| blob | 792ab330dd056e90cd4df1b59386045ded988430 |
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 {
924 {
932 {
938 /* Replace the saved decl. */
942 }
943 }
946 {
950 }
951 }
953 \f
955 /* Returns true if functions FN1 and FN2 have equivalent trailing
956 requires clauses. */
958 static bool
960 {
961 /* In the concepts TS, the combined constraints are compared. */
963 {
969 }
971 /* Compare only trailing requirements. */
977 /* Substitution is needed when friends are involved. */
982 }
984 /* Two functions of the same name correspond [basic.scope.scope] if
986 + both declare functions with the same non-object-parameter-type-list,
987 equivalent ([temp.over.link]) trailing requires-clauses (if any, except as
988 specified in [temp.friend]), and, if both are non-static members, they have
989 corresponding object parameters, or
991 + both declare function templates with equivalent
992 non-object-parameter-type-lists, return types (if any), template-heads, and
993 trailing requires-clauses (if any), and, if both are non-static members,
994 they have corresponding object parameters.
996 This is a subset of decls_match: it identifies declarations that cannot be
997 overloaded with one another. This function does not consider DECL_NAME. */
999 bool
1001 {
1006 {
1011 }
1019 /* If only one is a non-static member function, ignore ref-quals. */
1022 /* Two non-static member functions have corresponding object parameters if:
1023 + exactly one is an implicit object member function with no ref-qualifier
1024 and the types of their object parameters ([dcl.fct]), after removing
1025 top-level references, are the same, or
1026 + their object parameters have the same type. */
1027 /* ??? We treat member functions of different classes as corresponding even
1028 though that means the object parameters have different types. */
1035 {
1039 }
1041 /* Two function declarations match if either has a requires-clause
1042 then both have a requires-clause and their constraints-expressions
1043 are equivalent. */
1048 }
1050 /* Subroutine of duplicate_decls: return truthvalue of whether
1051 or not types of these decls match.
1053 For C++, we must compare the parameter list so that `int' can match
1054 `int&' in a parameter position, but `int&' is not confused with
1055 `const int&'. */
1057 int
1059 {
1066 /* If the two DECLs are not even the same kind of thing, we're not
1067 interested in their types. */
1073 {
1074 /* Specializations of different templates are different functions
1075 even if they have the same type. */
1090 /* A new declaration doesn't match a built-in one unless it
1091 is also extern "C". */
1101 /* A declaration with deduced return type should use its pre-deduction
1102 type for declaration matching. */
1110 {
1113 {
1117 }
1118 else
1119 types_match =
1125 }
1126 else
1129 /* Two function declarations match if either has a requires-clause
1130 then both have a requires-clause and their constraints-expressions
1131 are equivalent. */
1135 /* The decls dont match if they correspond to two different versions
1136 of the same function. Disallow extern "C" functions to be
1137 versions for now. */
1142 {
1148 }
1149 }
1151 {
1161 /* Two template types match if they are the same. Otherwise, compare
1162 the underlying declarations. */
1165 else
1167 }
1168 else
1169 {
1170 /* Need to check scope for variable declaration (VAR_DECL).
1171 For typedef (TYPE_DECL), scope is ignored. */
1174 /* [dcl.link]
1175 Two declarations for an object with C language linkage
1176 with the same name (ignoring the namespace that qualify
1177 it) that appear in different namespace scopes refer to
1178 the same object. */
1188 else
1191 COMPARE_REDECLARATION);
1192 }
1195 }
1197 /* Mark DECL as versioned if it isn't already. */
1199 static void
1201 {
1203 {
1205 /* If DECL_ASSEMBLER_NAME has already been set, re-mangle
1206 to include the version marker. */
1209 }
1210 }
1212 /* NEWDECL and OLDDECL have identical signatures. If they are
1213 different versions adjust them and return true.
1214 If RECORD is set to true, record function versions. */
1216 bool
1218 {
1224 {
1227 }
1231 {
1232 /* Unfortunately, we can get here before pushdecl naturally calls
1233 push_local_extern_decl_alias, so we need to call it directly. */
1238 }
1244 }
1246 /* If NEWDECL is `static' and an `extern' was seen previously,
1247 warn about it. OLDDECL is the previous declaration.
1249 Note that this does not apply to the C++ case of declaring
1250 a variable `extern const' and then later `const'.
1252 Don't complain about built-in functions, since they are beyond
1253 the user's control. */
1255 void
1257 {
1264 /* Don't get confused by static member functions; that's a different
1265 use of `static'. */
1270 /* If the old declaration was `static', or the new one isn't, then
1271 everything is OK. */
1275 /* It's OK to declare a builtin function as `static'. */
1280 auto_diagnostic_group d;
1285 }
1287 /* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1288 function templates. If their exception specifications do not
1289 match, issue a diagnostic. */
1291 static void
1293 tree old_decl)
1294 {
1298 /* Two default specs are equivalent, don't force evaluation. */
1304 {
1307 }
1311 /* [except.spec]
1313 If any declaration of a function has an exception-specification,
1314 all declarations, including the definition and an explicit
1315 specialization, of that function shall have an
1316 exception-specification with the same set of type-ids. */
1320 {
1325 auto_diagnostic_group d;
1329 /* We used to silently permit mismatched eh specs with
1330 -fno-exceptions, so make them a pedwarn now. */
1332 else
1337 }
1338 }
1340 /* Return true if OLD_DECL and NEW_DECL agree on constexprness.
1341 Otherwise issue diagnostics. */
1343 static bool
1345 {
1353 {
1359 }
1361 {
1362 /* With -fimplicit-constexpr, ignore changes in the constexpr
1363 keyword. */
1369 {
1370 /* Hide a built-in declaration. */
1376 }
1377 /* 7.1.5 [dcl.constexpr]
1378 Note: An explicit specialization can differ from the template
1379 declaration with respect to the constexpr specifier. */
1389 "redeclaration %qD differs in %qs "
1391 kind);
1395 }
1397 }
1399 // If OLDDECL and NEWDECL are concept declarations with the same type
1400 // (i.e., and template parameters), but different requirements,
1401 // emit diagnostics and return true. Otherwise, return false.
1404 {
1416 {
1421 {
1424 }
1425 }
1427 }
1429 /* DECL is a redeclaration of a function or function template. If
1430 it does have default arguments issue a diagnostic. Note: this
1431 function is used to enforce the requirements in C++11 8.3.6 about
1432 no default arguments in redeclarations. */
1434 static void
1436 {
1442 {
1444 "redeclaration of %q#D may not have default "
1447 }
1448 }
1450 /* NEWDECL is a redeclaration of a function or function template OLDDECL,
1451 in any case represented as FUNCTION_DECLs (the DECL_TEMPLATE_RESULTs of
1452 the TEMPLATE_DECLs in case of function templates). This function is used
1453 to enforce the final part of C++17 11.3.6/4, about a single declaration:
1454 "If a friend declaration specifies a default argument expression, that
1455 declaration shall be a definition and shall be the only declaration of
1456 the function or function template in the translation unit." */
1458 static void
1460 {
1470 {
1471 auto_diagnostic_group d;
1473 "friend declaration of %q#D specifies default "
1478 }
1479 }
1481 /* Merge tree bits that correspond to attributes noreturn, nothrow,
1482 const, malloc, and pure from NEWDECL with those of OLDDECL. */
1484 static void
1486 {
1499 }
1501 #define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn) \
1503 DECL_ATTRIBUTES (fn)))
1505 /* A subroutine of duplicate_decls. Emits a diagnostic when newdecl
1506 ambiguates olddecl. Returns true if an error occurs. */
1508 static bool
1510 {
1514 /* Function template declarations can be differentiated by parameter
1515 and return type. */
1520 {
1521 /* ... and also by their template-heads and requires-clauses. */
1524 {
1529 }
1531 /* FIXME: The types are the same but the are differences
1532 in either the template heads or function requirements.
1533 We should be able to diagnose a set of common errors
1534 stemming from these declarations. For example:
1536 template<typename T> requires C void f(...);
1537 template<typename T> void f(...) requires C;
1539 These are functionally equivalent but not equivalent. */
1540 }
1543 }
1545 /* OLD_PARMS is the innermost set of template parameters for some template
1546 declaration, and NEW_PARMS is the corresponding set of template parameters
1547 for a redeclaration of that template. Merge the default arguments within
1548 these two sets of parameters. CLASS_P is true iff the template in
1549 question is a class template. */
1551 bool
1553 {
1557 {
1565 {
1566 auto_diagnostic_group d;
1571 }
1573 /* Update the previous template parameters (which are the ones
1574 that will really count) with the new default value. */
1577 /* Update the new parameters, too; they'll be used as the
1578 parameters for any members. */
1580 }
1582 }
1584 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1585 If the redeclaration is invalid, a diagnostic is issued, and the
1586 error_mark_node is returned. Otherwise, OLDDECL is returned.
1588 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1589 returned.
1591 HIDING is true if the new decl is being hidden. WAS_HIDDEN is true
1592 if the old decl was hidden.
1594 Hidden decls can be anticipated builtins, injected friends, or
1595 (coming soon) injected from a local-extern decl. */
1597 tree
1599 {
1603 tree new_template_info;
1612 /* If either the type of the new decl or the type of the old decl is an
1613 error_mark_node, then that implies that we have already issued an
1614 error (earlier) for some bogus type specification, and in that case,
1615 it is rather pointless to harass the user with yet more error message
1616 about the same declaration, so just pretend the types match here. */
1621 /* Check for redeclaration and other discrepancies. */
1624 {
1626 {
1627 /* Avoid warnings redeclaring built-ins which have not been
1628 explicitly declared. */
1630 {
1634 OPT_Wbuiltin_declaration_mismatch,
1636 newdecl);
1638 }
1640 /* If you declare a built-in or predefined function name as static,
1641 the old definition is overridden, but optionally warn this was a
1642 bad choice of name. */
1644 {
1646 OPT_Wshadow,
1650 /* Discard the old built-in function. */
1652 }
1653 /* If the built-in is not ansi, then programs can override
1654 it even globally without an error. */
1659 else
1661 "declaration of %q#D conflicts with built-in "
1664 }
1666 {
1667 /* Avoid warnings redeclaring built-ins which have not been
1668 explicitly declared. */
1670 {
1673 /* A new declaration doesn't match a built-in one unless it
1674 is also extern "C". */
1684 {
1687 /* FILE, tm types are not known at the time
1688 we create the builtins. */
1694 {
1701 {
1711 }
1713 }
1717 next_arg:;
1718 }
1721 OPT_Wbuiltin_declaration_mismatch,
1722 "declaration of %q#D conflicts with built-in "
1724 }
1729 {
1730 /* Don't really override olddecl for __* prefixed builtins
1731 except for __[^b]*_chk, the compiler might be using those
1732 explicitly. */
1734 {
1745 {
1747 {
1749 "definition of %q#D ambiguates built-in "
1752 }
1753 auto_diagnostic_group d;
1755 "new declaration %q#D ambiguates built-in"
1761 }
1762 }
1764 /* A near match; override the builtin. */
1768 OPT_Wbuiltin_declaration_mismatch,
1769 "new declaration %q#D ambiguates built-in "
1771 else
1776 }
1777 else
1778 /* Discard the old built-in function. */
1781 /* Replace the old RTL to avoid problems with inlining. */
1783 }
1784 else
1785 {
1786 /* Even if the types match, prefer the new declarations type
1787 for built-ins which have not been explicitly declared,
1788 for exception lists, etc... */
1795 }
1797 /* If a function is explicitly declared "throw ()", propagate that to
1798 the corresponding builtin. */
1800 && was_hidden
1803 {
1808 }
1810 /* Whether or not the builtin can throw exceptions has no
1811 bearing on this declarator. */
1815 {
1816 /* If a builtin function is redeclared as `static', merge
1817 the declarations, but make the original one static. */
1821 /* Make the old declaration consistent with the new one so
1822 that all remnants of the builtin-ness of this function
1823 will be banished. */
1826 }
1827 }
1829 {
1830 /* C++ Standard, 3.3, clause 4:
1831 "[Note: a namespace name or a class template name must be unique
1832 in its declarative region (7.3.2, clause 14). ]" */
1853 {
1854 /* One is a function and the other is a template
1855 function. */
1859 /* There can only be one! */
1863 "literal operator %q#D conflicts with"
1867 "raw literal operator %q#D conflicts with"
1869 else
1874 }
1880 /* One is an implicit typedef, that's ok. */
1887 }
1889 {
1891 /* These are certainly not duplicate declarations; they're
1892 from different scopes. */
1896 {
1900 /* The name of a class template may not be declared to refer to
1901 any other template, class, function, object, namespace, value,
1902 or type in the same scope. */
1905 {
1911 }
1915 {
1919 }
1923 }
1925 {
1927 {
1930 newdecl);
1934 }
1935 /* For function versions, params and types match, but they
1936 are not ambiguous. */
1939 // The functions have the same parameter types.
1942 // And the same constraints.
1944 {
1950 }
1951 else
1953 }
1954 else
1955 {
1960 }
1961 }
1964 {
1965 /* OMP UDRs are never duplicates. */
1972 }
1982 /* It's OK to have a template specialization and a non-template
1983 with the same type, or to have specializations of two
1984 different templates with the same type. Note that if one is a
1985 specialization, and the other is an instantiation of the same
1986 template, that we do not exit at this point. That situation
1987 can occur if we instantiate a template class, and then
1988 specialize one of its methods. This situation is valid, but
1989 the declarations must be merged in the usual way. */
1996 /* One of the declarations is a template instantiation, and the
1997 other is not a template at all. That's OK. */
2000 {
2001 /* In [namespace.alias] we have:
2003 In a declarative region, a namespace-alias-definition can be
2004 used to redefine a namespace-alias declared in that declarative
2005 region to refer only to the namespace to which it already
2006 refers.
2008 Therefore, if we encounter a second alias directive for the same
2009 alias, we can just ignore the second directive. */
2015 /* Leave it to update_binding to merge or report error. */
2017 }
2018 else
2019 {
2022 {
2023 auto_diagnostic_group d;
2031 }
2036 {
2037 /* Prototype decl follows defn w/o prototype. */
2038 auto_diagnostic_group d;
2043 }
2046 {
2047 /* [dcl.link]
2048 If two declarations of the same function or object
2049 specify different linkage-specifications ..., the program
2050 is ill-formed.... Except for functions with C++ linkage,
2051 a function declaration without a linkage specification
2052 shall not precede the first linkage specification for
2053 that function. A function can be declared without a
2054 linkage specification after an explicit linkage
2055 specification has been seen; the linkage explicitly
2056 specified in the earlier declaration is not affected by
2057 such a function declaration.
2059 DR 563 raises the question why the restrictions on
2060 functions should not also apply to objects. Older
2061 versions of G++ silently ignore the linkage-specification
2062 for this example:
2064 namespace N {
2065 extern int i;
2066 extern "C" int i;
2067 }
2069 which is clearly wrong. Therefore, we now treat objects
2070 like functions. */
2072 {
2073 /* There is no explicit linkage-specification, so we use
2074 the linkage from the previous declaration. */
2077 }
2078 else
2079 {
2080 auto_diagnostic_group d;
2087 }
2088 }
2091 ;
2093 {
2094 /* Note: free functions, as TEMPLATE_DECLs, are handled below. */
2097 as FUNCTION_DECLs. */
2099 /* C++11 8.3.6/6.
2100 Default arguments for a member function of a class
2101 template shall be specified on the initial declaration
2102 of the member function within the class template. */
2104 {
2109 {
2113 tree old_parms
2117 }
2118 }
2119 else
2120 {
2128 {
2131 {
2132 auto_diagnostic_group d;
2134 "default argument given for parameter "
2138 olddecl);
2139 }
2140 else
2141 {
2142 auto_diagnostic_group d;
2144 "default argument given for parameter %d "
2148 olddecl);
2149 }
2150 }
2152 /* C++17 11.3.6/4: "If a friend declaration specifies a default
2153 argument expression, that declaration... shall be the only
2154 declaration of the function or function template in the
2155 translation unit." */
2157 }
2158 }
2159 }
2161 /* Do not merge an implicit typedef with an explicit one. In:
2163 class A;
2164 ...
2165 typedef class A A __attribute__ ((foo));
2167 the attribute should apply only to the typedef. */
2183 {
2185 {
2188 else
2189 {
2192 }
2195 }
2199 {
2202 {
2205 }
2206 }
2209 }
2211 /* We have committed to returning OLDDECL at this point. */
2213 /* If new decl is `static' and an `extern' was seen previously,
2214 warn about it. */
2217 /* True to merge attributes between the declarations, false to
2218 set OLDDECL's attributes to those of NEWDECL (for template
2219 explicit specializations that specify their own attributes
2220 independent of those specified for the primary template). */
2226 {
2228 {
2234 /* [dcl.attr.noreturn]: The first declaration of a function shall
2235 specify the noreturn attribute if any declaration of that function
2236 specifies the noreturn attribute. */
2237 tree a;
2240 /* This applies to [[noreturn]] only, not its GNU variants. */
2244 {
2248 }
2249 }
2251 /* Now that functions must hold information normally held
2252 by field decls, there is extra work to do so that
2253 declaration information does not get destroyed during
2254 definition. */
2276 /* Optionally warn about more than one declaration for the same
2277 name, but don't warn about a function declaration followed by a
2278 definition. */
2281 /* Don't warn about extern decl followed by definition. */
2283 /* Don't warn if at least one is/was hidden. */
2285 /* Don't warn about declaration followed by specialization. */
2288 {
2289 auto_diagnostic_group d;
2291 OPT_Wredundant_decls,
2293 newdecl))
2296 }
2298 /* [dcl.fct.def.delete] A deleted definition of a function shall be the
2299 first declaration of the function or, for an explicit specialization
2300 of a function template, the first declaration of that
2301 specialization. */
2304 {
2306 {
2307 auto_diagnostic_group d;
2312 }
2314 }
2315 }
2317 /* Deal with C++: must preserve virtual function table size. */
2319 {
2329 }
2331 /* Copy all the DECL_... slots specified in the new decl except for
2332 any that we copy here from the old type. */
2336 else
2340 {
2345 /* The new decl should not already have gathered any
2346 specializations. */
2349 /* Make sure the contracts are equivalent. */
2352 /* Remove contracts from old_result so they aren't appended to
2353 old_result by the merge function. */
2360 {
2363 {
2364 /* Per C++11 8.3.6/4, default arguments cannot be added in
2365 later declarations of a function template. */
2367 /* C++17 11.3.6/4: "If a friend declaration specifies a default
2368 argument expression, that declaration... shall be the only
2369 declaration of the function or function template in the
2370 translation unit." */
2371 check_no_redeclaration_friend_default_args
2378 }
2386 {
2389 else
2400 }
2401 else
2402 {
2410 }
2411 }
2413 /* If the new declaration is a definition, update the file and
2414 line information on the declaration, and also make
2415 the old declaration the same definition. */
2417 {
2423 {
2430 }
2431 }
2434 }
2437 {
2441 /* Automatically handles default parameters. */
2443 tree newtype;
2445 /* For typedefs use the old type, as the new type's DECL_NAME points
2446 at newdecl, which will be ggc_freed. */
2448 {
2449 /* But NEWTYPE might have an attribute, honor that. */
2454 {
2458 }
2460 /* And remove the new type from the variants list. */
2462 {
2465 {
2467 /* If remove is the main variant, no need to remove that
2468 from the list. One of the DECL_ORIGINAL_TYPE
2469 variants, e.g. created for aligned attribute, might still
2470 refer to the newdecl TYPE_DECL though, so remove that one
2471 in that case. */
2477 {
2481 }
2482 }
2483 else
2487 {
2490 }
2491 }
2492 }
2495 else
2499 {
2501 /* For already initialized vars, TREE_READONLY could have been
2502 cleared in cp_finish_decl, because the var needs runtime
2503 initialization or destruction. Make sure not to set
2504 TREE_READONLY on it again. */
2521 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
2524 {
2525 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
2528 }
2529 }
2531 /* An explicit specialization of a function template or of a member
2532 function of a class template can be declared transaction_safe
2533 independently of whether the corresponding template entity is declared
2534 transaction_safe. */
2547 /* Lay the type out, unless already done. */
2561 /* Merge deprecatedness. */
2565 /* Merge unavailability. */
2569 /* Preserve function specific target and optimization options */
2571 {
2584 }
2585 else
2586 {
2587 /* Merge the const type qualifier. */
2590 /* Merge the volatile type qualifier. */
2593 }
2595 /* Merge the initialization information. */
2598 {
2602 {
2605 }
2606 }
2609 {
2622 else
2623 {
2624 /* Merge the noreturn bit. */
2630 }
2631 /* Keep the old RTL. */
2633 }
2636 {
2637 /* Keep the old RTL. We cannot keep the old RTL if the old
2638 declaration was for an incomplete object and the new
2639 declaration is not since many attributes of the RTL will
2640 change. */
2642 }
2643 }
2644 /* If cannot merge, then use the new type and qualifiers,
2645 and don't preserve the old rtl. */
2646 else
2647 {
2648 /* Clean out any memory we had of the old declaration. */
2658 }
2660 /* Merge the storage class information. */
2672 {
2674 /* This can happen if olddecl was brought in from the
2675 enclosing namespace via a using-decl. The new decl is
2676 then not a block-scope extern at all. */
2678 else
2679 {
2687 }
2688 }
2692 {
2704 {
2708 }
2711 {
2716 /* If the OLDDECL is an instantiation and/or specialization,
2717 then the NEWDECL must be too. But, it may not yet be marked
2718 as such if the caller has created NEWDECL, but has not yet
2719 figured out that it is a redeclaration. */
2726 }
2728 /* Don't really know how much of the language-specific
2729 values we should copy from old to new. */
2733 {
2736 {
2740 /* Remember the presence of explicit specialization args. */
2743 }
2745 /* We don't want to copy template info from a non-templated friend
2746 (PR105761), but these shouldn't have DECL_TEMPLATE_INFO now. */
2750 }
2753 {
2754 /* Only functions have these fields. */
2759 /* DECL_THUNKS is only valid for virtual functions,
2760 otherwise it is a DECL_FRIEND_CONTEXT. */
2765 }
2767 {
2768 /* Only variables have this field. */
2771 }
2772 }
2775 {
2776 tree parm;
2778 /* Merge parameter attributes. */
2783 {
2787 }
2791 {
2792 /* If newdecl is not a specialization, then it is not a
2793 template-related function at all. And that means that we
2794 should have exited above, returning 0. */
2798 /* From [temp.expl.spec]:
2800 If a template, a member template or the member of a class
2801 template is explicitly specialized then that
2802 specialization shall be declared before the first use of
2803 that specialization that would cause an implicit
2804 instantiation to take place, in every translation unit in
2805 which such a use occurs. */
2807 olddecl);
2813 /* Don't propagate visibility from the template to the
2814 specialization here. We'll do that in determine_visibility if
2815 appropriate. */
2818 /* [temp.expl.spec/14] We don't inline explicit specialization
2819 just because the primary template says so. */
2829 }
2831 {
2832 /* Never inline re-defined extern inline functions.
2833 FIXME: this could be better handled by keeping both
2834 function as separate declarations. */
2836 }
2837 else
2838 {
2840 {
2844 }
2846 ;
2860 }
2862 /* Preserve abstractness on cloned [cd]tors. */
2865 /* Update newdecl's parms to point at olddecl. */
2871 {
2875 }
2877 {
2878 /* These are the final DECL_ARGUMENTS that will be used within the
2879 body; update any references to old DECL_ARGUMENTS in the
2880 contracts, if present. */
2884 /* These need to be copied so that the names are available.
2885 Note that if the types do match, we'll preserve inline
2886 info and other bits, but if not, we won't. */
2890 /* In some cases, duplicate_contracts will remove contracts from
2891 OLDDECL, to avoid duplications. Sometimes, the contracts end up
2892 shared. If we removed them, re-add them. */
2895 }
2896 /* If redeclaring a builtin function, it stays built in
2897 if newdecl is a gnu_inline definition, or if newdecl is just
2898 a declaration. */
2901 {
2903 /* If we're keeping the built-in definition, keep the rtl,
2904 regardless of declaration matches. */
2907 {
2910 {
2911 /* A compatible prototype of these builtin functions
2912 is seen, assume the runtime implements it with
2913 the expected semantics. */
2915 {
2922 }
2923 }
2926 }
2927 }
2929 /* If defining a function declared with other language
2930 linkage, use the previously declared language linkage. */
2933 {
2935 /* Don't clear out the arguments if we're just redeclaring a
2936 function. */
2938 {
2939 /* If we removed contracts from previous definition, re-attach
2940 them. Otherwise, rewrite the contracts so they match the
2941 parameters of the new declaration. */
2946 else
2947 {
2948 /* Temporarily undo the re-contexting of parameters so we can
2949 actually remap parameters. The inliner won't replace
2950 parameters if we don't do this. */
2955 /* Save new argument names for use in contracts parsing,
2956 unless we've already started parsing the body of olddecl
2957 (particular issues arise when newdecl is from a prior
2958 friend decl with no argument names, see
2959 modules/contracts-tpl-friend-1). */
2963 /* And reverse this operation again. */
2966 }
2969 }
2970 }
2971 }
2975 /* Now preserve various other info from the definition. */
2981 /* Warn about conflicting visibility specifications. */
2985 {
2986 auto_diagnostic_group d;
2988 "%qD: visibility attribute ignored because it "
2992 }
2993 /* Choose the declaration which specified visibility. */
2995 {
2998 }
2999 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
3000 so keep this behavior. */
3002 {
3005 }
3006 /* Likewise for DECL_ALIGN, DECL_USER_ALIGN and DECL_PACKED. */
3008 {
3011 }
3024 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
3025 with that from NEWDECL below. */
3027 {
3031 }
3033 /* Merge the USED information. */
3040 {
3045 }
3052 /* Merge the DECL_FUNCTION_VERSIONED information. newdecl will be copied
3053 to olddecl and deleted. */
3056 {
3057 /* Set the flag for newdecl so that it gets copied to olddecl. */
3059 /* newdecl will be purged after copying to olddecl and is no longer
3060 a version. */
3062 }
3065 {
3079 /* Preserve symtab node mapping. */
3083 /* If newdecl is a template instantiation, it is possible that
3084 the following sequence of events has occurred:
3086 o A friend function was declared in a class template. The
3087 class template was instantiated.
3089 o The instantiation of the friend declaration was
3090 recorded on the instantiation list, and is newdecl.
3092 o Later, however, instantiate_class_template called pushdecl
3093 on the newdecl to perform name injection. But, pushdecl in
3094 turn called duplicate_decls when it discovered that another
3095 declaration of a global function with the same name already
3096 existed.
3098 o Here, in duplicate_decls, we decided to clobber newdecl.
3100 If we're going to do that, we'd better make sure that
3101 olddecl, and not newdecl, is on the list of
3102 instantiations so that if we try to do the instantiation
3103 again we won't get the clobbered declaration. */
3105 new_template_info,
3106 olddecl);
3107 }
3108 else
3109 {
3117 {
3125 {
3138 }
3146 }
3147 }
3150 {
3154 {
3155 /* Merge the section attribute.
3156 We want to issue an error if the sections conflict but that must be
3157 done later in decl_attributes since we are called before attributes
3158 are assigned. */
3163 {
3167 else
3171 }
3172 }
3176 {
3180 }
3181 }
3185 /* NEWDECL contains the merged attribute lists.
3186 Update OLDDECL to be the same. */
3189 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
3190 so that encode_section_info has a chance to look at the new decl
3191 flags and attributes. */
3198 /* The NEWDECL will no longer be needed. Because every out-of-class
3199 declaration of a member results in a call to duplicate_decls,
3200 freeing these nodes represents in a significant savings.
3202 Before releasing the node, be sore to remove function from symbol
3203 table that might have been inserted there to record comdat group.
3204 Be sure to however do not free DECL_STRUCT_FUNCTION because this
3205 structure is shared in between newdecl and oldecl. */
3209 {
3213 }
3216 {
3217 tree clone;
3219 {
3222 }
3223 }
3225 /* Remove the associated constraints for newdecl, if any, before
3226 reclaiming memory. */
3233 }
3234 \f
3235 /* Return zero if the declaration NEWDECL is valid
3236 when the declaration OLDDECL (assumed to be for the same name)
3237 has already been seen.
3238 Otherwise return an error message format string with a %s
3239 where the identifier should go. */
3243 {
3245 {
3246 /* Because C++ can put things into name space for free,
3247 constructs like "typedef struct foo { ... } foo"
3248 would look like an erroneous redeclaration. */
3251 else
3253 }
3255 {
3256 /* If this is a pure function, its olddecl will actually be
3257 the original initialization to `0' (which we force to call
3258 abort()). Don't complain about redefinition in this case. */
3263 /* If both functions come from different namespaces, this is not
3264 a redeclaration - this is a conflict with a used function. */
3270 /* We'll complain about linkage mismatches in
3271 warn_extern_redeclared_static. */
3273 /* Defining the same name twice is no good. */
3276 {
3282 }
3285 {
3290 {
3294 else
3297 }
3298 }
3304 /* [class.compare.default]: A definition of a comparison operator as
3305 defaulted that appears in a class shall be the first declaration of
3306 that function. */
3312 check_abi_tag_redeclaration
3317 }
3319 {
3343 {
3348 {
3352 else
3355 }
3356 }
3362 /* Core issue #226 (C++11):
3364 If a friend function template declaration specifies a
3365 default template-argument, that declaration shall be a
3366 definition and shall be the only declaration of the
3367 function template in the translation unit. */
3378 }
3385 {
3386 /* Only variables can be thread-local, and all declarations must
3387 agree on this property. */
3391 else
3394 }
3396 {
3397 /* The objects have been declared at namespace scope. If either
3398 is a member of an anonymous union, then this is an invalid
3399 redeclaration. For example:
3401 int i;
3402 union { int i; };
3404 is invalid. */
3408 /* If at least one declaration is a reference, there is no
3409 conflict. For example:
3411 int i = 3;
3412 extern int i;
3414 is valid. */
3418 /* Static data member declared outside a class definition
3419 if the variable is defined within the class with constexpr
3420 specifier is declaration rather than definition (and
3421 deprecated). */
3427 {
3429 /* For now, only warn with explicit -Wdeprecated. */
3431 {
3432 auto_diagnostic_group d;
3434 "redundant redeclaration of %<constexpr%> "
3438 }
3440 }
3442 /* Reject two definitions. */
3444 }
3445 else
3446 {
3447 /* Objects declared with block scope: */
3448 /* Reject two definitions, and reject a definition
3449 together with an external reference. */
3453 }
3454 }
3455 \f
3457 /* Hash and equality functions for the named_label table. */
3459 hashval_t
3461 {
3463 }
3465 bool
3467 {
3469 }
3471 /* Look for a label named ID in the current function. If one cannot
3472 be found, create one. Return the named_label_entry, or NULL on
3473 failure. */
3477 {
3480 /* You can't use labels at global scope. */
3482 {
3485 }
3491 named_label_entry **slot
3496 {
3501 {
3505 }
3506 }
3508 /* We are making a new decl, create or reuse the named_label_entry */
3512 else
3513 {
3518 }
3520 /* Now create the LABEL_DECL. */
3526 {
3530 }
3535 }
3537 /* Wrapper for lookup_label_1. */
3539 tree
3541 {
3544 }
3546 tree
3548 {
3551 }
3553 /* Returns true if it is ill-formed to jump past the declaration of DECL. */
3555 static bool
3557 {
3558 /* [stmt.dcl]/3: A program that jumps from a point where a local variable
3559 with automatic storage duration is not in scope to a point where it is
3560 in scope is ill-formed unless the variable has scalar type, class type
3561 with a trivial default constructor and a trivial destructor, a
3562 cv-qualified version of one of these types, or an array of one of the
3563 preceding types and is declared without an initializer (8.5). */
3571 }
3573 /* A subroutine of check_previous_goto_1 and check_goto to identify a branch
3574 to the user. */
3576 static bool
3578 diagnostic_t diag_kind)
3579 {
3580 bool complained
3587 }
3589 /* Check that a single previously seen jump to a newly defined label
3590 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
3591 the jump context; NAMES are the names in scope in LEVEL at the jump
3592 context; LOCUS is the source position of the jump or 0. Returns
3593 true if all is well. */
3595 static bool
3598 {
3606 {
3612 }
3615 {
3621 {
3627 {
3630 }
3634 }
3642 {
3675 {
3679 }
3681 {
3685 }
3690 }
3693 {
3699 }
3700 }
3703 }
3705 static void
3707 {
3711 }
3713 static bool
3715 {
3717 }
3719 /* Check that a new jump to a label DECL is OK. Called by
3720 finish_goto_stmt. */
3722 void
3724 {
3725 /* We can't know where a computed goto is jumping.
3726 So we assume that it's OK. */
3731 named_label_entry **slot
3735 /* If the label hasn't been defined yet, defer checking. */
3737 {
3738 /* Don't bother creating another use if the last goto had the
3739 same data, and will therefore create the same set of errors. */
3744 named_label_use_entry *new_use
3754 }
3758 tree bad;
3765 {
3774 }
3777 {
3781 {
3782 /* Can't skip init of __exception_info. */
3784 {
3788 }
3792 }
3796 }
3799 {
3812 }
3815 {
3818 }
3821 {
3825 {
3827 {
3832 }
3836 }
3837 }
3838 }
3840 /* Check that a return is ok wrt OpenMP structured blocks.
3841 Called by finish_return_stmt. Returns true if all is well. */
3843 bool
3845 {
3848 {
3851 }
3855 }
3857 /* Define a label, specifying the location in the source file.
3858 Return the LABEL_DECL node for the label. */
3860 tree
3862 {
3865 /* After labels, make any new cleanups in the function go into their
3866 own new (temporary) binding contour. */
3876 {
3879 }
3880 else
3881 {
3882 /* Mark label as having been defined. */
3884 /* Say where in the source. */
3893 }
3896 }
3898 struct cp_switch
3899 {
3902 /* The SWITCH_STMT being built. */
3903 tree switch_stmt;
3904 /* A splay-tree mapping the low element of a case range to the high
3905 element, or NULL_TREE if there is no high element. Used to
3906 determine whether or not a new case label duplicates an old case
3907 label. We need a tree, rather than simply a hash table, because
3908 of the GNU case range extension. */
3909 splay_tree cases;
3910 /* Remember whether a default: case label has been seen. */
3912 /* Remember whether a BREAK_STMT has been seen in this SWITCH_STMT. */
3914 /* Set if inside of {FOR,DO,WHILE}_BODY nested inside of a switch,
3915 where BREAK_STMT doesn't belong to the SWITCH_STMT. */
3917 };
3919 /* A stack of the currently active switch statements. The innermost
3920 switch statement is on the top of the stack. There is no need to
3921 mark the stack for garbage collection because it is only active
3922 during the processing of the body of a function, and we never
3923 collect at that point. */
3927 /* Called right after a switch-statement condition is parsed.
3928 SWITCH_STMT is the switch statement being parsed. */
3930 void
3932 {
3942 }
3944 void
3946 {
3949 /* Emit warnings as needed. */
3952 const bool bool_cond_p
3958 bool_cond_p);
3960 /* For the benefit of block_may_fallthru remember if the switch body
3961 case labels cover all possible values and if there are break; stmts. */
3963 || (!processing_template_decl
3969 /* Now that we're done with the switch warnings, set the switch type
3970 to the type of the condition if the index type was of scoped enum type.
3971 (Such types don't participate in the integer promotions.) We do this
3972 because of bit-fields whose declared type is a scoped enum type:
3973 gimplification will use the lowered index type, but convert the
3974 case values to SWITCH_STMT_TYPE, which would have been the declared type
3975 and verify_gimple_switch doesn't accept that. */
3982 }
3984 /* Note that a BREAK_STMT is about to be added. If it is inside of
3985 a SWITCH_STMT and not inside of a loop body inside of it, note
3986 in switch_stack we've seen a BREAK_STMT. */
3988 void
3990 {
3993 }
3995 /* Note the start of processing of an iteration statement's body.
3996 The note_break_stmt function will do nothing while processing it.
3997 Return a flag that should be passed to note_iteration_stmt_body_end. */
3999 bool
4001 {
4007 }
4009 /* Note the end of processing of an iteration statement's body. */
4011 void
4013 {
4016 }
4018 /* Convert a case constant VALUE in a switch to the type TYPE of the switch
4019 condition. Note that if TYPE and VALUE are already integral we don't
4020 really do the conversion because the language-independent
4021 warning/optimization code will work better that way. */
4023 static tree
4025 {
4035 /* The constant-expression VALUE shall be a converted constant expression
4036 of the adjusted type of the switch condition, which doesn't allow
4037 narrowing conversions. */
4044 else
4045 /* The already integral case. */
4049 }
4051 /* Note that we've seen a definition of a case label, and complain if this
4052 is a bad place for one. */
4054 tree
4056 {
4059 tree type;
4065 {
4066 tree label;
4068 /* For templates, just add the case label; we'll do semantic
4069 analysis at instantiation-time. */
4072 }
4074 /* Find the condition on which this switch statement depends. */
4091 /* After labels, make any new cleanups in the function go into their
4092 own new (temporary) binding contour. */
4099 }
4100 \f
4102 tree scope;
4103 tree name;
4104 tree template_id;
4107 };
4110 {
4113 /* Hash a TYPENAME_TYPE. */
4115 static hashval_t
4117 {
4122 }
4124 static hashval_t
4126 {
4128 }
4130 static hashval_t
4132 {
4134 }
4136 /* Compare two TYPENAME_TYPEs. */
4138 static bool
4140 {
4146 }
4147 };
4149 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
4150 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
4152 Returns the new TYPENAME_TYPE. */
4156 tree
4159 {
4160 typename_info ti;
4174 /* See if we already have this type. */
4179 else
4180 {
4181 /* Build the TYPENAME_TYPE. */
4188 /* Build the corresponding TYPE_DECL. */
4195 /* Store it in the hash table. */
4198 /* TYPENAME_TYPEs must always be compared structurally, because
4199 they may or may not resolve down to another type depending on
4200 the currently open classes. */
4202 }
4205 }
4207 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
4208 provided to name the type. Returns an appropriate type, unless an
4209 error occurs, in which case error_mark_node is returned. If we
4210 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
4211 return that, rather than the _TYPE it corresponds to, in other
4212 cases we look through the type decl. If TF_ERROR is set, complain
4213 about errors, otherwise be quiet. */
4215 tree
4217 tsubst_flags_t complain)
4218 {
4219 tree fullname;
4220 tree t;
4229 {
4234 else
4235 /* Create a TEMPLATE_ID_EXPR for the type. */
4239 }
4246 {
4251 {
4255 }
4256 }
4258 {
4262 }
4264 {
4268 }
4275 {
4279 }
4281 /* When the CONTEXT is a dependent type, NAME could refer to a
4282 dependent base class of CONTEXT. But look inside it anyway
4283 if CONTEXT is a currently open scope, in case it refers to a
4284 member of the current instantiation or a non-dependent base;
4285 lookup will stop when we hit a dependent base. */
4287 {
4288 /* We generally don't ignore non-types during TYPENAME_TYPE lookup
4289 (as per [temp.res.general]/3), unless
4290 - the tag corresponds to a class-key or 'enum' so
4291 [basic.lookup.elab] applies, or
4292 - the tag corresponds to scope_type or tf_qualifying_scope is
4293 set so [basic.lookup.qual]/1 applies.
4294 TODO: If we'd set/track the scope_type tag thoroughly on all
4295 TYPENAME_TYPEs that are followed by :: then we wouldn't need the
4296 tf_qualifying_scope flag. */
4300 }
4301 else
4310 {
4312 {
4315 else
4318 }
4320 }
4322 /* Pull out the template from an injected-class-name (or multiple). */
4327 {
4329 {
4332 }
4334 }
4337 {
4342 }
4344 {
4347 /* The caller permits this typename-specifier to name a template
4349 else
4350 {
4355 }
4356 }
4366 {
4374 }
4382 }
4384 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
4385 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
4386 in which case error_mark_node is returned.
4388 If PARM_LIST is non-NULL, also make sure that the template parameter
4389 list of TEMPLATE_DECL matches.
4391 If COMPLAIN zero, don't complain about any errors that occur. */
4393 tree
4395 tsubst_flags_t complain)
4396 {
4405 {
4415 {
4419 }
4423 {
4425 {
4429 }
4431 }
4434 complain))
4438 }
4441 }
4443 /* Build an UNBOUND_CLASS_TEMPLATE. */
4445 tree
4447 {
4448 /* Build the UNBOUND_CLASS_TEMPLATE. */
4454 /* Build the corresponding TEMPLATE_DECL. */
4463 }
4465 \f
4467 /* Push the declarations of builtin types into the global namespace.
4468 RID_INDEX is the index of the builtin type in the array
4469 RID_POINTERS. NAME is the name used when looking up the builtin
4470 type. TYPE is the _TYPE node for the builtin type.
4472 The calls to set_global_binding below should be
4473 eliminated. Built-in types should not be looked up name; their
4474 names are keywords that the parser can recognize. However, there
4475 is code in c-common.cc that uses identifier_global_value to look up
4476 built-in types by name. */
4478 void
4481 tree type)
4482 {
4486 {
4492 }
4497 {
4503 }
4506 {
4510 }
4511 }
4513 /* Push a type into the namespace so that the back ends ignore it. */
4515 static void
4517 {
4520 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
4527 }
4529 /* Create all the predefined identifiers. */
4531 static void
4533 {
4534 struct predefined_identifier
4535 {
4539 };
4541 /* A table of identifiers to create at startup. */
4545 /* Some of these names have a trailing space so that it is
4546 impossible for them to conflict with names written by users. */
4563 /* The demangler expects anonymous namespaces to be called
4564 something starting with '_GLOBAL__N_'. It no longer needs
4565 to be unique to the TU. */
4595 };
4599 {
4601 /* Some of these identifiers already have a special kind. */
4604 }
4605 }
4607 /* Create the predefined scalar types of C,
4608 and some nodes representing standard constants (0, 1, (void *)0).
4609 Initialize the global binding level.
4610 Make definitions for built-in primitive functions. */
4612 void
4614 {
4615 tree void_ftype;
4616 tree void_ftype_ptr;
4618 /* Create all the identifiers we need. */
4621 /* Create the global variables. */
4626 /* Enter the global namespace. */
4629 void_type_node);
4634 /* Remember whether we want the empty class passing ABI change warning
4635 in this TU. */
4638 debug_hooks->register_main_translation_unit
4646 /* Initially, C. */
4649 /* Create the `std' namespace. */
4659 tree decl
4665 /* The concrete return type of __builtin_source_location is
4666 const std::source_location::__impl*, but we can't form the type
4667 at this point. So we initially declare it with an auto return
4668 type which we then "deduce" from require_deduced_type upon first use. */
4676 NULL_TREE);
4677 decl
4679 bool_vaftype,
4680 CP_BUILT_IN_IS_CORRESPONDING_MEMBER,
4684 decl
4686 bool_vaftype,
4687 CP_BUILT_IN_IS_POINTER_INTERCONVERTIBLE_WITH_CLASS,
4693 /* Guess at the initial static decls size. */
4696 /* ... and keyed classes. */
4708 NULL_TREE);
4710 #if 0
4712 #endif
4721 void_ftype_ptr
4724 /* Create the conversion operator marker. This operator's DECL_NAME
4725 is in the identifier table, so we can use identifier equality to
4726 find it. */
4728 void_ftype);
4730 /* C++ extensions */
4735 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
4738 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
4739 result. */
4746 /* Used when parsing to distinguish parameter-lists () and (void). */
4749 {
4750 /* Make sure we get a unique function type, so we can give
4751 its pointer type a name. (This wins for gdb.) */
4758 }
4761 vtbl_type_node
4777 /* Now, C++. */
4782 {
4784 aligned_new_threshold);
4786 }
4792 {
4795 tree ptr_ftype_sizetype;
4796 tree new_eh_spec;
4798 ptr_ftype_sizetype
4801 {
4802 tree bad_alloc_id;
4803 tree bad_alloc_type_node;
4804 tree bad_alloc_decl;
4810 bad_alloc_decl
4815 new_eh_spec
4817 }
4818 else
4821 /* Ensure attribs.cc is initialized. */
4825 NULL_TREE);
4828 extvisattr);
4848 {
4849 /* Also push the sized deallocation variants:
4850 void operator delete(void*, std::size_t) throw();
4851 void operator delete[](void*, std::size_t) throw(); */
4852 tree void_ftype_ptr_size
4856 extvisattr);
4864 }
4867 {
4874 /* operator new (size_t, align_val_t); */
4888 /* operator delete (void *, align_val_t); */
4901 {
4902 /* operator delete (void *, size_t, align_val_t); */
4905 NULL_TREE);
4914 }
4915 }
4917 /* C++-specific nullptr initialization. */
4921 }
4926 abort_fndecl
4930 /* If no definition is available, resolve references to NULL. */
4933 /* Perform other language dependent initializations. */
4947 /* Show we use EH for cleanups. */
4951 /* Check that the hardware interference sizes are at least
4952 alignof(max_align_t), as required by the standard. */
4955 {
4961 "%<--param destructive-interference-size=%d%> "
4964 }
4969 /* else leave it unset. */
4972 {
4979 "%<--param constructive-interference-size=%d%> "
4982 }
4987 }
4989 /* Enter an abi node in global-module context. returns a cookie to
4990 give to pop_abi_namespace. */
4992 unsigned
4994 {
5000 }
5002 /* Pop an abi namespace, FLAGS is the cookie push_abi_namespace gave
5003 you. */
5005 void
5007 {
5011 }
5013 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give
5014 the decl, LOC is the location to give the decl, NAME is the
5015 initialization string and TYPE_DEP indicates whether NAME depended
5016 on the type of the function. We make use of that to detect
5017 __PRETTY_FUNCTION__ inside a template fn. This is being done lazily
5018 at the point of first use, so we mustn't push the decl now. */
5020 static tree
5022 {
5027 {
5034 {
5035 /* __FUNCTION__ */
5038 }
5039 else
5040 {
5041 /* __PRETTY_FUNCTION__ */
5044 }
5051 }
5058 else
5072 /* For decl_constant_var_p. */
5076 {
5081 }
5082 else
5083 {
5086 }
5089 }
5091 /* Install DECL as a builtin function at current global scope. Return
5092 the new decl (if we found an existing version). Also installs it
5093 into ::std, if it's not '_*'. */
5095 tree
5097 {
5102 /* Runtime library routines are, by definition, available in an
5103 external shared object. */
5111 /* In the user's namespace, it must be declared before use. */
5117 /* Treat __*_chk fortification functions as anticipated as well,
5118 unless they are __builtin_*_chk. */
5121 /* All builtins that don't begin with an '_' should additionally
5122 go in the 'std' namespace. */
5124 {
5131 }
5137 }
5139 /* Like cxx_builtin_function, but guarantee the function is added to the global
5140 scope. This is to allow function specific options to add new machine
5141 dependent builtins when the target ISA changes via attribute((target(...)))
5142 which saves space on program startup if the program does not use non-generic
5143 ISAs. */
5145 tree
5147 {
5153 }
5155 /* Implement LANG_HOOKS_SIMULATE_BUILTIN_FUNCTION_DECL. */
5157 tree
5159 {
5166 }
5168 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
5169 function. Not called directly. */
5171 static tree
5174 {
5182 /* Runtime library routines are, by definition, available in an
5183 external shared object. */
5188 }
5190 /* Returns the _DECL for a library function with C++ linkage. */
5192 static tree
5195 {
5200 }
5202 /* Like build_library_fn, but takes a C string instead of an
5203 IDENTIFIER_NODE. */
5205 tree
5207 {
5209 }
5211 /* Like build_cp_library_fn, but takes a C string instead of an
5212 IDENTIFIER_NODE. */
5214 tree
5216 {
5218 ecf_flags);
5219 }
5221 /* Like build_library_fn, but also pushes the function so that we will
5222 be able to find it via get_global_binding. Also, the function
5223 may throw exceptions listed in RAISES. */
5225 tree
5227 {
5233 }
5235 /* Like build_cp_library_fn, but also pushes the function so that it
5236 will be found by normal lookup. */
5238 static tree
5241 {
5248 }
5250 /* Like push_library_fn, but also note that this function throws
5251 and does not return. Used for __throw_foo and the like. */
5253 tree
5255 {
5258 }
5259 \f
5260 /* When we call finish_struct for an anonymous union, we create
5261 default copy constructors and such. But, an anonymous union
5262 shouldn't have such things; this function undoes the damage to the
5263 anonymous union type T.
5265 (The reason that we create the synthesized methods is that we don't
5266 distinguish `union { int i; }' from `typedef union { int i; } U'.
5267 The first is an anonymous union; the second is just an ordinary
5268 union type.) */
5270 void
5272 {
5273 /* Wipe out memory of synthesized methods. */
5281 /* Splice the implicitly generated functions out of TYPE_FIELDS and diagnose
5282 invalid members. */
5284 {
5287 else
5297 {
5298 /* We already complained about static data members in
5299 finish_static_data_member_decl. */
5301 {
5302 auto_diagnostic_group d;
5306 "only have public non-static data members"
5309 {
5312 {
5315 "this flexibility is deprecated and will be "
5317 }
5318 }
5319 }
5320 }
5321 }
5323 /* Splice all functions out of CLASSTYPE_MEMBER_VEC. */
5331 /* Wipe RTTI info. */
5334 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
5335 assignment operators (because they cannot have these methods themselves).
5336 For anonymous unions this is already checked because they are not allowed
5337 in any union, otherwise we have to check it. */
5339 {
5343 {
5345 /* Avoid ICE after error on anon-struct9.C. */
5347 }
5351 {
5354 {
5364 }
5365 }
5366 }
5367 }
5369 /* Warn for an attribute located at LOCATION that appertains to the
5370 class type CLASS_TYPE that has not been properly placed after its
5371 class-key, in it class-specifier. */
5373 void
5375 tree class_type)
5376 {
5379 auto_diagnostic_group d;
5381 "attribute ignored in declaration "
5386 }
5388 /* Returns the cv-qualifiers that apply to the type specified
5389 by the DECLSPECS. */
5391 static int
5393 {
5404 }
5406 /* Make sure that a declaration with no declarator is well-formed, i.e.
5407 just declares a tagged type or anonymous union.
5409 Returns the type declared; or NULL_TREE if none. */
5411 tree
5414 {
5417 /* If a class, struct, or enum type is declared by the DECLSPECS
5418 (i.e, if a class-specifier, enum-specifier, or non-typename
5419 elaborated-type-specifier appears in the DECLSPECS),
5420 DECLARED_TYPE is set to the corresponding type. */
5428 {
5434 }
5446 {
5448 "%<auto%> can only be specified for variables "
5451 }
5458 /* Check for an anonymous union. */
5461 {
5462 /* 7/3 In a simple-declaration, the optional init-declarator-list
5463 can be omitted only when declaring a class (clause 9) or
5464 enumeration (7.2), that is, when the decl-specifier-seq contains
5465 either a class-specifier, an elaborated-type-specifier with
5466 a class-key (9.1), or an enum-specifier. In these cases and
5467 whenever a class-specifier or enum-specifier is present in the
5468 decl-specifier-seq, the identifiers in these specifiers are among
5469 the names being declared by the declaration (as class-name,
5470 enum-names, or enumerators, depending on the syntax). In such
5471 cases, and except for the declaration of an unnamed bit-field (9.6),
5472 the decl-specifier-seq shall introduce one or more names into the
5473 program, or shall redeclare a name introduced by a previous
5474 declaration. [Example:
5475 enum { }; // ill-formed
5476 typedef class { }; // ill-formed
5477 --end example] */
5479 {
5483 }
5490 }
5492 else
5493 {
5501 && (!current_class_type
5510 "a storage class can only be specified for objects "
5514 "%<const%> can only be specified for objects and "
5518 "%<volatile%> can only be specified for objects and "
5522 "%<__restrict%> can only be specified for objects and "
5526 "%<__thread%> can only be specified for objects "
5540 }
5543 {
5544 location_t loc;
5547 /* For a non-template class, use the name location. */
5549 else
5550 /* For a template class (an explicit instantiation), use the
5551 current location. */
5555 /* [dcl.attr.grammar]/4:
5557 No attribute-specifier-seq shall appertain to an explicit
5558 instantiation. */
5559 {
5562 declared_type))
5564 "no attribute can be applied to "
5566 }
5567 else
5569 }
5571 /* Diagnose invalid application of contracts, if any. */
5574 else
5578 }
5580 /* Called when a declaration is seen that contains no names to declare.
5581 If its type is a reference to a structure, union or enum inherited
5582 from a containing scope, shadow that tag name for the current scope
5583 with a forward reference.
5584 If its type defines a new named structure or union
5585 or defines an enum, it is valid but we need not do anything here.
5586 Otherwise, it is an error.
5588 C++: may have to grok the declspecs to learn about static,
5589 complain for anonymous unions.
5591 Returns the TYPE declared -- or NULL_TREE if none. */
5593 tree
5595 {
5606 /* This is where the variables in an anonymous union are
5607 declared. An anonymous union declaration looks like:
5608 union { ... } ;
5609 because there is no declarator after the union, the parser
5610 sends that declaration here. */
5612 {
5616 {
5620 }
5621 }
5624 }
5625 \f
5626 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
5628 tree
5632 {
5633 tree attrs;
5634 tree type;
5635 enum decl_context context
5641 {
5646 /* A template type parameter or other dependent type. */
5649 else
5651 }
5653 }
5655 /* Process a DECLARATOR for a function-scope or namespace-scope
5656 variable or function declaration.
5657 (Function definitions go through start_function; class member
5658 declarations appearing in the body of the class go through
5659 grokfield.) The DECL corresponding to the DECLARATOR is returned.
5660 If an error occurs, the error_mark_node is returned instead.
5662 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED is
5663 SD_INITIALIZED if an explicit initializer is present, or SD_DEFAULTED
5664 for an explicitly defaulted function, or SD_DELETED for an explicitly
5665 deleted function, but 0 (SD_UNINITIALIZED) if this is a variable
5666 implicitly initialized via a default constructor. It can also be
5667 SD_DECOMPOSITION which behaves much like SD_INITIALIZED, but we also
5668 mark the new decl as DECL_DECOMPOSITION_P.
5670 ATTRIBUTES and PREFIX_ATTRIBUTES are GNU attributes associated with this
5671 declaration.
5673 The scope represented by the context of the returned DECL is pushed
5674 (if it is not the global namespace) and is assigned to
5675 *PUSHED_SCOPE_P. The caller is then responsible for calling
5676 pop_scope on *PUSHED_SCOPE_P if it is set. */
5678 tree
5682 tree attributes,
5683 tree prefix_attributes,
5685 {
5686 tree decl;
5687 tree context;
5691 tree initial;
5711 {
5716 }
5718 /* Save the DECL_INITIAL value in case it gets clobbered to assist
5719 with attribute validation. */
5723 {
5727 decl);
5731 /* Tell 'cplus_decl_attributes' this is an initialized decl,
5732 even though we might not yet have the initializer expression. */
5735 }
5741 /* If this is a typedef that names the class for linkage purposes
5742 (7.1.3p8), apply any attributes directly to the type. */
5747 else
5750 /* Set attributes here so if duplicate decl, will have proper attributes. */
5753 /* Restore the original DECL_INITIAL that we may have clobbered earlier to
5754 assist with attribute validation. */
5757 /* Dllimported symbols cannot be defined. Static data members (which
5758 can be initialized in-class and dllimported) go through grokfield,
5759 not here, so we don't need to exclude those decls when checking for
5760 a definition. */
5762 {
5766 }
5768 /* If #pragma weak was used, mark the decl weak now. */
5780 {
5784 {
5794 {
5800 }
5801 else
5802 {
5807 {
5814 }
5815 /* Static data member are tricky; an in-class initialization
5816 still doesn't provide a definition, so the in-class
5817 declaration will have DECL_EXTERNAL set, but will have an
5818 initialization. Thus, duplicate_decls won't warn
5819 about this situation, and so we check here. */
5827 }
5828 }
5829 else
5830 {
5832 this_tmpl
5833 ? current_template_parms
5838 }
5840 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
5842 /* Do not mark DECL as an explicit specialization if it was not
5843 already marked as an instantiation; a declaration should
5844 never be marked as a specialization unless we know what
5845 template is being specialized. */
5847 {
5852 else
5855 /* [temp.expl.spec] An explicit specialization of a static data
5856 member of a template is a definition if the declaration
5857 includes an initializer; otherwise, it is a declaration.
5859 We check for processing_specialization so this only applies
5860 to the new specialization syntax. */
5863 }
5866 /* Aliases are definitions. */
5868 {
5872 decl);
5876 decl);
5877 }
5878 }
5880 /* Create a DECL_LANG_SPECIFIC so that DECL_DECOMPOSITION_P works. */
5888 {
5889 /* A function-scope decl of some namespace-scope decl. */
5893 "block-scope extern declaration %q#D not permitted"
5895 }
5897 /* Enter this declaration into the symbol table. Don't push the plain
5898 VAR_DECL for a variable template. */
5912 /* But not templated variables. */
5914 {
5915 /* This is a const variable with implicit 'static'. Set
5916 DECL_THIS_STATIC so we can tell it from variables that are
5917 !TREE_PUBLIC because of the anonymous namespace. */
5920 }
5925 {
5929 "%qD defined %<thread_local%> in %qs function only "
5935 "%qD defined %<static%> in %qs function only available "
5939 else
5943 }
5949 }
5951 /* Process the declaration of a variable DECL. INITIALIZED is true
5952 iff DECL is explicitly initialized. (INITIALIZED is false if the
5953 variable is initialized via an implicitly-called constructor.)
5954 This function must be called for ordinary variables (including, for
5955 example, implicit instantiations of templates), but must not be
5956 called for template declarations. */
5958 void
5960 {
5970 bool aggregate_definition_p
5973 /* If an explicit initializer is present, or if this is a definition
5974 of an aggregate, then we need a complete type at this point.
5975 (Scalars are always complete types, so there is nothing to
5976 check.) This code just sets COMPLETE_P; errors (if necessary)
5977 are issued below. */
5979 && !complete_p
5981 {
5983 /* We will not yet have set TREE_READONLY on DECL if the type
5984 was "const", but incomplete, before this point. But, now, we
5985 have a complete type, so we can try again. */
5987 }
5990 /* Is it valid for this decl to have an initializer at all? */
5991 {
5992 /* Don't allow initializations for incomplete types except for
5993 arrays which might be completed by the initialization. */
5999 {
6000 auto_diagnostic_group d;
6006 }
6008 {
6011 /* else we already gave an error in start_decl. */
6012 }
6013 }
6015 {
6018 else
6019 {
6020 auto_diagnostic_group d;
6022 decl);
6026 /* Change the type so that assemble_variable will give
6027 DECL an rtl we can live with: (mem (const_int 0)). */
6029 }
6030 }
6032 /* Create a new scope to hold this declaration if necessary.
6033 Whether or not a new scope is necessary cannot be determined
6034 until after the type has been completed; if the type is a
6035 specialization of a class template it is not until after
6036 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
6037 will be set correctly. */
6039 }
6041 /* Given a parenthesized list of values INIT, create a CONSTRUCTOR to handle
6042 C++20 P0960. TYPE is the type of the object we're initializing. */
6044 tree
6046 {
6050 {
6051 /* If the list has a single element and it's a string literal,
6052 then it's the initializer for the array as a whole. */
6058 /* Handle non-standard extensions like compound literals. This also
6059 prevents triggering aggregate parenthesized-initialization in
6060 compiler-generated code for =default. */
6064 }
6070 }
6072 /* Handle initialization of references. DECL, TYPE, and INIT have the
6073 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
6074 but will be set to a new CLEANUP_STMT if a temporary is created
6075 that must be destroyed subsequently.
6077 Returns an initializer expression to use to initialize DECL, or
6078 NULL if the initialization can be performed statically.
6080 Quotes on semantics can be found in ARM 8.4.3. */
6082 static tree
6084 {
6086 {
6093 }
6097 {
6098 /* This handles (C++20 only) code like
6100 const A& r(1, 2, 3);
6102 where we treat the parenthesized list as a CONSTRUCTOR. */
6107 {
6108 /* We don't know yet if we should treat const A& r(1) as
6109 const A& r{1}. */
6111 {
6114 tf_warning_or_error);
6115 }
6116 /* If the list had more than one element, the code is ill-formed
6117 pre-C++20, so we can build a constructor right away. */
6118 else
6120 }
6121 else
6123 tf_warning_or_error);
6124 }
6128 /* Note: default conversion is only called in very special cases. */
6131 /* check_initializer handles this for non-reference variables, but for
6132 references we need to do it here or the initializer will get the
6133 incomplete array type and confuse later calls to
6134 cp_complete_array_type. */
6139 {
6143 }
6145 /* Convert INIT to the reference type TYPE. This may involve the
6146 creation of a temporary, whose lifetime must be the same as that
6147 of the reference. If so, a DECL_EXPR for the temporary will be
6148 added just after the DECL_EXPR for DECL. That's why we don't set
6149 DECL_INITIAL for local references (instead assigning to them
6150 explicitly); we need to allow the temporary to be initialized
6151 first. */
6153 tf_warning_or_error);
6154 }
6156 /* Designated initializers in arrays are not supported in GNU C++.
6157 The parser cannot detect this error since it does not know whether
6158 a given brace-enclosed initializer is for a class type or for an
6159 array. This function checks that CE does not use a designated
6160 initializer. If it does, an error is issued. Returns true if CE
6161 is valid, i.e., does not have a designated initializer. */
6163 bool
6166 {
6167 /* Designated initializers for array elements are not supported. */
6169 {
6170 /* The parser only allows identifiers as designated
6171 initializers. */
6173 {
6177 }
6179 {
6183 }
6191 {
6192 /* A C99 designator is OK if it matches the current index. */
6194 {
6197 }
6198 else
6200 }
6201 else
6207 }
6210 }
6212 /* When parsing `int a[] = {1, 2};' we don't know the size of the
6213 array until we finish parsing the initializer. If that's the
6214 situation we're in, update DECL accordingly. */
6216 static void
6218 {
6224 {
6225 /* do_default is really a C-ism to deal with tentative definitions.
6226 But let's leave it here to ease the eventual merge. */
6231 /* Check that there are no designated initializers in INIT, as
6232 those are not supported in GNU C++, and as the middle-end
6233 will crash if presented with a non-numeric designated
6234 initializer. */
6236 {
6239 HOST_WIDE_INT i;
6241 {
6246 /* If an un-designated initializer is type-dependent, we can't
6247 check brace elision yet. */
6251 }
6252 }
6256 else
6257 {
6259 do_default);
6261 {
6265 }
6267 {
6269 {
6272 }
6273 /* If a `static' var's size isn't known, make it extern as
6274 well as static, so it does not get allocated. If it's not
6275 `static', then don't mark it extern; finish_incomplete_decl
6276 will give it a default size and it will get allocated. */
6279 }
6281 {
6284 }
6285 }
6290 }
6291 }
6293 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
6294 any appropriate error messages regarding the layout. */
6296 static void
6298 {
6299 tree type;
6305 /* If we haven't already laid out this declaration, do so now.
6306 Note that we must not call complete type for an external object
6307 because it's type might involve templates that we are not
6308 supposed to instantiate yet. (And it's perfectly valid to say
6309 `extern X x' for some incomplete type `X'.) */
6318 {
6319 /* An automatic variable with an incomplete type: that is an error.
6320 Don't talk about array types here, since we took care of that
6321 message in grokdeclarator. */
6325 }
6326 #if 0
6327 /* Keep this code around in case we later want to control debug info
6328 based on whether a type is "used". (jason 1999-11-11) */
6331 /* Let debugger know it should output info for this type. */
6336 #endif
6341 {
6345 else
6346 {
6351 }
6352 }
6354 /* If the final element initializes a flexible array field, add the size of
6355 that initializer to DECL's size. */
6365 {
6368 {
6375 {
6381 }
6382 }
6383 }
6384 }
6386 /* If a local static variable is declared in an inline function, or if
6387 we have a weak definition, we must endeavor to create only one
6388 instance of the variable at link-time. */
6390 void
6392 {
6393 /* Don't mess with __FUNCTION__ and similar. */
6397 /* Static data in a function with comdat linkage also has comdat
6398 linkage. */
6403 {
6405 {
6406 /* With weak symbols, we simply make the variable COMDAT;
6407 that will cause copies in multiple translations units to
6408 be merged. */
6410 }
6411 else
6412 {
6415 {
6416 /* Without weak symbols, we can use COMMON to merge
6417 uninitialized variables. */
6420 }
6421 else
6422 {
6423 /* While for initialized variables, we must use internal
6424 linkage -- which means that multiple copies will not
6425 be merged. */
6432 "%q#D are wrong (you%'ll wind up with "
6434 else
6436 "static data %q#D are wrong (you%'ll wind "
6442 }
6443 }
6444 }
6445 }
6447 /* Issue an error message if DECL is an uninitialized const variable.
6448 CONSTEXPR_CONTEXT_P is true when the function is called in a constexpr
6449 context from potential_constant_expression. Returns true if all is well,
6450 false otherwise. */
6452 bool
6454 tsubst_flags_t complain)
6455 {
6458 /* ``Unless explicitly declared extern, a const object does not have
6459 external linkage and must be initialized. ($8.4; $12.1)'' ARM
6460 7.1.6 */
6464 /* C++20 permits trivial default initialization in constexpr
6465 context (P1331R2). */
6467 && (constexpr_context_p
6470 {
6478 {
6480 {
6484 }
6485 else
6486 {
6490 "uninitialized variable %qD in %<constexpr%> "
6492 else
6495 }
6496 }
6500 decl);
6503 {
6504 tree defaulted_ctor;
6511 "constructor is not user-provided because it is "
6514 "and the implicitly-defined constructor does not "
6516 }
6519 }
6522 }
6523 \f
6524 /* Structure holding the current initializer being processed by reshape_init.
6525 CUR is a pointer to the current element being processed, END is a pointer
6526 after the last element present in the initializer. */
6527 struct reshape_iter
6528 {
6531 };
6535 /* FIELD is an element of TYPE_FIELDS or NULL. In the former case, the value
6536 returned is the next FIELD_DECL (possibly FIELD itself) that can be
6537 initialized as if for an aggregate class. If there are no more such fields,
6538 the return value will be NULL. */
6540 tree
6542 {
6547 /* In C++17, aggregates can have bases. */
6552 }
6554 /* FIELD is an element of TYPE_FIELDS or NULL. In the former case, the value
6555 returned is the next FIELD_DECL (possibly FIELD itself) that corresponds
6556 to a subobject. If there are no more such fields, the return value will be
6557 NULL. */
6559 tree
6561 {
6571 }
6573 /* Return true for [dcl.init.list] direct-list-initialization from
6574 single element of enumeration with a fixed underlying type. */
6576 bool
6578 {
6585 /* DR 2374: The single element needs to be implicitly
6586 convertible to the underlying type of the enum. */
6593 }
6595 /* Subroutine of reshape_init_array and reshape_init_vector, which does
6596 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
6597 INTEGER_CST representing the size of the array minus one (the maximum index),
6598 or NULL_TREE if the array was declared without specifying the size. D is
6599 the iterator within the constructor. */
6601 static tree
6604 {
6605 tree new_init;
6610 /* The initializer for an array is always a CONSTRUCTOR. If this is the
6611 outermost CONSTRUCTOR and the element type is non-aggregate, we don't need
6612 to build a new one. But don't reuse if not complaining; if this is
6613 tentative, we might also reshape to another type (95319). */
6620 else
6624 {
6625 /* Minus 1 is used for zero sized arrays. */
6631 /* sizetype is sign extended, not zero extended. */
6632 else
6634 }
6636 /* Loop until there are no more initializers. */
6640 {
6641 tree elt_init;
6649 complain);
6654 {
6657 }
6658 else
6664 /* This can happen with an invalid initializer (c++/54501). */
6667 }
6670 }
6672 /* Subroutine of reshape_init_r, processes the initializers for arrays.
6673 Parameters are the same of reshape_init_r. */
6675 static tree
6677 tsubst_flags_t complain)
6678 {
6688 }
6690 /* Subroutine of reshape_init_r, processes the initializers for vectors.
6691 Parameters are the same of reshape_init_r. */
6693 static tree
6695 {
6701 {
6704 {
6709 }
6712 }
6714 /* For a vector, we initialize it as an array of the appropriate size. */
6720 }
6722 /* Subroutine of reshape_init*: We're initializing an element with TYPE from
6723 INIT, in isolation from any designator or other initializers. */
6725 static tree
6727 {
6728 /* We could also implement this by wrapping init in a new CONSTRUCTOR and
6729 calling reshape_init, but this way can just live on the stack. */
6734 complain);
6735 }
6737 /* Subroutine of reshape_init_r, processes the initializers for classes
6738 or union. Parameters are the same of reshape_init_r. */
6740 static tree
6742 tsubst_flags_t complain)
6743 {
6744 tree field;
6745 tree new_init;
6749 /* The initializer for a class is always a CONSTRUCTOR. */
6756 {
6757 /* We get here from maybe_aggr_guide for C++20 class template argument
6758 deduction. In this case we need to look through the binfo because a
6759 template doesn't have base fields. */
6762 }
6765 else
6769 {
6770 /* [dcl.init.aggr]
6772 An initializer for an aggregate member that is an
6773 empty class shall have the form of an empty
6774 initializer-list {}. */
6776 {
6780 }
6782 }
6784 /* For C++20 CTAD, handle pack expansions in the base list. */
6787 /* Loop through the initializable fields, gathering initializers. */
6789 {
6790 tree field_init;
6794 /* Handle C++20 designated initializers. */
6796 {
6801 {
6802 /* We already reshaped this; we should have returned early from
6803 reshape_init. */
6806 {
6811 }
6812 }
6814 {
6818 }
6819 else
6820 {
6825 }
6828 /* Apparently the designator isn't for a member of this anonymous
6829 struct, so head back to the enclosing class. */
6833 {
6838 }
6840 /* If the element is an anonymous union object and the initializer
6841 list is a designated-initializer-list, the anonymous union object
6842 is initialized by the designated-initializer-list { D }, where D
6843 is the designated-initializer-clause naming a member of the
6844 anonymous union object. */
6847 {
6848 /* Find the anon aggr that is a direct member of TYPE. */
6850 {
6855 }
6857 /* Not found, e.g. FIELD is a member of a base class. */
6862 found:
6863 /* Now find the TYPE member with that anon aggr type. */
6871 }
6872 }
6874 /* If we processed all the member of the class, we are done. */
6881 /* Each non-trailing aggregate element that is a pack expansion is
6882 assumed to correspond to no elements of the initializer list. */
6886 {
6887 /* The designated field F is initialized from this one element.
6889 Note that we don't want to do this if we found the designator
6890 inside an anon aggr above; we use the normal code to implement:
6892 "If the element is an anonymous union member and the initializer
6893 list is a brace-enclosed designated- initializer-list, the element
6894 is initialized by the designated-initializer-list { D }, where D
6895 is the designated- initializer-clause naming a member of the
6896 anonymous union member." */
6900 }
6901 else
6904 complain);
6910 {
6911 /* This can happen with an invalid initializer for a flexible
6912 array member (c++/54441). */
6916 }
6920 /* [dcl.init.aggr]
6922 When a union is initialized with a brace-enclosed
6923 initializer, the braces shall only contain an
6924 initializer for the first member of the union. */
6928 continue_:
6930 {
6933 else
6935 }
6936 else
6938 }
6940 /* A trailing aggregate element that is a pack expansion is assumed to
6941 correspond to all remaining elements of the initializer list (if any). */
6943 {
6948 }
6951 }
6953 /* Subroutine of reshape_init_r. We're in a context where C99 initializer
6954 designators are not valid; either complain or return true to indicate
6955 that reshape_init_r should return error_mark_node. */
6957 static bool
6959 {
6961 {
6966 else
6968 }
6970 }
6972 /* Subroutine of reshape_init, which processes a single initializer (part of
6973 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
6974 iterator within the CONSTRUCTOR which points to the initializer to process.
6975 If this is the first initializer of the outermost CONSTRUCTOR node,
6976 FIRST_INITIALIZER_P is that CONSTRUCTOR; otherwise, it is NULL_TREE. */
6978 static tree
6980 tsubst_flags_t complain)
6981 {
6994 {
6995 /* A complex type can be initialized from one or two initializers,
6996 but braces are not elided. */
6999 {
7001 {
7004 else
7006 }
7007 }
7009 {
7017 }
7019 }
7021 /* A non-aggregate type is always initialized with a single
7022 initializer. */
7024 /* As is an array with dependent bound, which we can see
7025 during C++20 aggregate CTAD. */
7029 {
7030 /* It is invalid to initialize a non-aggregate type with a
7031 brace-enclosed initializer before C++0x.
7032 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
7033 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
7034 a CONSTRUCTOR (with a record type). */
7036 /* Don't complain about a capture-init. */
7039 {
7041 {
7043 {
7046 type);
7048 }
7051 && (BRACE_ENCLOSED_INITIALIZER_P
7053 {
7058 }
7059 }
7060 else
7062 }
7066 }
7068 /* "If T is a class type and the initializer list has a single element of
7069 type cv U, where U is T or a class derived from T, the object is
7070 initialized from that element." Even if T is an aggregate. */
7072 && first_initializer_p
7073 /* But not if it's a designated init. */
7077 {
7080 }
7082 /* [dcl.init.aggr]
7084 All implicit type conversions (clause _conv_) are considered when
7085 initializing the aggregate member with an initializer from an
7086 initializer-list. If the initializer can initialize a member,
7087 the member is initialized. Otherwise, if the member is itself a
7088 non-empty subaggregate, brace elision is assumed and the
7089 initializer is considered for the initialization of the first
7090 member of the subaggregate. */
7092 /* But don't try this for the first initializer, since that would be
7093 looking through the outermost braces; A a2 = { a1 }; is not a
7094 valid aggregate initialization. */
7095 && !first_initializer_p
7098 complain)))
7099 {
7102 }
7104 /* [dcl.init.string]
7106 A char array (whether plain char, signed char, or unsigned char)
7107 can be initialized by a string-literal (optionally enclosed in
7108 braces); a wchar_t array can be initialized by a wide
7109 string-literal (optionally enclosed in braces). */
7112 {
7115 reshape_iter stripd = {};
7117 /* Strip one level of braces if and only if they enclose a single
7118 element (as allowed by [dcl.init.string]). */
7122 {
7126 }
7128 /* If it's a string literal, then it's the initializer for the array
7129 as a whole. Otherwise, continue with normal initialization for
7130 array types (one value per array element). */
7132 {
7138 }
7139 }
7141 /* The following cases are about aggregates. If we are not within a full
7142 initializer already, and there is not a CONSTRUCTOR, it means that there
7143 is a missing set of braces (that is, we are processing the case for
7144 which reshape_init exists). */
7147 {
7149 {
7152 /* There is no need to call reshape_init for pointer-to-member
7153 function initializers, as they are always constructed correctly
7154 by the front end. Here we have e.g. {.__pfn=0B, .__delta=0},
7155 which is missing outermost braces. We should warn below, and
7157 /* For a nested compound literal, proceed to specialized routines,
7158 to handle initialization of arrays and similar. */
7161 /* If we have an unresolved designator, we need to find the member it
7162 designates within TYPE, so proceed to the routines below. For
7163 FIELD_DECL or INTEGER_CST designators, we're already initializing
7164 the designated element. */
7167 /* Brace elision with designators is only permitted for anonymous
7168 aggregates. */
7170 /* A CONSTRUCTOR of the target's type is a previously
7171 digested initializer. */
7173 {
7176 }
7177 else
7178 {
7179 /* Something that hasn't been reshaped yet. */
7183 }
7184 }
7189 type);
7191 }
7193 /* Dispatch to specialized routines. */
7194 tree new_init;
7201 else
7209 }
7211 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
7212 brace-enclosed aggregate initializer.
7214 INIT is the CONSTRUCTOR containing the list of initializers describing
7215 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
7216 It may not presently match the shape of the TYPE; for example:
7218 struct S { int a; int b; };
7219 struct S a[] = { 1, 2, 3, 4 };
7221 Here INIT will hold a vector of four elements, rather than a
7222 vector of two elements, each itself a vector of two elements. This
7223 routine transforms INIT from the former form into the latter. The
7224 revised CONSTRUCTOR node is returned. */
7226 tree
7228 {
7230 reshape_iter d;
7231 tree new_init;
7237 /* An empty constructor does not need reshaping, and it is always a valid
7238 initializer. */
7243 /* Already reshaped. */
7246 /* Brace elision is not performed for a CONSTRUCTOR representing
7247 parenthesized aggregate initialization. */
7249 {
7251 /* If we're initializing a char array from a string-literal that is
7252 enclosed in braces, unwrap it here. */
7259 }
7261 /* Handle [dcl.init.list] direct-list-initialization from
7262 single element of enumeration with a fixed underlying type. */
7264 {
7268 {
7272 tf_warning_or_error);
7273 }
7274 else
7276 }
7278 /* Recurse on this CONSTRUCTOR. */
7286 /* Make sure all the element of the constructor were used. Otherwise,
7287 issue an error about exceeding initializers. */
7289 {
7293 }
7304 }
7306 /* Verify array initializer. Returns true if errors have been reported. */
7308 bool
7310 {
7313 /* Structured binding when initialized with an array type needs
7314 to have complete type. */
7319 {
7324 }
7326 /* The array type itself need not be complete, because the
7327 initializer may tell us how many elements are in the array.
7328 But, the elements of the array must be complete. */
7330 {
7334 else
7337 }
7343 /* A compound literal can't have variable size. */
7347 {
7350 }
7352 }
7354 /* Subroutine of check_initializer; args are passed down from that function.
7355 Set stmts_are_full_exprs_p to 1 across a call to build_aggr_init. */
7357 static tree
7359 {
7364 }
7366 /* Verify INIT (the initializer for DECL), and record the
7367 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
7368 grok_reference_init.
7370 If the return value is non-NULL, it is an expression that must be
7371 evaluated dynamically to initialize DECL. */
7373 static tree
7375 {
7376 tree type;
7378 tree core_type;
7380 /* Things that are going to be initialized need to have complete
7381 type. */
7385 {
7386 /* A variable with DECL_HAS_VALUE_EXPR_P set is just a placeholder,
7387 it doesn't have storage to be initialized. */
7390 }
7393 /* We will have already complained. */
7397 {
7400 }
7402 {
7407 }
7408 else
7409 /* There is no way to make a variable-sized class type in GNU C++. */
7413 {
7416 {
7418 {
7421 }
7423 {
7425 "scalar object %qD requires one element in "
7429 }
7430 }
7431 }
7434 {
7441 }
7443 ;
7446 {
7448 {
7451 }
7454 tf_warning_or_error);
7455 /* Do not reshape constructors of vectors (they don't need to be
7456 reshaped. */
7458 {
7460 {
7462 tf_warning_or_error);
7464 }
7466 {
7467 /* Don't reshape if the class has constructors. */
7470 "in C++98 %qD must be initialized by "
7472 decl);
7473 }
7475 {
7478 }
7479 else
7480 {
7483 }
7484 }
7485 /* [dcl.init] "Otherwise, if the destination type is an array, the object
7486 is initialized as follows..." So handle things like
7488 int a[](1, 2, 3);
7490 which is permitted in C++20 by P0960. */
7500 {
7503 /* We get here with code like `int a (2);' */
7505 tf_warning_or_error);
7506 }
7508 /* If DECL has an array type without a specific bound, deduce the
7509 array size from the initializer. */
7520 /* The call to build_aggr_init below could end up
7521 calling build_vec_init, which may break when we
7522 are processing a template. */
7523 || processing_template_decl
7527 {
7530 /* A constructor call is a non-trivial initializer even if
7531 it isn't explicitly written. */
7535 /* If this is a constexpr initializer, expand_default_init will
7536 have returned an INIT_EXPR rather than a CALL_EXPR. In that
7537 case, pull the initializer back out and pass it down into
7538 store_init_value. */
7540 {
7547 else
7549 }
7551 {
7552 /* In C++20, the call to build_aggr_init could have created
7553 an INIT_EXPR with a CONSTRUCTOR as the RHS to handle
7554 A(1, 2). */
7557 /* Avoid leaking TARGET_EXPR into template trees. */
7562 /* Don't call digest_init; it's unnecessary and will complain
7563 about aggregate initialization of non-aggregate classes. */
7565 }
7568 {
7569 /* Declared constexpr or constinit, but no suitable initializer;
7570 massage init appropriately so we can pass it into
7571 store_init_value for the error. */
7581 {
7586 }
7588 }
7589 else
7591 }
7594 {
7600 {
7605 }
7617 }
7618 }
7619 else
7620 {
7628 tf_warning_or_error);
7629 }
7639 {
7640 /* We might have set these in cp_finish_decl. */
7643 }
7648 {
7656 else
7660 {
7664 }
7666 }
7669 }
7671 /* If DECL is not a local variable, give it RTL. */
7673 static void
7675 {
7679 /* Set the DECL_ASSEMBLER_NAME for the object. */
7681 {
7682 /* The `register' keyword, when used together with an
7683 asm-specification, indicates that the variable should be
7684 placed in a particular register. */
7686 {
7689 }
7690 else
7691 {
7698 /* We have to propagate the name to the ns-alias.
7699 This is horrible, as we're affecting a
7700 possibly-shared decl. Again, a one-true-decl
7701 model breaks down. */
7704 }
7705 }
7707 /* Handle non-variables up front. */
7709 {
7712 }
7714 /* If we see a class member here, it should be a static data
7715 member. */
7717 {
7719 /* An in-class declaration of a static data member should be
7720 external; it is only a declaration, and not a definition. */
7724 }
7726 /* We don't create any RTL for local variables. */
7730 /* We defer emission of local statics until the corresponding
7731 DECL_EXPR is expanded. But with constexpr its function might never
7732 be expanded, so go ahead and tell cgraph about the variable now. */
7737 /* Defer template instantiations. */
7742 /* If we're not deferring, go ahead and assemble the variable. */
7745 }
7747 /* walk_tree helper for wrap_temporary_cleanups, below. */
7749 static tree
7751 {
7752 /* Stop at types or full-expression boundaries. */
7755 {
7758 }
7761 {
7767 {
7769 /* Tell honor_protect_cleanup_actions to handle this as a separate
7770 cleanup. */
7773 }
7774 }
7777 }
7779 /* We're initializing a local variable which has a cleanup GUARD. If there
7780 are any temporaries used in the initializer INIT of this variable, we
7781 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
7782 variable will be cleaned up properly if one of them throws.
7784 Unfortunately, there's no way to express this properly in terms of
7785 nesting, as the regions for the temporaries overlap the region for the
7786 variable itself; if there are two temporaries, the variable needs to be
7787 the first thing destroyed if either of them throws. However, we only
7788 want to run the variable's cleanup if it actually got constructed. So
7789 we need to guard the temporary cleanups with the variable's cleanup if
7790 they are run on the normal path, but not if they are run on the
7791 exceptional path. We implement this by telling
7792 honor_protect_cleanup_actions to strip the variable cleanup from the
7793 exceptional path.
7795 Another approach could be to make the variable cleanup region enclose
7796 initialization, but depend on a flag to indicate that the variable is
7797 initialized; that's effectively what we do for arrays. But the current
7798 approach works fine for non-arrays, and has no code overhead in the usual
7799 case where the temporary destructors are noexcept. */
7801 static void
7803 {
7805 {
7806 /* An array cleanup region already encloses any temporary cleanups,
7807 don't wrap it around them again. */
7810 }
7812 }
7814 /* Generate code to initialize DECL (a local variable). */
7816 static void
7818 {
7820 tree cleanup;
7828 {
7829 /* If we used it already as memory, it must stay in memory. */
7833 }
7838 /* Compute and store the initial value. */
7843 /* Generate a cleanup, if necessary. */
7846 /* Perform the initialization. */
7848 {
7853 {
7854 /* Stick simple initializers in DECL_INITIAL so that
7855 -Wno-init-self works (c++/34772). */
7859 {
7863 OPT_Winit_self,
7865 }
7866 }
7867 else
7868 {
7871 /* If we're only initializing a single object, guard the
7872 destructors of any temporaries used in its initializer with
7873 its destructor. */
7882 saved_stmts_are_full_exprs_p;
7883 }
7884 }
7886 /* Set this to 0 so we can tell whether an aggregate which was
7887 initialized was ever used. Don't do this if it has a
7888 destructor, so we don't complain about the 'resource
7889 allocation is initialization' idiom. Now set
7890 attribute((unused)) on types so decls of that type will be
7891 marked used. (see TREE_USED, above.) */
7893 && ! already_used
7902 }
7904 /* DECL is a VAR_DECL for a compiler-generated variable with static
7905 storage duration (like a virtual table) whose initializer is a
7906 compile-time constant. Initialize the variable and provide it to the
7907 back end. */
7909 void
7911 {
7912 tree init;
7918 /* Mark the decl as constexpr so that we can access its content
7919 at compile time. */
7926 }
7928 /* INIT is the initializer for a variable, as represented by the
7929 parser. Returns true iff INIT is value-dependent. */
7931 static bool
7933 {
7935 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
7938 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
7939 {
7952 }
7953 else
7954 /* It must be a simple expression, e.g., int i = 3; */
7958 }
7960 // Returns true if a DECL is VAR_DECL with the concept specifier.
7963 {
7965 // Not all variables have DECL_LANG_SPECIFIC.
7968 }
7970 /* A helper function to be called via walk_tree. If any label exists
7971 under *TP, it is (going to be) forced. Set has_forced_label_in_static. */
7973 static tree
7975 {
7981 }
7983 /* Return true if DECL has either a trivial destructor, or for C++20
7984 is constexpr and has a constexpr destructor. */
7986 static bool
7988 {
7994 }
7998 /* Helper function of omp_declare_variant_finalize. Finalize one
7999 "omp declare variant base" attribute. Return true if it should be
8000 removed. */
8002 static bool
8004 {
8006 {
8011 }
8016 {
8020 /* FIXME, adjusting simd args unimplemented. */
8022 }
8025 location_t varid_loc
8034 releasing_vec args;
8043 else
8048 {
8050 /* In C++20, we may need to perform ADL for a template
8051 name. */
8054 {
8056 {
8060 tf_warning_or_error);
8061 }
8062 else
8064 }
8066 {
8072 {
8076 tf_warning_or_error);
8077 }
8078 }
8079 }
8084 else
8094 {
8097 {
8101 }
8106 {
8109 }
8110 else
8111 {
8117 }
8118 }
8120 {
8123 }
8126 }
8128 /* Helper function, finish up "omp declare variant base" attribute
8129 now that there is a DECL. ATTR is the first "omp declare variant base"
8130 attribute. */
8132 void
8134 {
8144 {
8147 }
8149 {
8152 }
8154 {
8157 }
8159 {
8162 }
8164 {
8167 }
8168 /* This loop is like private_lookup_attribute, except that it works
8169 with tree * rather than tree, as we might want to remove the
8170 attributes that are diagnosed as errorneous. */
8172 {
8177 {
8179 {
8182 }
8183 }
8185 }
8186 }
8188 /* Finish processing of a declaration;
8189 install its line number and initial value.
8190 If the length of an array type is not known before,
8191 it must be determined now, from the initial value, or it is an error.
8193 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
8194 true, then INIT is an integral constant expression.
8196 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
8197 if the (init) syntax was used. */
8199 void
8202 {
8207 tree auto_node;
8212 {
8216 }
8219 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
8229 /* Warn about register storage specifiers except when in GNU global
8230 or local register variable extension. */
8232 {
8235 "ISO C++17 does not allow %<register%> storage "
8237 else
8240 }
8242 /* If a name was specified, get the string. */
8248 bool in_class_decl
8249 = (current_class_type
8260 {
8261 tree d_init;
8263 {
8267 {
8268 /* init is null because we're deferring instantiating the
8269 initializer until we need it. Well, we need it now. */
8272 }
8276 else
8277 {
8278 /* Ordinary auto deduction without an initializer, a situation
8279 which grokdeclarator already detects and rejects for the most
8280 part. But we can still get here if we're instantiating a
8281 variable template before we've fully parsed (and attached) its
8282 initializer, e.g. template<class> auto x = x<int>; */
8287 }
8288 }
8291 {
8295 tf_warning_or_error);
8297 /* Force auto deduction now. Use tf_none to avoid redundant warnings
8298 on deprecated-14.C. */
8300 }
8309 /* The outer template arguments might be needed for satisfaction.
8310 (For function scope variables, do_auto_deduction will obtain the
8311 outer template arguments from current_function_decl.) */
8319 {
8324 }
8325 /* As in start_decl_1, complete so TREE_READONLY is set properly. */
8329 {
8335 }
8338 /* Update the type of the corresponding TEMPLATE_DECL to match. */
8343 }
8346 {
8349 {
8352 }
8353 }
8363 {
8365 ? TCTX_THREAD_STORAGE
8368 }
8371 {
8372 tree clone;
8374 {
8375 /* FIXME check this is 1st decl. */
8380 {
8384 }
8386 }
8388 {
8391 else
8393 }
8394 }
8397 {
8399 /* If DECL is a reference, then we want to know whether init is a
8400 reference constant; init_const_expr_p as passed tells us whether
8401 it's an rvalue constant. */
8405 {
8406 /* Set these flags now for templates. We'll update the flags in
8407 store_init_value for instantiations. */
8410 /* FIXME setting TREE_CONSTANT on refs breaks the back end. */
8413 }
8414 /* This is handled mostly by gimplify.cc, but we have to deal with
8415 not warning about int x = x; as it is a GCC extension to turn off
8416 this warning but only if warn_init_self is zero. */
8422 }
8428 /* We have no initializer but there's nothing to initialize anyway.
8429 Treat DECL as constant due to c++/109876. */
8434 /* #pragma omp declare variant on methods handled in finish_struct
8435 instead. */
8443 {
8446 /* Add this declaration to the statement-tree. */
8453 {
8456 }
8458 /* Generally, initializers in templates are expanded when the
8459 template is instantiated. But, if DECL is a variable constant
8460 then it can be used in future constant expressions, so its value
8461 must be available. */
8468 {
8471 }
8477 {
8478 /* This variable seems to be a non-dependent constant, so process
8479 its initializer. If check_initializer returns non-null the
8480 initialization wasn't constant after all. */
8481 tree init_code;
8487 }
8488 else
8489 {
8491 /* Try to deduce array size. */
8493 /* And complain about multiple initializers. */
8497 tf_warning_or_error);
8498 }
8504 {
8507 }
8510 {
8513 }
8515 }
8517 /* Just store non-static data member initializers for later. */
8521 /* Take care of TYPE_DECLs up front. */
8523 {
8526 {
8530 }
8532 /* If we have installed this as the canonical typedef for this
8533 type, and that type has not been defined yet, delay emitting
8534 the debug information for it, as we will emit it later. */
8540 at_eof);
8542 }
8544 /* A reference will be modified here, as it is initialized. */
8548 {
8551 }
8553 /* This needs to happen before extend_ref_init_temps. */
8555 {
8559 }
8562 {
8564 /* [dcl.constinit]/1 "The constinit specifier shall be applied
8565 only to a declaration of a variable with static or thread storage
8566 duration." */
8569 {
8571 "%<constinit%> can only be applied to a variable with "
8574 }
8576 /* If this is a local variable that will need a mangled name,
8577 register it now. We must do this before processing the
8578 initializer for the variable, since the initialization might
8579 require a guard variable, and since the mangled name of the
8580 guard variable will depend on the mangled name of this
8581 variable. */
8585 {
8586 /* The variable holding an anonymous union will have had its
8587 discriminator set in finish_anon_union, after which it's
8588 NAME will have been cleared. */
8591 /* Normally has_forced_label_in_static is set during GIMPLE
8592 lowering, but [cd]tors are never actually compiled directly.
8593 We need to set this early so we can deal with the label
8594 address extension. */
8598 {
8601 }
8602 /* And make sure it's in the symbol table for
8603 c_parse_final_cleanups to find. */
8605 }
8607 /* Convert the initializer to the type of DECL, if we have not
8608 already initialized DECL. */
8610 /* If !DECL_EXTERNAL then DECL is being defined. In the
8611 case of a static data member initialized inside the
8612 class-specifier, there can be an initializer even if DECL
8613 is *not* defined. */
8615 {
8619 /* Handle:
8621 [dcl.init]
8623 The memory occupied by any object of static storage
8624 duration is zero-initialized at program startup before
8625 any other initialization takes place.
8627 We cannot create an appropriate initializer until after
8628 the type of DECL is finalized. If DECL_INITIAL is set,
8629 then the DECL is statically initialized, and any
8630 necessary zero-initialization has already been performed. */
8635 /* Remember that the initialization for this variable has
8636 taken place. */
8638 /* This declaration is the definition of this variable,
8639 unless we are initializing a static data member within
8640 the class specifier. */
8643 }
8644 /* If the variable has an array type, lay out the type, even if
8645 there is no initializer. It is valid to index through the
8646 array, and we must get TYPE_ALIGN set correctly on the array
8647 type. */
8654 /* So decl is a global variable or a static member of a
8655 non local class. Record the types it uses
8656 so that we can decide later to emit debug info for them. */
8658 }
8660 /* Add this declaration to the statement-tree. This needs to happen
8661 after the call to check_initializer so that the DECL_EXPR for a
8662 reference temp is added before the DECL_EXPR for the reference itself. */
8664 {
8665 /* If we're building a variable sized type, and we might be
8666 reachable other than via the top of the current binding
8667 level, then create a new BIND_EXPR so that we deallocate
8668 the object at the right time. */
8673 {
8674 tree bind;
8679 }
8681 }
8683 /* Let the middle end know about variables and functions -- but not
8684 static data members in uninstantiated class templates. */
8686 {
8688 {
8691 /* Check again now that we have an initializer. */
8693 /* A class-scope constexpr variable with an out-of-class declaration.
8694 C++17 makes them implicitly inline, but still force it out. */
8700 }
8703 /* With -fmerge-all-constants, gimplify_init_constructor
8704 might add TREE_STATIC to aggregate variables. */
8708 {
8709 /* If a TREE_READONLY variable needs initialization
8710 at runtime, it is no longer readonly and we need to
8711 avoid MEM_READONLY_P being set on RTL created for it. */
8713 {
8717 }
8721 /* Likewise if it needs destruction. */
8724 }
8730 {
8731 /* TLS variables need dynamic initialization by the TLS wrapper
8732 function, we don't want to hoist accesses to it before the
8733 wrapper. */
8736 }
8740 /* Check for abstractness of the type. */
8745 /* No initialization required. */
8746 ;
8748 {
8750 {
8752 {
8753 /* An out-of-class default definition is defined at
8754 the point where it is explicitly defaulted. */
8759 }
8760 else
8764 decl);
8765 }
8766 /* else no initialization required. */
8767 }
8771 {
8772 /* check_initializer will have done any constant initialization. */
8773 }
8774 /* A variable definition. */
8776 /* Initialize the local variable. */
8779 /* If a variable is defined, and then a subsequent
8780 definition with external linkage is encountered, we will
8781 get here twice for the same variable. We want to avoid
8782 calling expand_static_init more than once. For variables
8783 that are not static data members, we can call
8784 expand_static_init only when we actually process the
8785 initializer. It is not legal to redeclare a static data
8786 member, so this issue does not arise in that case. */
8789 }
8791 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
8792 reference, insert it in the statement-tree now. */
8794 {
8796 {
8798 /* As in initialize_local_var. */
8800 }
8802 }
8811 {
8817 {
8823 }
8828 {
8834 {
8837 {
8841 }
8842 }
8843 }
8844 }
8846 /* This is the last point we can lower alignment so give the target the
8847 chance to do so. */
8854 }
8856 /* For class TYPE return itself or some its bases that contain
8857 any direct non-static data members. Return error_mark_node if an
8858 error has been diagnosed. */
8860 static tree
8862 {
8872 {
8876 else
8881 }
8883 {
8891 }
8892 else
8902 {
8907 {
8909 {
8914 }
8918 {
8920 "classes %qT and %qT have non-static data "
8923 }
8924 else
8926 }
8927 }
8929 }
8931 /* Return std::tuple_size<TYPE>::value. */
8933 static tree
8935 {
8951 else
8953 }
8955 /* Return std::tuple_element<I,TYPE>::type. */
8957 static tree
8959 {
8967 tf_warning_or_error);
8970 }
8972 /* Return e.get<i>() or get<i>(e). */
8974 static tree
8976 {
8983 /* [The id-expression] e is an lvalue if the type of the entity e is an
8984 lvalue reference and an xvalue otherwise. */
8993 /* To use a member get, member lookup must find at least one
8994 declaration that is a function template
8995 whose first template parameter is a non-type parameter. */
8997 {
9000 {
9004 {
9007 }
9008 }
9009 }
9012 {
9017 }
9018 else
9019 {
9025 }
9026 }
9028 /* It's impossible to recover the decltype of a tuple decomposition variable
9029 based on the actual type of the variable, so store it in a hash table. */
9033 tree
9035 {
9037 }
9039 /* Mangle a decomposition declaration if needed. Arguments like
9040 in cp_finish_decomp. */
9042 void
9044 {
9048 {
9056 }
9057 }
9059 /* Finish a decomposition declaration. DECL is the underlying declaration
9060 "e", FIRST is the head of a chain of decls for the individual identifiers
9061 chained through DECL_CHAIN in reverse order and COUNT is the number of
9062 those decls. */
9064 void
9066 {
9068 {
9069 error_out:
9071 {
9074 {
9077 }
9079 }
9083 }
9087 /* This happens for range for when not in templates.
9088 Still add the DECL_VALUE_EXPRs for later processing. */
9089 || (!processing_template_decl
9091 {
9093 {
9095 {
9101 }
9105 }
9107 }
9113 {
9116 }
9122 {
9128 {
9130 type);
9132 }
9133 }
9138 {
9139 tree nelts;
9144 {
9147 }
9150 {
9151 cnt_mismatch:
9156 else
9165 }
9168 {
9177 }
9178 }
9179 /* 2 GNU extensions. */
9181 {
9187 {
9196 }
9197 }
9199 {
9201 {
9204 }
9209 {
9220 }
9221 }
9223 {
9225 {
9229 }
9231 {
9238 }
9244 {
9255 {
9259 }
9261 {
9265 }
9266 /* Save the decltype away before reference collapse. */
9272 {
9273 /* In this case the names are variables, not just proxies. */
9276 }
9278 {
9282 }
9283 }
9284 /* Ignore reads from the underlying decl performed during initialization
9285 of the individual variables. If those will be read, we'll mark
9286 the underlying decl as read at that point. */
9288 }
9290 {
9293 }
9295 {
9298 }
9300 {
9303 }
9308 type);
9309 else
9310 {
9315 {
9319 }
9325 else
9326 eltscnt++;
9331 {
9335 }
9342 else
9343 {
9345 NULL_TREE);
9351 {
9354 }
9355 i++;
9356 }
9357 }
9359 {
9362 {
9367 }
9368 }
9369 }
9371 /* Returns a declaration for a VAR_DECL as if:
9373 extern "C" TYPE NAME;
9375 had been seen. Used to create compiler-generated global
9376 variables. */
9378 static tree
9380 {
9387 /* If the user has explicitly declared this variable (perhaps
9388 because the code we are compiling is part of a low-level runtime
9389 library), then it is possible that our declaration will be merged
9390 with theirs by pushdecl. */
9396 }
9398 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
9399 if "__cxa_atexit" is not being used) corresponding to the function
9400 to be called when the program exits. */
9402 static tree
9404 {
9405 tree fn_type;
9408 {
9409 tree arg_type;
9412 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
9414 else
9415 /* The parameter to "atexit" is "void (*)(void)". */
9421 }
9424 }
9426 /* Returns a pointer to the `atexit' function. Note that if
9427 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
9428 `__cxa_atexit' function specified in the IA64 C++ ABI. */
9430 static tree
9432 {
9433 tree atexit_fndecl;
9434 tree fn_type;
9435 tree fn_ptr_type;
9444 {
9445 /* The declaration for `__cxa_atexit' is:
9447 int __cxa_atexit (void (*)(void *), void *, void *)
9449 We build up the argument types and then the function type
9450 itself. */
9454 /* First, build the pointer-to-function type for the first
9455 argument. */
9457 /* Then, build the rest of the argument types. */
9460 {
9463 }
9464 else
9465 {
9468 }
9469 /* And the final __cxa_atexit type. */
9472 NULL_TREE);
9473 /* ... which needs noexcept. */
9476 {
9484 }
9485 else
9486 {
9489 }
9490 }
9491 else
9492 {
9493 /* The declaration for `atexit' is:
9495 int atexit (void (*)());
9497 We build up the argument types and then the function type
9498 itself. */
9500 /* Build the final atexit type. */
9503 /* ... which needs noexcept. */
9506 }
9508 /* Now, build the function declaration. */
9513 /* Install as hidden builtin so we're (a) more relaxed about
9514 exception spec matching and (b) will not give a confusing location
9515 in diagnostic and (c) won't magically appear in user-visible name
9516 lookups. */
9525 }
9527 /* Like get_atexit_node, but for thread-local cleanups. */
9529 static tree
9531 {
9532 /* The declaration for `__cxa_thread_atexit' is:
9534 int __cxa_thread_atexit (void (*)(void *), void *, void *) */
9538 NULL_TREE);
9540 /* Now, build the function declaration. */
9544 }
9546 /* Returns the __dso_handle VAR_DECL. */
9548 static tree
9550 {
9554 /* Declare the variable. */
9556 ptr_type_node);
9558 #ifdef HAVE_GAS_HIDDEN
9560 {
9563 }
9564 #endif
9567 }
9569 /* Begin a new function with internal linkage whose job will be simply
9570 to destroy some particular variable. */
9574 static tree
9576 {
9581 /* No need to mangle this. */
9584 /* Build the name of the function. */
9586 /* Build the function declaration. */
9590 /* It's a function with internal linkage, generated by the
9591 compiler. */
9594 /* Make the function `inline' so that it is only emitted if it is
9595 actually needed. It is unlikely that it will be inlined, since
9596 it is only called via a function pointer, but we avoid unnecessary
9597 emissions this way. */
9601 {
9602 /* Build the parameter. */
9607 }
9615 }
9617 /* Finish the cleanup function begun by start_cleanup_fn. */
9619 static void
9621 {
9625 }
9627 /* Generate code to handle the destruction of DECL, an object with
9628 static storage duration. */
9630 tree
9632 {
9633 tree cleanup;
9634 tree addr;
9635 tree compound_stmt;
9636 tree fcall;
9637 tree type;
9640 tree atex_node;
9648 {
9651 }
9653 /* If we're using "__cxa_atexit" (or "__cxa_thread_atexit" or
9654 "__aeabi_atexit"), and DECL is a class object, we can just pass the
9655 destructor to "__cxa_atexit"; we don't have to build a temporary
9656 function to do the cleanup. */
9657 dso_parm = (flag_use_cxa_atexit
9662 {
9665 /* Make sure it is accessible. */
9667 tf_warning_or_error);
9668 }
9669 else
9670 {
9671 /* Call build_cleanup before we enter the anonymous function so
9672 that any access checks will be done relative to the current
9673 scope, rather than the scope of the anonymous function. */
9676 /* Now start the function. */
9679 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
9680 to the original function, rather than the anonymous one. That
9681 will make the back end think that nested functions are in use,
9682 which causes confusion. */
9687 /* Create the body of the anonymous function. */
9692 }
9694 /* Call atexit with the cleanup function. */
9700 else
9704 {
9705 /* We must convert CLEANUP to the type that "__cxa_atexit"
9706 expects. */
9708 /* "__cxa_atexit" will pass the address of DECL to the
9709 cleanup function. */
9712 /* The declared type of the parameter to "__cxa_atexit" is
9713 "void *". For plain "T*", we could just let the
9714 machinery in cp_build_function_call convert it -- but if the
9715 type is "cv-qualified T *", then we need to convert it
9716 before passing it in, to avoid spurious errors. */
9718 }
9719 else
9720 /* Since the cleanup functions we build ignore the address
9721 they're given, there's no reason to pass the actual address
9722 in, and, in general, it's cheaper to pass NULL than any
9723 other value. */
9728 tf_warning_or_error);
9730 /* Just pass NULL to the dso handle parm if we don't actually
9731 have a DSO handle on this target. */
9733 else
9737 {
9740 {
9743 }
9744 else
9745 {
9748 }
9749 }
9750 else
9751 {
9754 }
9757 }
9759 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
9760 is its initializer. Generate code to handle the construction
9761 and destruction of DECL. */
9763 static void
9765 {
9769 /* Some variables require no dynamic initialization. */
9771 {
9772 /* Make sure the destructor is callable. */
9776 }
9780 {
9785 else
9790 {
9794 }
9796 }
9799 {
9800 /* Emit code to perform this initialization but once. */
9805 /* We don't need thread-safety code for thread-local vars. */
9809 /* Emit code to perform this initialization but once. This code
9810 looks like:
9812 static <type> guard;
9813 if (!__atomic_load (guard.first_byte)) {
9814 if (__cxa_guard_acquire (&guard)) {
9815 bool flag = false;
9816 try {
9817 // Do initialization.
9818 flag = true; __cxa_guard_release (&guard);
9819 // Register variable for destruction at end of program.
9820 } catch {
9821 if (!flag) __cxa_guard_abort (&guard);
9822 }
9823 }
9824 }
9826 Note that the `flag' variable is only set to 1 *after* the
9827 initialization is complete. This ensures that an exception,
9828 thrown during the construction, will cause the variable to
9829 reinitialized when we pass through this code again, as per:
9831 [stmt.dcl]
9833 If the initialization exits by throwing an exception, the
9834 initialization is not complete, so it will be tried again
9835 the next time control enters the declaration.
9837 This process should be thread-safe, too; multiple threads
9838 should not be able to initialize the variable more than
9839 once. */
9841 /* Create the guard variable. */
9844 /* Begin the conditional initialization. */
9851 {
9864 acquire_fn = push_library_fn
9867 NULL_TREE),
9872 NULL_TREE);
9875 ECF_NOTHROW);
9882 inner_if_stmt);
9890 void_node,
9894 /* Do the initialization itself. */
9900 /* Use atexit to register a function for destroying this static
9901 variable. Do this before calling __cxa_guard_release. */
9905 guard_addr));
9906 }
9907 else
9908 {
9911 /* Use atexit to register a function for destroying this static
9912 variable. */
9914 }
9919 {
9923 }
9928 }
9931 else
9933 }
9935 \f
9936 /* Make TYPE a complete type based on INITIAL_VALUE.
9937 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
9938 2 if there was no information (in which case assume 0 if DO_DEFAULT),
9939 3 if the initializer list is empty (in pedantic mode). */
9941 int
9943 {
9947 /* Don't get confused by a CONSTRUCTOR for some other type. */
9954 {
9955 /* An array of character type can be initialized from a
9956 brace-enclosed string constant so call reshape_init to
9957 remove the optional braces from a braced string literal. */
9961 tf_warning_or_error);
9963 /* If any of the elements are parameter packs, we can't actually
9964 complete this type now because the array size is dependent. */
9969 }
9973 /* We can create the array before the element type is complete, which
9974 means that we didn't have these two bits set in the original type
9975 either. In completing the type, we are expected to propagate these
9976 bits. See also complete_type which does the same thing for arrays
9977 of fixed size. */
9980 {
9985 }
9988 }
9990 /* As above, but either give an error or reject zero-size arrays, depending
9991 on COMPLAIN. */
9993 int
9996 {
9999 /* In SFINAE context we can't be lenient about zero-size arrays. */
10006 {
10012 {
10015 }
10019 }
10021 }
10022 \f
10023 /* Return zero if something is declared to be a member of type
10024 CTYPE when in the context of CUR_TYPE. STRING is the error
10025 message to print in that case. Otherwise, quietly return 1. */
10027 static int
10029 {
10031 {
10034 else
10037 }
10039 }
10040 \f
10041 /* Subroutine of `grokdeclarator'. */
10043 /* Generate errors possibly applicable for a given set of specifiers.
10044 This is for ARM $7.1.2. */
10046 static void
10055 {
10057 {
10101 }
10105 && !flag_noexcept_type
10111 }
10113 /* DECL is a member function or static data member and is presently
10114 being defined. Check that the definition is taking place in a
10115 valid namespace. */
10117 static void
10119 {
10120 /* These checks only apply to member functions and static data
10121 members. */
10123 /* We check for problems with specializations in pt.cc in
10124 check_specialization_namespace, where we can issue better
10125 diagnostics. */
10128 /* We check this in check_explicit_instantiation_namespace. */
10131 /* [class.mfct]
10133 A member function definition that appears outside of the
10134 class definition shall appear in a namespace scope enclosing
10135 the class definition.
10137 [class.static.data]
10139 The definition for a static data member shall appear in a
10140 namespace scope enclosing the member's class definition. */
10144 }
10146 /* Build a PARM_DECL for the "this" parameter of FN. TYPE is the
10147 METHOD_TYPE for a non-static member function; QUALS are the
10148 cv-qualifiers that apply to the function. */
10150 tree
10152 {
10153 tree this_type;
10154 tree qual_type;
10155 tree parm;
10156 cp_cv_quals this_quals;
10159 {
10160 this_type
10163 }
10164 else
10166 /* The `this' parameter is implicitly `const'; it cannot be
10167 assigned to. */
10173 }
10175 /* DECL is a static member function. Complain if it was declared
10176 with function-cv-quals. */
10178 static void
10180 {
10183 decl);
10184 }
10186 // Check that FN takes no arguments and returns bool.
10187 static void
10189 {
10190 // A constraint is nullary.
10195 // The declared return type of the concept shall be bool, and
10196 // it shall not be deduced from it definition.
10204 }
10206 /* Helper function. Replace the temporary this parameter injected
10207 during cp_finish_omp_declare_simd with the real this parameter. */
10209 static tree
10211 {
10220 }
10222 /* CTYPE is class type, or null if non-class.
10223 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
10224 or METHOD_TYPE.
10225 DECLARATOR is the function's name.
10226 PARMS is a chain of PARM_DECLs for the function.
10227 VIRTUALP is truthvalue of whether the function is virtual or not.
10228 FLAGS are to be passed through to `grokclassfn'.
10229 QUALS are qualifiers indicating whether the function is `const'
10230 or `volatile'.
10231 RAISES is a list of exceptions that this function can raise.
10232 CHECK is 1 if we must find this method in CTYPE, 0 if we should
10233 not look, and -1 if we should not call `grokclassfn' at all.
10235 SFK is the kind of special function (if any) for the new function.
10237 Returns `NULL_TREE' if something goes wrong, after issuing
10238 applicable error messages. */
10240 static tree
10242 tree type,
10243 tree declarator,
10244 tree parms,
10245 tree orig_declarator,
10247 tree decl_reqs,
10250 cp_cv_quals quals,
10251 cp_ref_qualifier rqual,
10252 tree raises,
10258 special_function_kind sfk,
10262 tree in_namespace,
10264 location_t location)
10265 {
10266 tree decl;
10268 tree t;
10273 /* Was the concept specifier present? */
10276 /* Concept declarations must have a corresponding definition. */
10278 {
10281 }
10287 /* Set the constraints on the declaration. */
10289 {
10294 && (current_template_depth
10297 {
10299 /* If there are no template parameters, something must have
10300 gone wrong. */
10302 else
10304 }
10307 {
10310 }
10311 /* C++20 CA378: Remove non-templated constrained functions. */
10313 && (block_local
10314 || (!flag_concepts_ts
10315 && (!processing_template_decl
10317 {
10320 }
10322 }
10325 {
10330 /* Allocate space to hold the vptr bit if needed. */
10332 }
10338 /* Propagate volatile out from type to decl. */
10342 /* Setup decl according to sfk. */
10344 {
10357 }
10360 {
10364 orig_declarator);
10365 else
10366 {
10371 {
10372 /* Something like `template <class T> friend void f<T>()'. */
10374 "invalid use of template-id %qD in declaration "
10376 orig_declarator);
10378 }
10380 /* A friend declaration of the form friend void f<>(). Record
10381 the information in the TEMPLATE_ID_EXPR. */
10390 {
10392 "default arguments are not allowed in declaration "
10394 decl);
10396 }
10399 {
10401 "%<inline%> is not allowed in declaration of friend "
10403 decl);
10405 }
10406 }
10407 }
10409 /* C++17 11.3.6/4: "If a friend declaration specifies a default argument
10410 expression, that declaration shall be a definition..." */
10412 {
10416 {
10418 "friend declaration of %qD specifies default "
10421 }
10422 }
10424 /* If this decl has namespace scope, set that up. */
10429 else
10432 /* `main' and builtins have implicit 'C' linkage. */
10447 /* Should probably propagate const out from type to decl I bet (mrs). */
10449 {
10452 }
10461 {
10477 }
10479 /* Members of anonymous types and local classes have no linkage; make
10480 them internal. If a typedef is made later, this will be changed. */
10486 {
10487 /* [basic.link]: A name with no linkage (notably, the name of a class
10488 or enumeration declared in a local scope) shall not be used to
10489 declare an entity with linkage.
10491 DR 757 relaxes this restriction for C++0x. */
10493 }
10497 {
10500 }
10502 /* If the declaration was declared inline, mark it as such. */
10504 {
10508 }
10512 {
10515 }
10517 // If the concept declaration specifier was found, check
10518 // that the declaration satisfies the necessary requirements.
10520 {
10523 }
10527 {
10530 TYPE_UNQUALIFIED,
10531 REF_QUAL_NONE);
10534 {
10538 decl);
10540 }
10543 {
10547 decl);
10549 }
10550 }
10553 {
10557 {
10562 }
10565 {
10569 }
10573 }
10578 {
10582 /* [over.literal]/6: Literal operators shall not have C linkage. */
10584 {
10588 }
10591 {
10594 {
10597 }
10601 {
10605 }
10607 {
10611 }
10612 /* 17.6.3.3.5 */
10616 "literal operator suffixes not preceded by %<_%>"
10618 }
10619 else
10620 {
10623 }
10624 }
10627 /* Make the init_value nonzero so pushdecl knows this is not
10628 tentative. error_mark_node is replaced later with the BLOCK. */
10635 {
10636 /* Adjust "omp declare simd" attributes. */
10639 {
10640 tree attr;
10643 {
10648 {
10650 cl = c_omp_declare_simd_clauses_to_numbers
10654 else
10656 }
10657 }
10658 }
10659 }
10661 /* Caller will do the rest of this. */
10668 /* 12.4/3 */
10678 template_count,
10690 {
10693 }
10698 /* Check main's type after attributes have been applied. */
10700 {
10702 integer_type_node))
10703 {
10705 tree newtype;
10710 }
10713 }
10716 {
10718 (current_template_depth
10720 ? current_template_parms
10727 {
10728 tree ok;
10729 tree pushed_scope;
10732 /* Because grokfndecl is always supposed to return a
10733 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
10734 here. We depend on our callers to figure out that its
10735 really a template that's being returned. */
10740 {
10741 /* Remove the `this' parm added by grokclassfn. */
10744 }
10746 {
10749 }
10751 {
10756 }
10758 /* Since we've smashed OLD_DECL to its
10759 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
10763 /* Attempt to merge the declarations. This can fail, in
10764 the case of some invalid specialization declarations. */
10770 {
10774 }
10778 }
10779 }
10791 }
10793 /* decl is a FUNCTION_DECL.
10794 specifiers are the parsed virt-specifiers.
10796 Set flags to reflect the virt-specifiers.
10798 Returns decl. */
10800 static tree
10802 {
10810 }
10812 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
10813 the linkage that DECL will receive in the object file. */
10815 static void
10817 {
10818 /* A static data member always has static storage duration and
10819 external linkage. Note that static data members are forbidden in
10820 local classes -- the only situation in which a class has
10821 non-external linkage. */
10824 /* For non-template classes, static data members are always put
10825 out in exactly those files where they are defined, just as
10826 with ordinary namespace-scope variables. */
10829 }
10831 /* Create a VAR_DECL named NAME with the indicated TYPE.
10833 If SCOPE is non-NULL, it is the class type or namespace containing
10834 the variable. If SCOPE is NULL, the variable should is created in
10835 the innermost enclosing scope. */
10837 static tree
10839 tree name,
10840 tree orig_declarator,
10847 tree scope,
10848 location_t location)
10849 {
10850 tree decl;
10851 tree explicit_scope;
10858 /* Compute the scope in which to place the variable, but remember
10859 whether or not that scope was explicitly specified by the user. */
10862 {
10863 /* An explicit "extern" specifier indicates a namespace-scope
10864 variable. */
10869 }
10873 template, we need DECL_LANG_SPECIFIC. */
10875 /* Similarly for namespace-scope variables with language linkage
10876 other than C++. */
10879 /* Similarly for static data members. */
10881 /* Similarly for explicit specializations. */
10882 || (orig_declarator
10885 else
10890 else
10894 {
10897 }
10900 {
10902 /* This function is only called with out-of-class definitions. */
10905 }
10906 /* At top level, either `static' or no s.c. makes a definition
10907 (perhaps tentative), and absence of `static' makes it public. */
10909 {
10912 || ! constp
10913 || volatilep
10916 }
10917 /* Not at top level, only `static' makes a static definition. */
10918 else
10919 {
10922 }
10927 {
10929 {
10933 }
10936 }
10938 /* If the type of the decl has no linkage, make sure that we'll
10939 notice that in mark_used. */
10948 {
10949 /* [basic.link]: A name with no linkage (notably, the name of a class
10950 or enumeration declared in a local scope) shall not be used to
10951 declare an entity with linkage.
10953 DR 757 relaxes this restriction for C++0x. */
10956 }
10957 else
10966 /* Check that the variable can be safely declared as a concept.
10967 Note that this also forbids explicit specializations. */
10969 {
10971 {
10975 }
10977 {
10981 }
10982 else
10988 {
10991 }
10992 }
10995 {
10998 }
11000 // Handle explicit specializations and instantiations of variable templates.
11006 }
11008 /* Create and return a canonical pointer to member function type, for
11009 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
11011 tree
11013 {
11015 tree t;
11020 /* Make sure that we always have the unqualified pointer-to-member
11021 type first. */
11023 {
11026 }
11028 /* If a canonical type already exists for this type, use it. We use
11029 this method instead of type_hash_canon, because it only does a
11030 simple equality check on the list of field members. */
11038 /* Let the front end know this is a pointer to member function. */
11046 delta_type_node);
11053 /* Zap out the name so that the back end will give us the debugging
11054 information for this anonymous RECORD_TYPE. */
11057 /* Cache this pointer-to-member type so that we can find it again
11058 later. */
11067 }
11069 /* Create and return a pointer to data member type. */
11071 tree
11073 {
11075 {
11080 }
11081 else
11082 {
11085 }
11086 }
11088 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
11089 Check to see that the definition is valid. Issue appropriate error
11090 messages. */
11092 static void
11094 {
11095 /* Avoid redundant diagnostics on out-of-class definitions. */
11097 ;
11098 /* Can't check yet if we don't know the type. */
11100 ;
11101 /* If DECL is declared constexpr, we'll do the appropriate checks
11102 in check_initializer. Similarly for inline static data members. */
11106 ;
11108 {
11111 "in-class initialization of static data member %q#D of "
11115 "%<constexpr%> needed for in-class initialization of "
11117 else
11119 "in-class initialization of static data member %q#D of "
11121 }
11122 /* Motion 10 at San Diego: If a static const integral data member is
11123 initialized with an integral constant expression, the initializer
11124 may appear either in the declaration (within the class), or in
11125 the definition, but not both. If it appears in the class, the
11126 member is a member constant. The file-scope definition is always
11127 required. */
11130 "invalid in-class initialization of static data member "
11132 type);
11135 "ISO C++ forbids in-class initialization of non-const "
11137 decl);
11140 "ISO C++ forbids initialization of member constant "
11142 }
11144 /* *expr_p is part of the TYPE_SIZE of a variably-sized array. If any
11145 SAVE_EXPRs in *expr_p wrap expressions with side-effects, break those
11146 expressions out into temporary variables so that walk_tree doesn't
11147 step into them (c++/15764). */
11149 static tree
11151 {
11155 {
11161 }
11165 }
11167 /* Entry point for the above. */
11169 static void
11171 {
11173 /* Break out any function calls into temporary variables. */
11175 }
11177 /* Reduce a SIZEOF_EXPR to its value. */
11179 tree
11181 {
11182 tree r;
11191 else
11198 }
11200 /* Given the SIZE (i.e., number of elements) in an array, compute
11201 an appropriate index type for the array. If non-NULL, NAME is
11202 the name of the entity being declared. */
11204 static tree
11206 tsubst_flags_t complain)
11207 {
11211 /* The type of the index being computed. */
11212 tree itype;
11214 /* The original numeric size as seen in the source code before
11215 conversion to size_t. */
11221 {
11226 /* In C++98, we mark a non-constant array bound with a magic
11228 else
11229 {
11231 /* Pedantically a constant expression is required here and so
11232 __builtin_is_constant_evaluated () should fold to true if it
11233 is successfully folded into a constant. */
11239 }
11244 /* The array bound must be an integer type. */
11247 {
11253 else
11256 }
11257 }
11259 /* A type is dependent if it is...an array type constructed from any
11260 dependent type or whose size is specified by a constant expression
11261 that is value-dependent. */
11262 /* We can only call value_dependent_expression_p on integral constant
11263 expressions. */
11267 {
11268 /* Just build the index type and mark that it requires
11269 structural equality checks. */
11270 in_template:
11277 }
11280 {
11283 {
11287 else
11290 }
11292 /* We might have lost the TREE_CONSTANT flag e.g. when we are
11293 folding a conversion from a pointer to integral type. In that
11295 else
11296 /* Use the folded result for VLAs, too; it will have resolved
11297 SIZEOF_EXPR. */
11299 }
11301 /* Normally, the array-bound will be a constant. */
11303 {
11304 /* The size to use in diagnostics that reflects the constant
11305 size used in the source, rather than SIZE massaged above. */
11308 /* If the original size before conversion to size_t was signed
11309 and negative, convert it to ssizetype to restore the sign. */
11313 {
11316 /* Clear the overflow bit that may have been set as a result
11317 of the conversion from the sizetype of the new size to
11318 ssizetype. */
11320 }
11322 /* Verify that the array has a positive number of elements
11323 and issue the appropriate diagnostic if it doesn't. */
11325 {
11329 }
11330 /* As an extension we allow zero-sized arrays. */
11332 {
11334 /* We must fail if performing argument deduction (as
11335 indicated by the state of complain), so that
11336 another substitution can be found. */
11341 else
11344 }
11345 }
11347 /* We don't allow VLAs at non-function scopes, or during
11348 tentative template substitution. */
11351 {
11354 /* `(int) &fn' is not a valid array bound. */
11358 name);
11359 else
11362 }
11364 {
11368 else
11371 }
11373 {
11377 else
11380 }
11384 else
11385 {
11387 {
11388 /* A variable sized array. Arrange for the SAVE_EXPR on the inside
11389 of the MINUS_EXPR, which allows the -1 to get folded with the +1
11390 that happens when building TYPE_SIZE. */
11393 }
11395 /* Compute the index of the largest element in the array. It is
11396 one less than the number of elements in the array. We save
11397 and restore PROCESSING_TEMPLATE_DECL so that computations in
11398 cp_build_binary_op will be appropriately folded. */
11399 {
11400 processing_template_decl_sentinel s;
11402 MINUS_EXPR,
11405 complain),
11406 complain);
11408 }
11411 {
11414 {
11415 /* We have to add 1 -- in the ubsan routine we generate
11416 LE_EXPR rather than LT_EXPR. */
11421 }
11422 }
11423 /* Make sure that there was no overflow when creating to a signed
11424 index type. (For example, on a 32-bit machine, an array with
11425 size 2^32 - 1 is too big.) */
11428 {
11433 }
11434 }
11436 /* Create and return the appropriate index type. */
11439 /* If the index type were dependent, we would have returned early, so
11440 remember that it isn't. */
11444 }
11446 tree
11448 {
11450 }
11452 /* Returns the scope (if any) in which the entity declared by
11453 DECLARATOR will be located. If the entity was declared with an
11454 unqualified name, NULL_TREE is returned. */
11456 tree
11458 {
11462 /* If the declarator-id is a SCOPE_REF, the scope in which the
11463 declaration occurs is the first operand. */
11468 /* Otherwise, the declarator is not a qualified name; the entity will
11469 be declared in the current scope. */
11471 }
11473 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
11474 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
11475 with this type. */
11477 static tree
11479 {
11482 /* If things have already gone awry, bail now. */
11486 /* [dcl.type.class.deduct] prohibits forming an array of placeholder
11487 for a deduced class type. */
11489 {
11493 else
11496 }
11498 /* If there are some types which cannot be array elements,
11499 issue an error-message and return. */
11501 {
11505 else
11512 else
11519 else
11526 name);
11527 else
11533 }
11539 /* [dcl.array]
11541 The constant expressions that specify the bounds of the arrays
11542 can be omitted only for the first member of the sequence. */
11544 {
11548 name);
11549 else
11554 }
11556 /* Figure out the index type for the array. */
11558 {
11560 tf_warning_or_error);
11563 {
11566 }
11567 }
11570 }
11572 /* Returns the smallest location that is not UNKNOWN_LOCATION. */
11574 static location_t
11576 {
11582 }
11584 /* Returns the smallest location != UNKNOWN_LOCATION among the
11585 three stored in LOCATIONS[ds_const], LOCATIONS[ds_volatile],
11586 and LOCATIONS[ds_restrict]. */
11588 static location_t
11590 {
11603 }
11605 /* Returns the smallest among the latter and locations[ds_type_spec]. */
11607 static location_t
11609 {
11612 }
11614 static location_t
11616 {
11619 }
11621 /* Check that it's OK to declare a function with the indicated TYPE
11622 and TYPE_QUALS. SFK indicates the kind of special function (if any)
11623 that this function is. OPTYPE is the type given in a conversion
11624 operator declaration, or the class type for a constructor/destructor.
11625 Returns the actual return type of the function; that may be different
11626 than TYPE if an error occurs, or for certain special functions. */
11628 static tree
11630 tree type,
11631 tree optype,
11634 {
11636 {
11647 else
11659 /* We can't use the proper return type here because we run into
11660 problems with ambiguous bases and covariant returns. */
11663 else
11673 "qualifiers are not allowed on declaration of "
11685 "qualifiers are not allowed on declaration of "
11688 {
11692 }
11693 else
11703 }
11706 }
11708 /* A variable or data member (whose unqualified name is IDENTIFIER)
11709 has been declared with the indicated TYPE. If the TYPE is not
11710 acceptable, issue an error message and return a type to use for
11711 error-recovery purposes. */
11713 tree
11715 {
11717 {
11721 {
11724 identifier);
11725 }
11726 else
11729 }
11732 }
11734 /* Handle declaring DECL as an inline variable. */
11736 static void
11738 {
11741 {
11745 }
11750 {
11753 }
11754 }
11757 /* Assign a typedef-given name to a class or enumeration type declared
11758 as anonymous at first. This was split out of grokdeclarator
11759 because it is also used in libcc1. */
11761 void
11763 {
11766 /* Replace the anonymous decl with the real decl. Be careful not to
11767 rename other typedefs (such as the self-reference) of type. */
11773 /* If this is a typedef within a template class, the nested
11774 type is a (non-primary) template. The name for the
11775 template needs updating as well. */
11779 /* Adjust linkage now that we aren't unnamed anymore. */
11782 /* FIXME remangle member functions; member functions of a
11783 type with external linkage have external linkage. */
11785 /* Check that our job is done, and that it would fail if we
11786 attempted to do it again. */
11788 }
11790 /* Check that decltype(auto) was well-formed: only plain decltype(auto)
11791 is allowed. TYPE might contain a decltype(auto). Returns true if
11792 there was a problem, false otherwise. */
11794 static bool
11796 {
11798 {
11800 {
11802 {
11806 }
11808 {
11811 }
11812 }
11813 }
11815 }
11817 /* Given declspecs and a declarator (abstract or otherwise), determine
11818 the name and type of the object declared and construct a DECL node
11819 for it.
11821 DECLSPECS points to the representation of declaration-specifier
11822 sequence that precedes declarator.
11824 DECL_CONTEXT says which syntactic context this declaration is in:
11825 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
11826 FUNCDEF for a function definition. Like NORMAL but a few different
11827 error messages in each case. Return value may be zero meaning
11828 this definition is too screwy to try to parse.
11829 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
11830 handle member functions (which have FIELD context).
11831 Return value may be zero meaning this definition is too screwy to
11832 try to parse.
11833 PARM for a parameter declaration (either within a function prototype
11834 or before a function body). Make a PARM_DECL, or return void_type_node.
11835 TPARM for a template parameter declaration.
11836 CATCHPARM for a parameter declaration before a catch clause.
11837 TYPENAME if for a typename (in a cast or sizeof).
11838 Don't make a DECL node; just return the ..._TYPE node.
11839 FIELD for a struct or union field; make a FIELD_DECL.
11840 BITFIELD for a field with specified width.
11842 INITIALIZED is as for start_decl.
11844 ATTRLIST is a pointer to the list of attributes, which may be NULL
11845 if there are none; *ATTRLIST may be modified if attributes from inside
11846 the declarator should be applied to the declaration.
11848 When this function is called, scoping variables (such as
11849 CURRENT_CLASS_TYPE) should reflect the scope in which the
11850 declaration occurs, not the scope in which the new declaration will
11851 be placed. For example, on:
11853 void S::f() { ... }
11855 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
11856 should not be `S'.
11858 Returns a DECL (if a declarator is present), a TYPE (if there is no
11859 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
11860 error occurs. */
11862 tree
11868 {
11881 /* True if this declarator is a function definition. */
11885 #if 0
11886 /* See the code below that used this. */
11888 #endif
11890 /* Keep track of what sort of function is being processed
11891 so that we can warn about default return values, or explicit
11892 return values which do not match prescribed defaults. */
11898 /* cv-qualifiers that apply to the declarator, for a declaration of
11899 a member function. */
11901 /* virt-specifiers that apply to the declarator, for a declaration of
11902 a member function. */
11904 /* ref-qualifier that applies to the declarator, for a declaration of
11905 a member function. */
11907 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
11914 /* The unqualified name of the declarator; either an
11915 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
11916 tree unqualified_id;
11917 /* The class type, if any, in which this entity is located,
11918 or NULL_TREE if none. Note that this value may be different from
11919 the current class type; for example if an attempt is made to declare
11920 "A::f" inside "B", this value will be "A". */
11922 /* The NAMESPACE_DECL for the namespace in which this entity is
11923 located. If an unqualified name is used to declare the entity,
11924 this value will be NULL_TREE, even if the entity is located at
11925 namespace scope. */
11927 cp_storage_class storage_class;
11950 // Was concept_p specified? Note that ds_concept
11951 // implies ds_constexpr!
11973 location_t id_loc;
11974 location_t init_loc;
11976 {
11979 }
11980 else
11983 /* Look inside a declarator for the name being declared
11984 and get it as a string, for an error message. */
11986 id_declarator;
11988 {
11993 {
11997 {
12001 }
12005 {
12011 {
12016 {
12017 /* [dcl.meaning]
12019 A declarator-id shall not be qualified except
12020 for ...
12022 None of the cases are permitted in block
12023 scope. */
12026 decl);
12030 else
12034 }
12036 {
12039 {
12043 }
12045 && current_class_type
12047 current_class_type))
12048 {
12053 }
12054 }
12057 }
12059 {
12061 {
12063 {
12067 }
12070 {
12074 }
12081 }
12085 {
12091 }
12092 /* Fall through. */
12099 {
12101 dname);
12103 }
12106 else
12107 {
12114 else
12116 }
12121 }
12123 }
12140 }
12143 }
12145 /* [dcl.fct.edf]
12147 The declarator in a function-definition shall have the form
12148 D1 ( parameter-declaration-clause) ... */
12150 {
12153 }
12158 {
12161 }
12164 {
12167 {
12170 }
12173 {
12175 {
12178 }
12180 {
12183 }
12184 }
12185 }
12187 /* Anything declared one level down from the top level
12188 must be one of the parameters of a function
12189 (because the body is at least two levels down). */
12191 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
12192 by not allowing C++ class definitions to specify their parameters
12193 with xdecls (must be spec.d in the parmlist).
12195 Since we now wait to push a class scope until we are sure that
12196 we are in a legitimate method context, we must set oldcname
12197 explicitly (since current_class_name is not yet alive).
12199 We also want to avoid calling this a PARM if it is in a namespace. */
12202 {
12208 }
12214 {
12218 }
12221 {
12225 }
12228 {
12232 }
12235 {
12239 }
12242 {
12246 }
12248 /* [dcl.spec]/2 "At most one of the constexpr, consteval, and constinit
12249 keywords shall appear in a decl-specifier-seq." */
12251 {
12255 "can use at most one of the %<constinit%> and %<constexpr%> "
12258 }
12260 /* If there were multiple types specified in the decl-specifier-seq,
12261 issue an error message. */
12263 {
12267 }
12272 /* Extract the basic type from the decl-specifier-seq. */
12275 {
12278 }
12280 /* Ignore erroneous attributes. */
12284 /* An object declared as __attribute__((unavailable)) suppresses
12285 any reports of being declared with unavailable or deprecated
12286 items. An object declared as __attribute__((deprecated))
12287 suppresses warnings of uses of other deprecated items. */
12296 {
12302 }
12303 /* No type at all: default to `int', and set DEFAULTED_INT
12304 because it was not a user-defined typedef. */
12306 {
12308 {
12309 /* These imply 'int'. */
12312 }
12313 /* If we just have "complex", it is equivalent to "complex double". */
12316 {
12319 "ISO C++ does not support plain %<complex%> meaning "
12321 }
12322 }
12323 /* Gather flags. */
12327 #if 0
12328 /* See the code below that used this. */
12331 #endif
12336 else
12340 {
12342 ctor_return_type,
12343 type_quals,
12346 }
12348 {
12353 /* We handle `main' specially here, because 'main () { }' is so
12354 common. With no options, it is allowed. With -Wreturn-type,
12355 it is a warning. It is only an error with -pedantic-errors. */
12356 is_main = (funcdef_flag
12369 name);
12373 else
12378 /* FIXME we should be able to propagate the error_mark_node as is
12379 for other contexts too. */
12381 else
12383 }
12388 {
12390 {
12395 }
12396 /* Don't pedwarn if the alternate "__intN__" form has been used instead
12397 of "__intN". */
12402 }
12404 /* Now process the modifiers that were specified
12405 and check for invalid combinations. */
12407 /* Long double is a special combination. */
12409 {
12413 }
12415 /* Check all other uses of type modifiers. */
12418 {
12419 location_t loc;
12422 {
12425 }
12427 {
12430 }
12432 {
12435 }
12437 {
12440 }
12442 {
12445 }
12450 {
12455 }
12457 {
12461 }
12471 {
12473 {
12478 /* PR108099: __int128_t comes from c_common_nodes_and_builtins,
12479 and is not built as a typedef. */
12482 }
12485 else
12487 }
12488 else
12491 /* Discard the type modifiers if they are invalid. */
12493 {
12499 }
12500 }
12502 /* Decide whether an integer type is signed or not.
12503 Optionally treat bitfields as signed by default. */
12505 /* [class.bit]
12507 It is implementation-defined whether a plain (neither
12508 explicitly signed or unsigned) char, short, int, or long
12509 bit-field is signed or unsigned.
12511 Naturally, we extend this to long long as well. Note that
12512 this does not include wchar_t. */
12514 && !signed_p
12515 /* A typedef for plain `int' without `signed' can be
12516 controlled just like plain `int', but a typedef for
12517 `signed int' cannot be so controlled. */
12518 && !(typedef_decl
12522 {
12535 else
12537 }
12552 {
12556 /* If a modifier is specified, the resulting complex is the complex
12557 form of TYPE. E.g, "complex short" is "complex short int". */
12566 else
12568 }
12570 /* If we're using the injected-class-name to form a compound type or a
12571 declaration, replace it with the underlying class so we don't get
12572 redundant typedefs in the debug output. But if we are returning the
12573 type unchanged, leave it alone so that it's available to
12574 maybe_get_template_decl_from_type_decl. */
12582 type = cp_build_qualified_type
12586 /* We might have ignored or rejected some of the qualifiers. */
12591 /* Placeholder in parm gets a better error below. */
12595 {
12596 auto_diagnostic_group g;
12600 "for deduction, template placeholder must be followed "
12604 }
12615 /* Treat class-scope deduction guides as static member functions
12616 so that they get a FUNCTION_TYPE instead of a METHOD_TYPE. */
12620 {
12622 {
12629 }
12631 {
12635 "declared both %<virtual%> and %<constexpr%> only in "
12637 }
12638 }
12641 /* Issue errors about use of storage classes for parameters. */
12643 {
12645 {
12649 }
12651 {
12655 name);
12657 }
12661 {
12666 }
12668 /* Function parameters cannot be concept. */
12670 {
12675 }
12676 /* Function parameters cannot be constexpr. If we saw one, moan
12677 and pretend it wasn't there. */
12679 {
12683 }
12685 {
12689 }
12691 {
12695 }
12696 }
12698 /* Give error if `virtual' is used outside of class declaration. */
12701 {
12705 }
12708 {
12725 "structured binding declaration can be %qs only in "
12727 declspecs->gnu_thread_keyword_p
12732 /* [dcl.struct.bind] "A cv that includes volatile is deprecated." */
12737 {
12747 "structured binding declaration can be %qs only in "
12764 }
12767 {
12769 {
12770 auto_diagnostic_group d;
12774 "type must be cv-qualified %<auto%> or reference to "
12776 }
12779 }
12782 "structured binding declaration cannot have constrained "
12790 {
12793 }
12794 }
12796 /* Static anonymous unions are dealt with here. */
12802 /* Warn about storage classes that are invalid for certain
12803 kinds of declarations (parameters, typenames, etc.). */
12805 && ((storage_class
12809 {
12810 location_t loc
12815 }
12820 {
12824 ;
12826 ;
12828 /* C++ allows static class elements. */
12830 /* C++ also allows inlines and signed and unsigned elements,
12831 but in those cases we don't come in here. */
12832 ;
12833 else
12834 {
12835 location_t loc
12842 else
12849 }
12850 }
12855 {
12859 }
12863 {
12869 /* When thread_local is applied to a variable of block scope the
12870 storage-class-specifier static is implied if it does not appear
12871 explicitly. */
12874 }
12877 {
12880 "storage class specifiers invalid in friend function "
12884 }
12888 else
12889 {
12892 {
12905 }
12906 }
12910 {
12915 }
12920 /* Determine the type of the entity declared by recurring on the
12921 declarator. */
12923 {
12925 tree attrs;
12932 {
12944 /* Assume that any attributes that get applied late to
12945 templates will DTRT when applied to the declaration
12946 as a whole. */
12950 attrs),
12951 attr_flags);
12953 }
12957 /* Check that contracts aren't misapplied. */
12963 /* We don't want to warn in parameter context because we don't
12964 yet know if the parse will succeed, and this might turn out
12965 to be a constructor call. */
12968 && !typedef_p
12970 /* If the type is class-like and the inner name used a
12971 global namespace qualifier, we need the parens.
12972 Unfortunately all we can tell is whether a qualified name
12973 was used or not. */
12974 && !(inner_declarator
12979 {
12982 name))
12983 {
12988 }
12989 }
12994 {
13005 /* [dcl.array]/1:
13007 The optional attribute-specifier-seq appertains to the
13008 array. */
13014 {
13015 tree arg_types;
13018 /* Declaring a function type. */
13020 /* Pick up type qualifiers which should be applied to `this'. */
13022 /* Pick up virt-specifiers. */
13024 /* And ref-qualifier, too */
13026 /* And tx-qualifier. */
13028 /* Pick up the exception specifications. */
13030 /* If the exception-specification is ill-formed, let's pretend
13031 there wasn't one. */
13039 /* Say it's a definition only for the CALL_EXPR
13040 closest to the identifier. */
13043 /* Handle a late-specified return type. */
13046 {
13048 {
13055 {
13057 "%<auto%> type specifier without "
13060 "deduced return type only available "
13062 }
13064 {
13068 }
13069 }
13071 {
13073 "return type has %qT as its type rather "
13076 }
13078 {
13081 "%qs function with trailing return type "
13082 "has %<decltype(auto)%> as its type "
13084 else
13088 }
13094 {
13096 {
13097 auto_diagnostic_group g;
13104 }
13106 {
13108 "for %qT must have trailing return "
13113 }
13119 else
13123 }
13124 }
13127 {
13131 /* Not using maybe_warn_cpp0x because this should
13132 always be an error. */
13134 "trailing return type only available "
13136 else
13138 "return type not declared with %<auto%> "
13141 }
13143 {
13146 }
13152 {
13155 }
13158 {
13159 /* It's wrong, for instance, to issue a -Wignored-qualifiers
13160 warning for
13161 static_assert(!is_same_v<void(*)(), const void(*)()>);
13162 because there the qualifier matters. */
13166 /* [dcl.fct] "A volatile-qualified return type is
13167 deprecated." */
13170 "%<volatile%>-qualified return type is "
13173 /* We now know that the TYPE_QUALS don't apply to the
13174 decl, but to its return type. */
13176 }
13178 /* Error about some types functions can't return. */
13181 {
13185 }
13187 {
13191 }
13193 {
13195 "%<constinit%> on function return type is not "
13198 }
13205 && funcdecl_p
13211 {
13212 /* We are within a class's scope. If our declarator name
13213 is the same as the class name, and we are defining
13214 a function, then it is a constructor/destructor, and
13215 therefore returns a void type. */
13217 /* ISO C++ 12.4/2. A destructor may not be declared
13218 const or volatile. A destructor may not be static.
13219 A destructor may not be declared with ref-qualifier.
13221 ISO C++ 12.1. A constructor may not be declared
13222 const or volatile. A constructor may not be
13223 virtual. A constructor may not be static.
13224 A constructor may not be declared with ref-qualifier. */
13233 {
13238 }
13241 {
13247 }
13251 current_class_type,
13252 flags))
13256 {
13257 /* It's a constructor. */
13261 {
13265 }
13269 }
13272 }
13274 {
13276 {
13277 /* Cannot be both friend and virtual. */
13282 }
13287 {
13289 "cannot define friend function %qs in a local "
13292 }
13293 /* [class.friend]/6: A function can be defined in a friend
13294 declaration if the function name is unqualified. */
13296 {
13299 "friend function definition %qs cannot have "
13301 else
13303 "friend function definition %qs cannot have "
13305 in_namespace);
13306 }
13307 }
13309 {
13311 {
13314 }
13315 }
13317 {
13320 }
13327 pushed_scope
13339 {
13344 }
13350 {
13352 /* transaction_safe applies to the type, but
13353 transaction_safe_dynamic applies to the function. */
13356 else
13358 }
13360 /* Actually apply the contract attributes to the declaration. */
13362 {
13365 {
13367 /* Intentionally reverse order of contracts so they're
13368 reversed back into their lexical order. */
13371 }
13372 else
13374 }
13377 /* [dcl.fct]/2:
13379 The optional attribute-specifier-seq appertains to
13380 the function type. */
13385 }
13391 /* Filter out pointers-to-references and references-to-references.
13392 We can get these if a TYPE_DECL is used. */
13395 {
13397 {
13400 }
13402 /* In C++0x, we allow reference to reference declarations
13403 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
13404 and template type arguments [14.3.1/4 temp.arg.type]. The
13405 check for direct reference to reference declarations, which
13406 are still forbidden, occurs below. Reasoning behind the change
13407 can be found in DR106, DR540, and the rvalue reference
13408 proposals. */
13410 {
13413 }
13414 }
13416 {
13421 }
13423 /* We now know that the TYPE_QUALS don't apply to the decl,
13424 but to the target of the pointer. */
13427 /* This code used to handle METHOD_TYPE, but I don't think it's
13428 possible to get it here anymore. */
13432 {
13436 memfn_quals,
13437 rqual);
13443 }
13451 type);
13453 /* When the pointed-to type involves components of variable size,
13454 care must be taken to ensure that the size evaluation code is
13455 emitted early enough to dominate all the possible later uses
13456 and late enough for the variables on which it depends to have
13457 been assigned.
13459 This is expected to happen automatically when the pointed-to
13460 type has a name/declaration of it's own, but special attention
13461 is required if the type is anonymous.
13463 We handle the NORMAL and FIELD contexts here by inserting a
13464 dummy statement that just evaluates the size at a safe point
13465 and ensures it is not deferred until e.g. within a deeper
13466 conditional context (c++/43555).
13468 We expect nothing to be needed here for PARM or TYPENAME.
13469 Evaluating the size at this point for TYPENAME would
13470 actually be incorrect, as we might be in the middle of an
13471 expression with side effects on the pointed-to type size
13472 "arguments" prior to the pointer declaration point and the
13473 size evaluation could end up prior to the side effects. */
13479 {
13483 }
13486 {
13487 /* In C++0x, the type we are creating a reference to might be
13488 a typedef which is itself a reference type. In that case,
13489 we follow the reference collapsing rules in
13490 [7.1.3/8 dcl.typedef] to create the final reference type:
13492 "If a typedef TD names a type that is a reference to a type
13493 T, an attempt to create the type 'lvalue reference to cv TD'
13494 creates the type 'lvalue reference to T,' while an attempt
13495 to create the type "rvalue reference to cv TD' creates the
13496 type TD."
13497 */
13501 {
13504 else
13506 }
13507 else
13508 type = cp_build_reference_type
13511 /* In C++0x, we need this check for direct reference to
13512 reference declarations, which are forbidden by
13513 [8.3.2/5 dcl.ref]. Reference to reference declarations
13514 are only allowed indirectly through typedefs and template
13515 type arguments. Example:
13517 void foo(int & &); // invalid ref-to-ref decl
13519 typedef int & int_ref;
13520 void foo(int_ref &); // valid ref-to-ref decl
13521 */
13525 }
13529 {
13533 /* We will already have complained. */
13535 else
13537 type);
13538 }
13539 else
13542 /* Process a list of type modifier keywords (such as
13543 const or volatile) that were given inside the `*' or `&'. */
13546 {
13547 type
13551 }
13553 /* Apply C++11 attributes to the pointer, and not to the
13554 type pointed to. This is unlike what is done for GNU
13555 attributes above. It is to comply with [dcl.ptr]/1:
13557 [the optional attribute-specifier-seq (7.6.1) appertains
13558 to the pointer and not to the object pointed to]. */
13571 }
13572 }
13577 /* Don't check this if it can be the artifical decltype(auto)
13578 we created when building a constraint in a compound-requirement:
13579 that the type-constraint is plain is going to be checked in
13580 cp_parser_compound_requirement. */
13585 /* A `constexpr' specifier used in an object declaration declares
13586 the object as `const'. */
13588 {
13589 /* DR1688 says that a `constexpr' specifier in combination with
13590 `volatile' is valid. */
13593 {
13596 }
13597 }
13602 {
13604 unqualified_id);
13606 }
13608 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
13609 qualified with a class-name, turn it into a METHOD_TYPE, unless
13610 we know that the function is static. We take advantage of this
13611 opportunity to do other processing that pertains to entities
13612 explicitly declared to be class members. Note that if DECLARATOR
13613 is non-NULL, we know it is a cdk_id declarator; otherwise, we
13614 would not have exited the loop above. */
13619 {
13625 {
13627 {
13629 "member functions are implicitly "
13632 }
13633 else
13636 }
13638 can skip the following checks. */
13641 qualifying type must certainly be complete. */
13642 funcdef_flag
13643 /* A friend declaration of "T::f" is OK, even if
13644 "T" is a template parameter. But, if this
13645 function is not a friend, the qualifying type
13646 must be a class. */
13648 /* For a declaration, the type need not be
13649 complete, if either it is dependent (since there
13650 is no meaningful definition of complete in that
13651 case) or the qualifying class is currently being
13652 defined. */
13655 /* Check that the qualifying type is complete. */
13659 {
13662 {
13670 }
13671 }
13673 {
13677 }
13678 }
13683 /* Now TYPE has the actual type. */
13686 {
13689 else
13691 }
13697 {
13698 /* [dcl.meaning]/1: The optional attribute-specifier-seq following
13699 a declarator-id appertains to the entity that is declared. */
13702 else
13703 /* We should have already diagnosed the issue (c++/78344). */
13705 }
13707 /* Handle parameter packs. */
13709 {
13711 /* Turn the type into a pack expansion.*/
13713 else
13715 }
13718 && !processing_template_decl
13720 {
13724 else
13728 }
13731 {
13732 /* [dcl.fct.spec] (C++11) The explicit specifier shall be used only
13733 in the declaration of a constructor or conversion function within
13734 a class definition. */
13741 else
13743 "only declarations of constructors and conversion operators "
13746 }
13749 {
13752 {
13754 name);
13756 }
13758 {
13761 name);
13763 }
13765 {
13767 name);
13769 }
13771 {
13773 name);
13775 }
13777 {
13779 name);
13781 }
13783 {
13785 name);
13787 }
13788 }
13790 /* If this is declaring a typedef name, return a TYPE_DECL. */
13792 {
13794 tree decl;
13797 {
13801 else
13805 }
13807 /* This declaration:
13809 typedef void f(int) const;
13811 declares a function type which is not a member of any
13812 particular class, but which is cv-qualified; for
13813 example "f S::*" declares a pointer to a const-qualified
13814 member function of S. We record the cv-qualification in the
13815 function type. */
13817 {
13820 /* We have now dealt with these qualifiers. */
13823 }
13826 {
13830 else
13834 }
13840 {
13843 }
13847 else
13851 {
13855 /* The TYPE_DECL is "abstract" because there will be
13856 clones of this constructor/destructor, and there will
13857 be copies of this TYPE_DECL generated in those
13858 clones. The decloning optimization (for space) may
13859 revert this subsequently if it determines that
13860 the clones should share a common implementation. */
13864 }
13869 unqualified_id);
13871 /* If the user declares "typedef struct {...} foo" then the
13872 struct will have an anonymous name. Fill that name in now.
13873 Nothing can refer to it, so nothing needs know about the name
13874 change. */
13876 && unqualified_id
13895 /* Acknowledge that this was written:
13896 `using analias = atype;'. */
13900 }
13902 /* Detect the case of an array type of unspecified size
13903 which came, as such, direct from a typedef name.
13904 We must copy the type, so that the array's domain can be
13905 individually set by the object's initializer. */
13912 /* Detect where we're using a typedef of function type to declare a
13913 function. PARMS will not be set, so we must create it now. */
13916 {
13918 tree args;
13923 {
13929 }
13934 {
13935 /* The qualifiers on the function type become the qualifiers on
13936 the non-static member function. */
13941 }
13942 }
13944 /* If this is a type name (such as, in a cast or sizeof),
13945 compute the type and return it now. */
13948 {
13949 /* Note that here we don't care about type_quals. */
13951 /* Special case: "friend class foo" looks like a TYPENAME context. */
13953 {
13955 {
13958 }
13961 {
13962 /* Don't allow friend declaration without a class-key. */
13969 else
13972 type);
13973 }
13975 /* Only try to do this stuff if we didn't already give up. */
13977 {
13978 /* A friendly class? */
13982 else
13984 type);
13987 }
13988 }
13990 {
13997 /* Core issue #547: need to allow this in template type args.
13998 Allow it in general in C++11 for alias-declarations. */
14002 else
14004 }
14010 }
14014 && ! bitfield
14016 {
14019 }
14022 {
14023 /* Only functions may be declared using an operator-function-id. */
14025 {
14028 }
14033 type);
14034 }
14036 /* We don't check parameter types here because we can emit a better
14037 error message later. */
14039 {
14043 }
14045 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
14046 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
14049 {
14055 {
14057 {
14062 {
14063 auto_diagnostic_group g;
14067 "missing template argument list after %qE; template "
14073 }
14074 else
14077 }
14078 else
14081 }
14083 /* A parameter declared as an array of T is really a pointer to T.
14084 One declared as a function is really a pointer to a function.
14085 One declared as a member is really a pointer to member. */
14088 {
14089 /* Transfer const-ness of array into that of type pointed to. */
14093 }
14096 }
14099 && !(unqualified_id
14102 {
14108 }
14110 {
14114 {
14122 }
14124 {
14127 {
14133 else
14137 }
14139 /* The C99 flexible array extension. */
14142 {
14146 {
14149 }
14150 else
14151 {
14152 /* Array is a flexible member. */
14156 else
14160 /* Flexible array member has a null domain. */
14162 }
14163 }
14166 {
14167 /* Happens when declaring arrays of sizes which
14168 are error_mark_node, for example. */
14170 }
14172 {
14173 /* Something like struct S { int N::j; }; */
14176 }
14178 {
14180 tree function_context;
14183 {
14184 /* This should never happen in pure C++ (the check
14185 could be an assert). It could happen in
14186 Objective-C++ if someone writes invalid code that
14187 uses a function declaration for an instance
14188 variable or property (instance variables and
14189 properties are parsed as FIELD_DECLs, but they are
14190 part of an Objective-C class, not a C++ class).
14191 That code is invalid and is caught by this
14192 check. */
14194 {
14196 unqualified_id);
14198 }
14200 /* ``A union may [ ... ] not [ have ] virtual functions.''
14201 ARM 9.5 */
14203 {
14206 unqualified_id);
14208 }
14213 {
14215 "%qD cannot be declared %<virtual%>, since it "
14218 }
14219 }
14221 /* Check that the name used for a destructor makes sense. */
14223 {
14227 {
14232 }
14235 {
14239 }
14241 {
14245 }
14247 {
14249 "%<constexpr%> destructors only available"
14252 }
14254 {
14258 }
14259 }
14261 {
14266 }
14269 {
14273 }
14275 {
14279 }
14283 {
14287 }
14290 {
14293 {
14299 }
14300 }
14302 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
14303 function_context
14312 parms,
14313 unqualified_id,
14314 declspecs,
14315 reqs,
14327 #if 0
14328 /* This clobbers the attrs stored in `decl' from `attrlist'. */
14329 /* The decl and setting of decl_attr is also turned off. */
14331 #endif
14333 /* [class.conv.ctor]
14335 A constructor declared without the function-specifier
14336 explicit that can be called with a single parameter
14337 specifies a conversion from the type of its first
14338 parameter to the type of its class. Such a constructor
14339 is called a converting constructor. */
14345 }
14347 && ((current_class_type
14353 {
14356 {
14358 {
14362 }
14363 else
14368 }
14369 }
14371 staticp
14372 ? TCTX_STATIC_STORAGE
14374 {
14377 }
14378 else
14379 {
14381 {
14384 "%qE is neither function nor member function; "
14386 else
14390 }
14392 }
14395 {
14396 /* Packages tend to use GNU attributes on friends, so we only
14397 warn for standard attributes. */
14399 && !funcdef_flag
14402 {
14407 }
14408 /* Friends are treated specially. */
14412 {
14416 /* Kludge: We need funcdef_flag to be true in do_friend for
14417 in-class defaulted functions, but that breaks grokfndecl.
14418 So set it here. */
14428 }
14429 else
14431 }
14433 /* Structure field. It may not be a function, except for C++. */
14436 {
14438 {
14439 /* C++ allows static class members. All other work
14440 for this is done by grokfield. */
14449 {
14451 "%<constexpr%> static data member %qD must "
14454 }
14465 /* Even if there is an in-class initialization, DECL
14466 is considered undefined until an out-of-class
14467 definition is provided, unless this is an inline
14468 variable. */
14472 {
14478 }
14480 /* Set the constraints on the declaration. */
14484 {
14487 }
14488 }
14489 else
14490 {
14492 {
14498 }
14500 {
14505 }
14507 {
14512 }
14514 {
14519 }
14526 {
14529 }
14532 {
14533 /* An attempt is being made to initialize a non-static
14534 member. This is new in C++11. */
14537 /* If this has been parsed with static storage class, but
14538 errors forced staticp to be cleared, ensure NSDMI is
14539 not present. */
14542 }
14543 }
14550 }
14551 }
14553 {
14554 tree original_name;
14562 else
14564 // FIXME:gcc_assert (original_name == dname);
14572 name);
14574 {
14578 name);
14579 else
14581 "storage class %<thread_local%> invalid for "
14583 }
14588 /* Function declaration not at top level.
14589 Storage classes other than `extern' are not allowed
14590 and `extern' makes no difference. */
14595 {
14598 "%<static%> specifier invalid for function %qs "
14600 else
14602 "%<inline%> specifier invalid for function %qs "
14604 }
14607 {
14609 {
14612 }
14615 {
14620 }
14621 }
14625 {
14629 }
14631 /* Record whether the function is public. */
14636 declspecs,
14639 publicp,
14643 sfk,
14644 funcdef_flag,
14645 late_return_type_p,
14647 id_loc);
14654 {
14657 /* Don't allow a static member function in a class, and forbid
14658 declaring main to be static. */
14660 {
14664 }
14666 {
14667 /* 7.1.1: There can be no static function declarations within a
14668 block. */
14672 }
14675 {
14678 }
14679 }
14682 }
14683 else
14684 {
14685 /* It's a variable. */
14687 /* An uninitialized decl with `extern' is a reference. */
14689 declspecs,
14690 initialized,
14691 type_quals,
14692 inlinep,
14693 concept_p,
14694 template_count,
14696 id_loc);
14706 {
14709 {
14711 "%<static%> may not be used when defining "
14715 }
14717 {
14720 }
14722 {
14724 "cannot explicitly declare member %q#D to have "
14727 }
14728 }
14730 {
14732 "declaration of %<constexpr%> variable %qD "
14735 }
14737 {
14741 }
14746 {
14751 }
14752 }
14757 {
14761 }
14764 {
14766 {
14767 /* It's common practice (and completely valid) to have a const
14768 be initialized and declared extern. */
14772 }
14773 else
14774 {
14778 }
14779 }
14781 /* Record `register' declaration for warnings on &
14782 and in case doing stupid register allocation. */
14785 {
14787 /* Warn about register storage specifiers on PARM_DECLs. */
14789 {
14792 "ISO C++17 does not allow %<register%> storage "
14794 else
14797 }
14798 }
14805 {
14806 /* Set constexpr flag on vars (functions got it in grokfndecl). */
14809 /* And the constinit flag (which only applies to variables). */
14812 }
14814 {
14815 /* If we saw a return type, record its location. */
14820 {
14826 }
14829 }
14831 /* Record constancy and volatility on the DECL itself . There's
14832 no need to do this when processing a template; we'll do this
14833 for the instantiated declaration based on the type of DECL. */
14838 }
14839 }
14840 \f
14841 /* Subroutine of start_function. Ensure that each of the parameter
14842 types (as listed in PARMS) is complete, as is required for a
14843 function definition. */
14845 static void
14847 {
14849 {
14854 {
14861 }
14862 else
14863 /* grokparms or complete_type_or_else will have already issued
14864 an error. */
14866 }
14867 }
14869 /* Returns nonzero if T is a local variable. */
14871 int
14873 {
14882 }
14884 /* Like local_variable_p, but suitable for use as a tree-walking
14885 function. */
14887 static tree
14890 {
14892 {
14893 /* DR 2082 permits local variables in unevaluated contexts
14894 within a default argument. */
14897 }
14906 }
14908 /* Check that ARG, which is a default-argument expression for a
14909 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
14910 something goes wrong. DECL may also be a _TYPE node, rather than a
14911 DECL, if there is no DECL available. */
14913 tree
14915 {
14916 tree var;
14917 tree decl_type;
14920 /* We get a DEFERRED_PARSE when looking at an in-class declaration
14921 with a default argument. Ignore the argument for now; we'll
14922 deal with it after the class is complete. */
14926 {
14929 }
14930 else
14937 /* Something already went wrong. There's no need to check
14938 further. */
14941 /* [dcl.fct.default]
14943 A default argument expression is implicitly converted to the
14944 parameter type. */
14946 /* Avoid digest_init clobbering the initializer. */
14949 LOOKUP_IMPLICIT);
14952 /* Avoid redundant -Wzero-as-null-pointer-constant warnings at
14953 the call sites. */
14956 /* Don't lose side-effects as in PR90473. */
14960 /* [dcl.fct.default]
14962 Local variables shall not be used in default argument
14963 expressions.
14965 The keyword `this' shall not be used in a default argument of a
14966 member function. */
14969 {
14971 {
14975 else
14977 }
14979 }
14981 /* All is well. */
14983 }
14985 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
14987 static tree
14989 {
14994 {
14997 else
14998 {
15001 }
15002 }
15004 /* Do warn about using typedefs to a deprecated class. */
15016 return type_is_deprecated
15020 }
15022 /* Returns an unavailable type used within TYPE, or NULL_TREE if none. */
15024 static tree
15026 {
15031 {
15034 else
15035 {
15038 }
15039 }
15041 /* Do warn about using typedefs to a deprecated class. */
15053 return type_is_unavailable
15057 }
15059 /* Decode the list of parameter types for a function type.
15060 Given the list of things declared inside the parens,
15061 return a list of types.
15063 If this parameter does not end with an ellipsis, we append
15064 void_list_node.
15066 *PARMS is set to the chain of PARM_DECLs created. */
15068 tree
15070 {
15073 tree parm;
15077 {
15086 {
15089 }
15093 {
15095 && !init
15098 /* DR 577: A parameter list consisting of a single
15099 unnamed parameter of non-dependent type 'void'. */
15103 "invalid use of cv-qualified type %qT in "
15105 else
15107 "invalid use of type %<void%> in parameter "
15109 /* It's not a good idea to actually create parameters of
15110 type `void'; other parts of the compiler assume that a
15111 void type terminates the parameter list. */
15114 }
15117 {
15119 {
15123 }
15126 {
15130 }
15132 /* [dcl.fct] "A parameter with volatile-qualified type is
15133 deprecated." */
15136 "%<volatile%>-qualified parameter is "
15139 /* Top-level qualifiers on the parameters are
15140 ignored for function types. */
15143 {
15147 }
15149 {
15150 /* Before C++17 DR 393:
15151 [dcl.fct]/6, parameter types cannot contain pointers
15152 (references) to arrays of unknown bound. */
15157 {
15165 }
15168 ptr
15174 }
15178 }
15183 }
15193 /* We had parm errors, recover by giving the function (...) type. */
15197 }
15199 \f
15200 /* D is a constructor or overloaded `operator='.
15202 Let T be the class in which D is declared. Then, this function
15203 returns:
15205 -1 if D's is an ill-formed constructor or copy assignment operator
15206 whose first parameter is of type `T'.
15207 0 if D is not a copy constructor or copy assignment
15208 operator.
15209 1 if D is a copy constructor or copy assignment operator whose
15210 first parameter is a reference to non-const qualified T.
15211 2 if D is a copy constructor or copy assignment operator whose
15212 first parameter is a reference to const qualified T.
15214 This function can be used as a predicate. Positive values indicate
15215 a copy constructor and nonzero values indicate a copy assignment
15216 operator. */
15218 int
15220 {
15221 tree args;
15222 tree arg_type;
15230 /* Instantiations of template member functions are never copy
15231 functions. Note that member functions of templated classes are
15232 represented as template functions internally, and we must
15233 accept those as copy functions. */
15249 {
15250 /* Pass by value copy assignment operator. */
15252 }
15256 {
15259 }
15260 else
15266 /* There are more non-optional args. */
15270 }
15272 /* D is a constructor or overloaded `operator='.
15274 Let T be the class in which D is declared. Then, this function
15275 returns true when D is a move constructor or move assignment
15276 operator, false otherwise. */
15278 bool
15280 {
15282 /* There are no move constructors if we are in C++98 mode. */
15288 /* Instantiations of template member functions are never move
15289 functions. Note that member functions of templated classes are
15290 represented as template functions internally, and we must
15291 accept those as move functions. */
15295 }
15297 /* D is a constructor or overloaded `operator='.
15299 Then, this function returns true when D has the same signature as a move
15300 constructor or move assignment operator (because either it is such a
15301 ctor/op= or it is a template specialization with the same signature),
15302 false otherwise. */
15304 bool
15306 {
15307 tree args;
15308 tree arg_type;
15332 /* There are more non-optional args. */
15336 }
15338 /* Remember any special properties of member function DECL. */
15340 void
15342 {
15343 tree class_type;
15351 {
15358 {
15359 /* [class.copy]
15361 A non-template constructor for class X is a copy
15362 constructor if its first parameter is of type X&, const
15363 X&, volatile X& or const volatile X&, and either there
15364 are no other parameters or else all other parameters have
15365 default arguments. */
15369 }
15380 }
15382 {
15383 /* [class.copy]
15385 A non-template assignment operator for class X is a copy
15386 assignment operator if its parameter is of type X, X&, const
15387 X&, volatile X& or const volatile X&. */
15392 {
15396 }
15397 }
15401 /* Destructors are handled in check_methods. */
15402 }
15404 /* Check a constructor DECL has the correct form. Complains
15405 if the class has a constructor of the form X(X). */
15407 bool
15409 {
15413 {
15414 /* [class.copy]
15416 A declaration of a constructor for a class X is ill-formed if
15417 its first parameter is of type (optionally cv-qualified) X
15418 and either there are no other parameters or else all other
15419 parameters have default arguments.
15421 We *don't* complain about member template instantiations that
15422 have this form, though; they can occur as we try to decide
15423 what constructor to use during overload resolution. Since
15424 overload resolution will never prefer such a constructor to
15425 the non-template copy constructor (which is either explicitly
15426 or implicitly defined), there's no need to worry about their
15427 existence. Theoretically, they should never even be
15428 instantiated, but that's hard to forestall. */
15433 }
15436 }
15438 /* DECL is a declaration for an overloaded or conversion operator. If
15439 COMPLAIN is true, errors are issued for invalid declarations. */
15441 bool
15443 {
15453 tree_code operator_code;
15456 {
15457 /* Conversion operators are TYPE_EXPR for the purposes of this
15458 function. */
15461 }
15462 else
15463 {
15470 }
15473 {
15474 /* operator new and operator delete are quite special. */
15477 {
15496 }
15498 /* [basic.std.dynamic.allocation]/1:
15500 A program is ill-formed if an allocation function is declared
15501 in a namespace scope other than global scope or declared
15502 static in global scope.
15504 The same also holds true for deallocation functions. */
15506 {
15508 {
15510 decl);
15512 }
15515 {
15518 }
15519 }
15522 {
15525 }
15526 else
15527 {
15530 }
15533 }
15535 /* An operator function must either be a non-static member function
15536 or have at least one parameter of a class, a reference to a class,
15537 an enumeration, or a reference to an enumeration. 13.4.0.6 */
15539 {
15543 {
15546 }
15549 {
15551 {
15554 }
15556 /* For lambdas we diagnose static lambda specifier elsewhere. */
15558 /* For instantiations, we have diagnosed this already. */
15562 decl);
15564 /* static operator[] should have exactly one argument
15565 for C++20 and earlier, so that it isn't multidimensional. */
15567 }
15569 {
15573 }
15574 else
15576 {
15578 {
15583 }
15589 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
15590 because these checks are performed even on template
15591 functions. */
15595 }
15596 }
15599 /* There are no further restrictions on the arguments to an overloaded
15600 "operator ()". */
15603 /* C++23 allows an arbitrary number of parameters and default arguments for
15604 operator[], and none of the other checks below apply. */
15609 {
15610 /* 13.4.0.3 */
15613 }
15615 /* Count the number of arguments and check for ellipsis. */
15618 {
15620 {
15622 decl);
15624 }
15626 }
15628 /* Verify correct number of arguments. */
15630 {
15633 {
15634 /* We have a unary instance of an ambi-ary op. Remap to the
15635 unary one. */
15641 }
15643 {
15644 /* This was an ambiguous operator but is invalid. */
15646 methodp
15650 }
15653 && ! processing_template_decl
15654 /* x++ and x--'s second argument must be an int. */
15656 integer_type_node))
15657 {
15659 methodp
15662 decl);
15664 }
15669 {
15671 methodp
15675 }
15680 {
15682 methodp
15686 }
15691 }
15693 /* There can be no default arguments. */
15697 {
15701 }
15703 /* At this point the declaration is well-formed. It may not be
15704 sensible though. */
15706 /* Check member function warnings only on the in-class declaration.
15707 There's no point warning on an out-of-class definition. */
15711 /* Warn about conversion operators that will never be used. */
15715 {
15726 {
15729 ref
15734 class_type);
15735 /* Don't force t to be complete here. */
15740 ref
15746 }
15747 }
15752 /* Effective C++ rules below. */
15754 /* More Effective C++ rule 7. */
15761 /* More Effective C++ rule 6. */
15766 {
15775 {
15780 }
15781 else
15782 {
15786 }
15787 }
15789 /* Effective C++ rule 23. */
15800 }
15801 \f
15802 /* Return a string giving the keyword associate with CODE. */
15806 {
15808 {
15821 }
15822 }
15824 /* Name lookup in an elaborated-type-specifier (after the keyword
15825 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
15826 elaborated-type-specifier is invalid, issue a diagnostic and return
15827 error_mark_node; otherwise, return the *_TYPE to which it referred.
15828 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
15830 tree
15832 tree decl,
15834 {
15835 tree type;
15837 /* In the case of:
15839 struct S { struct S *p; };
15841 name lookup will find the TYPE_DECL for the implicit "S::S"
15842 typedef. Adjust for that here. */
15848 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
15849 is false for this case as well. */
15851 {
15855 }
15856 /* Accept template template parameters. */
15860 ;
15861 /* [dcl.type.elab]
15863 If the identifier resolves to a typedef-name or the
15864 simple-template-id resolves to an alias template
15865 specialization, the elaborated-type-specifier is ill-formed.
15867 In other words, the only legitimate declaration to use in the
15868 elaborated type specifier is the implicit typedef created when
15869 the type is declared. */
15873 {
15877 else
15882 }
15887 {
15891 }
15894 {
15898 }
15902 {
15903 /* If a class template appears as elaborated type specifier
15904 without a template header such as:
15906 template <class T> class C {};
15907 void f(class C); // No template header here
15909 then the required template argument is missing. */
15914 }
15917 }
15919 /* Lookup NAME of an elaborated type specifier according to SCOPE and
15920 issue diagnostics if necessary. Return *_TYPE node upon success,
15921 NULL_TREE when the NAME is not found, and ERROR_MARK_NODE for type
15922 error. */
15924 static tree
15927 {
15928 tree decl;
15930 {
15931 /* First try ordinary name lookup, ignoring hidden class name
15932 injected via friend declaration. */
15935 /* If that fails, the name will be placed in the smallest
15936 non-class, non-function-prototype scope according to 3.3.1/5.
15937 We may already have a hidden name declared as friend in this
15938 scope. So lookup again but not ignoring hidden names.
15939 If we find one, that name will be made visible rather than
15940 creating a new tag. */
15943 }
15944 else
15948 /* We found nothing. */
15952 {
15956 }
15959 && !template_header_p
15961 {
15966 }
15969 /* If scope is TAG_how::CURRENT_ONLY we're defining a class,
15970 so ignore a template template parameter. */
15975 /* Found not-a-type. */
15978 /* Look for invalid nested type:
15979 class C {
15980 class C {};
15981 }; */
15983 {
15987 }
15989 /* Two cases we need to consider when deciding if a class
15990 template is allowed as an elaborated type specifier:
15991 1. It is a self reference to its own class.
15992 2. It comes with a template header.
15994 For example:
15996 template <class T> class C {
15997 class C *c1; // DECL_SELF_REFERENCE_P is true
15998 class D;
15999 };
16000 template <class U> class C; // template_header_p is true
16001 template <class T> class C<T>::D {
16002 class C *c2; // DECL_SELF_REFERENCE_P is true
16003 }; */
16006 template_header_p
16011 {
16020 }
16023 }
16025 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
16026 Define the tag as a forward-reference if it is not defined.
16028 If a declaration is given, process it here, and report an error if
16029 multiple declarations are not identical.
16031 SCOPE is TS_CURRENT when this is also a definition. Only look in
16032 the current frame for the name (since C++ allows new names in any
16033 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
16034 declaration. Only look beginning from the current scope outward up
16035 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
16037 TEMPLATE_HEADER_P is true when this declaration is preceded by
16038 a set of template parameters. */
16040 tree
16043 {
16052 {
16065 }
16067 /* In case of anonymous name, xref_tag is only called to
16068 make type node and push name. Name lookup is not required. */
16079 {
16083 /* Since HOW is not TAG_how::CURRENT_ONLY, we are not looking at
16084 a definition of this tag. Since, in addition, we are
16085 currently processing a (member) template declaration of a
16086 template class, we must be very careful; consider:
16088 template <class X> struct S1
16090 template <class U> struct S2
16091 {
16092 template <class V> friend struct S1;
16093 };
16095 Here, the S2::S1 declaration should not be confused with the
16096 outer declaration. In particular, the inner version should
16097 have a template parameter of level 2, not level 1.
16099 On the other hand, when presented with:
16101 template <class T> struct S1
16102 {
16103 template <class U> struct S2 {};
16104 template <class U> friend struct S2;
16105 };
16107 the friend must find S1::S2 eventually. We accomplish this
16108 by making sure that the new type we create to represent this
16109 declaration has the right TYPE_CONTEXT. */
16112 }
16115 {
16116 /* If no such tag is yet defined, create a forward-reference node
16117 and record it as the "definition".
16118 When a real declaration of this type is found,
16119 the forward-reference will be altered into a real type. */
16121 {
16124 }
16129 /* Mark it as a lambda type right now. Our caller will
16130 correct the value. */
16133 }
16134 else
16135 {
16137 {
16138 /* Check that we aren't trying to overload a class with different
16139 constraints. */
16143 }
16147 {
16151 }
16155 {
16158 {
16162 }
16171 {
16172 /* Push it into this TU's symbol slot. */
16175 /* We're in the template parm binding level.
16176 Pushtag has logic to slide under that, but we're
16177 not pushing a *new* type. */
16183 }
16186 }
16187 }
16190 }
16192 /* Create the binfo hierarchy for REF with (possibly NULL) base list
16193 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
16194 access_* node, and the TREE_VALUE is the type of the base-class.
16195 Non-NULL TREE_TYPE indicates virtual inheritance. */
16197 void
16199 {
16206 tree default_access;
16212 /* The base of a derived class is private by default, all others are
16213 public. */
16218 /* First, make sure that any templates in base-classes are
16219 instantiated. This ensures that if we call ourselves recursively
16220 we do not get confused about which classes are marked and which
16221 are not. */
16224 {
16227 /* The dependent_type_p call below should really be dependent_scope_p
16228 so that we give a hard error about using an incomplete type as a
16229 base, but we allow it with a pedwarn for backward
16230 compatibility. */
16236 /* An incomplete type. Remove it from the list. */
16238 else
16239 {
16240 max_bases++;
16242 max_dvbases++;
16246 }
16247 }
16252 /* The binfo slot should be empty, unless this is an (ill-formed)
16253 redefinition. */
16264 /* Apply base-class info set up to the variants of this type. */
16268 {
16270 /* A C++98 POD cannot have base classes. */
16274 {
16277 }
16278 }
16285 {
16286 /* An aggregate can't have virtual base classes. */
16294 }
16297 {
16305 /* Before C++17, an aggregate cannot have base classes. In C++17, an
16306 aggregate can't have virtual, private, or protected base classes. */
16317 {
16319 basetype);
16321 }
16325 {
16327 /* The original basetype could have been a typedef'd type. */
16330 /* Inherit flags from the base. */
16341 }
16343 /* We must do this test after we've seen through a typedef
16344 type. */
16346 {
16349 else
16352 }
16355 /* Regenerate the pack expansion for the bases. */
16369 dropped_base:
16370 /* Update max_vbases to reflect the reality that we are dropping
16371 this base: if it reaches zero we want to undo the vec_alloc
16372 above to avoid inconsistencies during error-recovery: eg, in
16373 build_special_member_call, CLASSTYPE_VBASECLASSES non null
16374 and vtt null (c++/27952). */
16376 max_vbases--;
16378 max_vbases
16380 }
16387 /* If we didn't get max_vbases vbases, we must have shared at
16388 least one of them, and are therefore diamond shaped. */
16391 /* Unmark all the types. */
16396 /* Now see if we have a repeated base type. */
16398 {
16401 {
16403 {
16406 }
16408 }
16413 else
16415 }
16416 }
16418 \f
16419 /* Copies the enum-related properties from type SRC to type DST.
16420 Used with the underlying type of an enum and the enum itself. */
16421 static void
16423 {
16424 tree t;
16426 {
16436 else
16440 }
16441 }
16443 /* Begin compiling the definition of an enumeration type.
16444 NAME is its name,
16446 if ENUMTYPE is not NULL_TREE then the type has alredy been found.
16448 UNDERLYING_TYPE is the type that will be used as the storage for
16449 the enumeration type. This should be NULL_TREE if no storage type
16450 was specified.
16452 ATTRIBUTES are any attributes specified after the enum-key.
16454 SCOPED_ENUM_P is true if this is a scoped enumeration type.
16456 if IS_NEW is not NULL, gets TRUE iff a new type is created.
16458 Returns the type object, as yet incomplete.
16459 Also records info about it so that build_enumerator
16460 may be used to declare the individual values as they are read. */
16462 tree
16465 {
16471 /* [C++0x dcl.enum]p5:
16473 If not explicitly specified, the underlying type of a scoped
16474 enumeration type is int. */
16481 /* If this is the real definition for a previous forward reference,
16482 fill in the contents in the same object that used to be the
16483 forward reference. */
16489 /* In case of a template_decl, the only check that should be deferred
16490 to instantiation time is the comparison of underlying types. */
16492 {
16494 {
16500 }
16502 {
16508 }
16512 {
16518 }
16521 {
16523 {
16529 }
16531 }
16532 }
16536 {
16537 /* In case of error, make a dummy enum to allow parsing to
16538 continue. */
16540 {
16543 }
16545 /* enumtype may be an ENUMERAL_TYPE if this is a redefinition
16546 of an opaque enum, or an opaque enum of an already defined
16547 enumeration (C++11).
16548 In any other case, it'll be NULL_TREE. */
16550 {
16553 }
16556 /* Do not push the decl more than once. */
16559 {
16563 /* std::byte aliases anything. */
16568 }
16569 else
16575 /* The enum is considered opaque until the opening '{' of the
16576 enumerator list. */
16579 }
16586 {
16588 /* We already checked that it matches, don't change it to a different
16591 {
16594 }
16597 else
16598 {
16602 }
16603 }
16605 /* If into a template class, the returned enum is always the first
16606 declaration (opaque or not) seen. This way all the references to
16607 this type will be to the same declaration. The following ones are used
16608 only to check for definition errors. */
16611 else
16613 }
16615 /* After processing and defining all the values of an enumeration type,
16616 install their decls in the enumeration type.
16617 ENUMTYPE is the type object. */
16619 void
16621 {
16622 tree values;
16623 tree underlying_type;
16624 tree decl;
16625 tree value;
16627 tree t;
16629 bool fixed_underlying_type_p
16632 /* We built up the VALUES in reverse order. */
16635 /* For an enum defined in a template, just set the type of the values;
16636 all further processing is postponed until the template is
16637 instantiated. We need to set the type so that tsubst of a CONST_DECL
16638 works. */
16640 {
16642 values;
16646 }
16648 /* Determine the minimum and maximum values of the enumerators. */
16650 {
16654 values;
16656 {
16659 /* [dcl.enum]: Following the closing brace of an enum-specifier,
16660 each enumerator has the type of its enumeration. Prior to the
16661 closing brace, the type of each enumerator is the type of its
16662 initializing value. */
16665 /* Update the minimum and maximum values, if appropriate. */
16669 /* Figure out what the minimum and maximum values of the
16670 enumerators are. */
16677 }
16678 }
16679 else
16680 /* [dcl.enum]
16682 If the enumerator-list is empty, the underlying type is as if
16683 the enumeration had a single enumerator with value 0. */
16687 {
16688 /* Compute the number of bits require to represent all values of the
16689 enumeration. We must do this before the type of MINNODE and
16690 MAXNODE are transformed, since tree_int_cst_min_precision relies
16691 on the TREE_TYPE of the value it is passed. */
16699 /* Determine the underlying type of the enumeration.
16701 [dcl.enum]
16703 The underlying type of an enumeration is an integral type that
16704 can represent all the enumerator values defined in the
16705 enumeration. It is implementation-defined which integral type is
16706 used as the underlying type for an enumeration except that the
16707 underlying type shall not be larger than int unless the value of
16708 an enumerator cannot fit in an int or unsigned int.
16710 We use "int" or an "unsigned int" as the underlying type, even if
16711 a smaller integral type would work, unless the user has
16712 explicitly requested that we use the smallest possible type. The
16713 user can request that for all enumerations with a command line
16714 flag, or for just one enumeration with an attribute. */
16716 use_short_enum = flag_short_enums
16719 /* If the precision of the type was specified with an attribute and it
16720 was too small, give an error. Otherwise, use it. */
16722 {
16725 else
16726 {
16729 }
16730 }
16734 itk++)
16735 {
16741 }
16743 {
16744 /* DR 377
16746 IF no integral type can represent all the enumerator values, the
16747 enumeration is ill-formed. */
16752 }
16754 /* [dcl.enum]
16756 The value of sizeof() applied to an enumeration type, an object
16757 of an enumeration type, or an enumerator, is the value of sizeof()
16758 applied to the underlying type. */
16761 /* Compute the minimum and maximum values for the type.
16763 [dcl.enum]
16765 For an enumeration where emin is the smallest enumerator and emax
16766 is the largest, the values of the enumeration are the values of the
16767 underlying type in the range bmin to bmax, where bmin and bmax are,
16768 respectively, the smallest and largest values of the smallest bit-
16769 field that can store emin and emax. */
16771 /* The middle-end currently assumes that types with TYPE_PRECISION
16772 narrower than their underlying type are suitably zero or sign
16773 extended to fill their mode. Similarly, it assumes that the front
16774 end assures that a value of a particular type must be within
16775 TYPE_MIN_VALUE and TYPE_MAX_VALUE.
16777 We used to set these fields based on bmin and bmax, but that led
16778 to invalid assumptions like optimizing away bounds checking. So
16779 now we just set the TYPE_PRECISION, TYPE_MIN_VALUE, and
16780 TYPE_MAX_VALUE to the values for the mode above and only restrict
16781 the ENUM_UNDERLYING_TYPE for the benefit of diagnostics. */
16785 set_min_and_max_values_for_integral_type
16788 /* If -fstrict-enums, still constrain TYPE_MIN/MAX_VALUE. */
16791 }
16792 else
16795 /* If the enum is exported, mark the consts too. */
16800 /* Convert each of the enumerators to the type of the underlying
16801 type of the enumeration. */
16803 {
16807 /* If the enumeration type has a fixed underlying type, we
16808 already checked all of the enumerator values. */
16810 else
16813 tf_warning_or_error);
16814 /* Do not clobber shared ints. */
16816 {
16820 }
16824 }
16826 /* Fix up all variant types of this enum type. */
16833 {
16835 /* TYPE_FIELDS needs fixup. */
16837 }
16839 /* Finish debugging output for this type. */
16842 /* Each enumerator now has the type of its enumeration. Clear the cache
16843 so that this change in types doesn't confuse us later on. */
16845 }
16847 /* Finishes the enum type. This is called only the first time an
16848 enumeration is seen, be it opaque or odinary.
16849 ENUMTYPE is the type object. */
16851 void
16853 {
16855 {
16859 }
16861 /* If this is a forward declaration, there should not be any variants,
16862 though we can get a variant in the middle of an enum-specifier with
16863 wacky code like 'enum E { e = sizeof(const E*) };' */
16867 }
16869 /* Build and install a CONST_DECL for an enumeration constant of the
16870 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
16871 Apply ATTRIBUTES if available. LOC is the location of NAME.
16872 Assignment of sequential values by default is handled here. */
16874 tree
16876 location_t loc)
16877 {
16878 tree decl;
16879 tree context;
16880 tree type;
16882 /* scalar_constant_value will pull out this expression, so make sure
16883 it's folded as appropriate. */
16887 /* If the VALUE was erroneous, pretend it wasn't there; that will
16888 result in the enum being assigned the next value in sequence. */
16892 /* Remove no-op casts from the value. */
16897 {
16898 /* Validate and default VALUE. */
16900 {
16902 {
16907 }
16910 value = perform_implicit_conversion_flags
16918 {
16921 {
16923 "enumerator value for %qD must have integral or "
16926 }
16927 else
16928 {
16932 {
16936 }
16937 }
16938 }
16939 }
16941 /* Default based on previous value. */
16943 {
16945 {
16946 tree prev_value;
16948 /* C++03 7.2/4: If no initializer is specified for the first
16949 enumerator, the type is an unspecified integral
16950 type. Otherwise the type is the same as the type of the
16951 initializing value of the preceding enumerator unless the
16952 incremented value is not representable in that type, in
16953 which case the type is an unspecified integral type
16954 sufficient to contain the incremented value. */
16958 else
16959 {
16966 {
16969 {
16972 {
16978 }
16985 }
16988 else
16990 }
16993 {
16996 }
16997 }
16998 }
16999 else
17001 }
17003 /* Remove no-op casts from the value. */
17006 /* If the underlying type of the enum is fixed, check whether
17007 the enumerator values fits in the underlying type. If it
17008 does not fit, the program is ill-formed [C++0x dcl.enum]. */
17010 && value
17012 {
17017 /* Convert the value to the appropriate type. */
17019 }
17020 }
17022 /* C++ associates enums with global, function, or class declarations. */
17025 /* Build the actual enumeration constant. Note that the enumeration
17026 constants have the underlying type of the enum (if it is fixed)
17027 or the type of their initializer (if the underlying type of the
17028 enum is not fixed):
17030 [ C++0x dcl.enum ]
17032 If the underlying type is fixed, the type of each enumerator
17033 prior to the closing brace is the underlying type; if the
17034 initializing value of an enumerator cannot be represented by
17035 the underlying type, the program is ill-formed. If the
17036 underlying type is not fixed, the type of each enumerator is
17037 the type of its initializing value.
17039 If the underlying type is not fixed, it will be computed by
17040 finish_enum and we will reset the type of this enumerator. Of
17041 course, if we're processing a template, there may be no value. */
17055 {
17056 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
17057 on the TYPE_FIELDS list for `S'. (That's so that you can say
17058 things like `S::i' later.) */
17060 /* The enumerator may be getting declared outside of its enclosing
17061 class, like so:
17063 class S { public: enum E : int; }; enum S::E : int { i = 7; };
17065 For which case we need to make sure that the access of `S::i'
17066 matches the access of `S::E'. */
17070 }
17071 else
17074 /* Add this enumeration constant to the list for this type. */
17078 }
17080 /* Look for an enumerator with the given NAME within the enumeration
17081 type ENUMTYPE. This routine is used primarily for qualified name
17082 lookup into an enumerator in C++0x, e.g.,
17084 enum class Color { Red, Green, Blue };
17086 Color color = Color::Red;
17088 Returns the value corresponding to the enumerator, or
17089 NULL_TREE if no such enumerator was found. */
17090 tree
17092 {
17093 tree e;
17098 }
17100 /* Implement LANG_HOOKS_SIMULATE_ENUM_DECL. */
17102 tree
17105 {
17112 {
17117 }
17131 }
17133 /* Implement LANG_HOOKS_SIMULATE_RECORD_DECL. */
17135 tree
17138 {
17145 {
17148 }
17167 }
17168 \f
17169 /* We're defining DECL. Make sure that its type is OK. */
17171 static void
17173 {
17177 /* In a function definition, arg types must be complete. */
17184 {
17189 /* Make it return void instead. */
17192 void_type_node,
17194 else
17196 fntype = (cp_build_type_attribute_variant
17200 }
17201 else
17202 {
17206 }
17207 }
17209 /* True iff FN is an implicitly-defined default constructor. */
17211 static bool
17213 {
17217 }
17219 /* Clobber the contents of *this to let the back end know that the object
17220 storage is dead when we enter the constructor or leave the destructor. */
17222 static tree
17224 {
17225 /* Clobbering an empty base is pointless, and harmful if its one byte
17226 TYPE_SIZE overlays real data. */
17230 /* If we have virtual bases, clobber the whole object, but only if we're in
17231 charge. If we don't have virtual bases, clobber the as-base type so we
17232 don't mess with tail padding. */
17243 {
17246 }
17253 }
17255 /* Create the FUNCTION_DECL for a function definition.
17256 DECLSPECS and DECLARATOR are the parts of the declaration;
17257 they describe the function's name and the type it returns,
17258 but twisted together in a fashion that parallels the syntax of C.
17260 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
17261 DECLARATOR is really the DECL for the function we are about to
17262 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
17263 indicating that the function is an inline defined in-class.
17265 This function creates a binding context for the function body
17266 as well as setting up the FUNCTION_DECL in current_function_decl.
17268 For C++, we must first check whether that datum makes any sense.
17269 For example, "class A local_a(1,2);" means that variable local_a
17270 is an aggregate of type A, which should have a constructor
17271 applied to it with the argument list [1, 2].
17273 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
17274 or may be a BLOCK if the function has been defined previously
17275 in this translation unit. On exit, DECL_INITIAL (decl1) will be
17276 error_mark_node if the function has never been defined, or
17277 a BLOCK if the function has been defined somewhere. */
17279 bool
17281 {
17285 /* Sanity check. */
17292 else
17293 {
17298 }
17305 /* Handle gnu_inline attribute. */
17307 {
17312 }
17315 /* This is a constructor, we must ensure that any default args
17316 introduced by this definition are propagated to the clones
17317 now. The clones are used directly in overload resolution. */
17320 /* Sometimes we don't notice that a function is a static member, and
17321 build a METHOD_TYPE for it. Fix that up now. */
17325 /* Set up current_class_type, and enter the scope of the class, if
17326 appropriate. */
17332 /* Now that we have entered the scope of the class, we must restore
17333 the bindings for any template parameters surrounding DECL1, if it
17334 is an inline member template. (Order is important; consider the
17335 case where a template parameter has the same name as a field of
17336 the class.) It is not until after this point that
17337 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
17341 /* Effective C++ rule 15. */
17349 /* Make the init_value nonzero so pushdecl knows this is not tentative.
17350 error_mark_node is replaced below (in poplevel) with the BLOCK. */
17354 /* This function exists in static storage.
17355 (This does not mean `static' in the C sense!) */
17358 /* We must call push_template_decl after current_class_type is set
17359 up. (If we are processing inline definitions after exiting a
17360 class scope, current_class_type will be NULL_TREE until set above
17361 by push_nested_class.) */
17363 {
17366 {
17370 }
17372 }
17374 /* Make sure the parameter and return types are reasonable. When
17375 you declare a function, these types can be incomplete, but they
17376 must be complete when you define the function. */
17379 /* Build the return declaration for the function. */
17383 {
17384 /* In a template instantiation, copy the return type location. When
17385 parsing, the location will be set in grokdeclarator. */
17388 {
17392 }
17400 }
17402 /* Record the decl so that the function name is defined.
17403 If we already have a decl for this name, and it is a FUNCTION_DECL,
17404 use the old decl. */
17406 {
17407 /* A specialization is not used to guide overload resolution. */
17411 {
17415 /* If something went wrong when registering the declaration,
17416 use DECL1; we have to have a FUNCTION_DECL to use when
17417 parsing the body of the function. */
17418 ;
17419 else
17420 {
17421 /* Otherwise, OLDDECL is either a previous declaration
17422 of the same function or DECL1 itself. */
17429 {
17430 tree context;
17432 /* Check whether DECL1 is in an anonymous
17433 namespace. */
17435 context;
17437 {
17441 }
17445 OPT_Wmissing_declarations,
17447 }
17450 }
17451 }
17452 else
17453 {
17454 /* We need to set the DECL_CONTEXT. */
17457 }
17461 /* If #pragma weak applies, mark the decl appropriately now.
17462 The pragma only applies to global functions. Because
17463 determining whether or not the #pragma applies involves
17464 computing the mangled name for the declaration, we cannot
17465 apply the pragma until after we have merged this declaration
17466 with any previous declarations; if the original declaration
17467 has a linkage specification, that specification applies to
17468 the definition as well, and may affect the mangled name. */
17471 }
17473 /* We are now in the scope of the function being defined. */
17476 /* Save the parm names or decls from this function's declarator
17477 where store_parm_decls will find them. */
17480 /* Let the user know we're compiling this function. */
17485 /* This function may already have been parsed, in which case just
17486 return; our caller will skip over the body without parsing. */
17490 /* Initialize RTL machinery. We cannot do this until
17491 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
17492 even when processing a template; this is how we get
17493 CFUN set up, and our per-function variables initialized.
17494 FIXME factor out the non-RTL stuff. */
17498 /* Initialize the language data structures. Whenever we start
17499 a new function, we destroy temporaries in the usual way. */
17504 /* If we are (erroneously) defining a function that we have already
17505 defined before, wipe out what we knew before. */
17511 {
17514 }
17516 /* Start the statement-tree, start the tree now. */
17520 {
17521 /* We know that this was set up by `grokclassfn'. We do not
17522 wait until `store_parm_decls', since evil parse errors may
17523 never get us to that point. Here we keep the consistency
17524 between `current_class_type' and `current_class_ptr'. */
17530 cp_function_chain->x_current_class_ref
17532 /* Set this second to avoid shortcut in cp_build_indirect_ref. */
17535 /* Constructors and destructors need to know whether they're "in
17536 charge" of initializing virtual base classes. */
17539 {
17542 }
17544 {
17547 }
17548 }
17551 /* Implicitly-defined methods (like the
17552 destructor for a class in which no destructor
17553 is explicitly declared) must not be defined
17554 until their definition is needed. So, we
17555 ignore interface specifications for
17556 compiler-generated functions. */
17564 {
17571 /* This is a function in a local class in an extern inline
17572 or template function. */
17574 }
17575 /* If this function belongs to an interface, it is public.
17576 If it belongs to someone else's interface, it is also external.
17577 This only affects inlines and template instantiations. */
17579 {
17582 {
17586 && ! flag_implement_inlines
17589 /* For WIN32 we also want to put these in linkonce sections. */
17591 }
17592 else
17595 /* If this function is in an interface implemented in this file,
17596 make sure that the back end knows to emit this function
17597 here. */
17600 }
17603 {
17604 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
17605 interface, we will have both finfo->interface_unknown and
17606 finfo->interface_only set. In that case, we don't want to
17607 use the normal heuristics because someone will supply a
17608 #pragma implementation elsewhere, and deducing it here would
17609 produce a conflict. */
17614 }
17615 else
17616 {
17617 /* This is a definition, not a reference.
17618 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
17626 else
17628 }
17630 /* Determine the ELF visibility attribute for the function. We must not
17631 do this before calling "pushdecl", as we must allow "duplicate_decls"
17632 to merge any attributes appropriately. We also need to wait until
17633 linkage is set. */
17654 /* Clobbering an empty base is harmful if it overlays real data. */
17656 /* We can't clobber safely for an implicitly-defined default constructor
17657 because part of the initialization might happen before we enter the
17658 constructor, via AGGR_INIT_ZERO_FIRST (c++/68006). */
17673 }
17676 /* Like start_preparsed_function, except that instead of a
17677 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
17679 Returns true on success. If the DECLARATOR is not suitable
17680 for a function, we return false, which tells the parser to
17681 skip the entire function. */
17683 bool
17686 tree attrs)
17687 {
17688 tree decl1;
17696 /* main must return int. grokfndecl should have corrected it
17697 (and issued a diagnostic) if the user got it wrong. */
17699 integer_type_node));
17702 }
17703 \f
17704 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
17705 FN. */
17707 static bool
17709 {
17711 && !processing_template_decl
17712 /* We insert the EH_SPEC_BLOCK only in the original
17713 function; then, it is copied automatically to the
17714 clones. */
17716 /* Implicitly-generated constructors and destructors have
17717 exception specifications. However, those specifications
17718 are the union of the possible exceptions specified by the
17719 constructors/destructors for bases and members, so no
17720 unallowed exception will ever reach this function. By
17721 not creating the EH_SPEC_BLOCK we save a little memory,
17722 and we avoid spurious warnings about unreachable
17723 code. */
17726 }
17728 /* Helper function to push ARGS into the current lexical scope. DECL
17729 is the function declaration. NONPARMS is used to handle enum
17730 constants. */
17732 void
17734 {
17735 /* If we're doing semantic analysis, then we'll call pushdecl
17736 for each of these. We must do them in reverse order so that
17737 they end in the correct forward order. */
17740 tree next;
17742 {
17747 {
17748 /* If we find an enum constant or a type tag, put it aside for
17749 the moment. */
17752 }
17753 }
17755 /* Get the decls in their original chain order and record in the
17756 function. This is all and only the PARM_DECLs that were
17757 pushed into scope by the loop above. */
17759 }
17761 /* Store the parameter declarations into the current function declaration.
17762 This is called after parsing the parameter declarations, before
17763 digesting the body of the function.
17765 Also install to binding contour return value identifier, if any. */
17767 static void
17769 {
17772 /* This is a chain of any other decls that came in among the parm
17773 declarations. If a parm is declared with enum {foo, bar} x;
17774 then CONST_DECLs for foo and bar are put here. */
17778 {
17779 /* This case is when the function was defined with an ANSI prototype.
17780 The parms already have decls, so we need not do anything here
17781 except record them as in effect
17782 and complain if any redundant old-style parm decls were written. */
17786 /* Must clear this because it might contain TYPE_DECLs declared
17787 at class level. */
17791 }
17792 else
17795 /* Now store the final chain of decls for the arguments
17796 as the decl-chain of the current lexical scope.
17797 Put the enumerators in as well, at the front so that
17798 DECL_ARGUMENTS is not modified. */
17803 }
17805 \f
17806 /* Set the return value of the [cd]tor if the ABI wants that. */
17808 void
17810 {
17812 {
17813 /* Return the address of the object. */
17821 }
17822 }
17824 /* Do all the processing for the beginning of a destructor; set up the
17825 vtable pointers and cleanups for bases and members. */
17827 static void
17829 {
17830 tree compound_stmt;
17832 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
17833 issued an error message. We still want to try to process the
17834 body of the function, but initialize_vtbl_ptrs will crash if
17835 TYPE_BINFO is NULL. */
17837 {
17839 /* Make all virtual function table pointers in non-virtual base
17840 classes point to CURRENT_CLASS_TYPE's virtual function
17841 tables. */
17846 /* Clobbering an empty base is harmful if it overlays real data. */
17848 {
17852 {
17854 tree ref
17861 tf_warning_or_error);
17862 /* If the vptr is shared with some virtual nearly empty base,
17863 don't clear it if not in charge, the dtor of the virtual
17864 nearly empty base will do that later. */
17866 {
17869 {
17871 {
17873 tf_warning_or_error);
17876 }
17878 }
17879 }
17881 }
17882 else
17884 }
17886 /* And insert cleanups for our bases and members so that they
17887 will be properly destroyed if we throw. */
17889 }
17890 }
17892 /* Do the necessary processing for the beginning of a function body, which
17893 in this case includes member-initializers, but not the catch clauses of
17894 a function-try-block. Currently, this means opening a binding level
17895 for the member-initializers (in a ctor), member cleanups (in a dtor),
17896 and capture proxies (in a lambda operator()). */
17898 tree
17900 {
17906 else
17907 /* Always keep the BLOCK node associated with the outermost pair of
17908 curly braces of a function. These are needed for correct
17909 operation of dwarfout.c. */
17920 }
17922 /* Do the processing for the end of a function body. Currently, this means
17923 closing out the cleanups for fully-constructed bases and members, and in
17924 the case of the destructor, deleting the object if desired. Again, this
17925 is only meaningful for [cd]tors, since they are the only functions where
17926 there is a significant distinction between the main body and any
17927 function catch clauses. Handling, say, main() return semantics here
17928 would be wrong, as flowing off the end of a function catch clause for
17929 main() would also need to return 0. */
17931 void
17933 {
17937 /* Close the block. */
17945 }
17947 /* Given a function, returns the BLOCK corresponding to the outermost level
17948 of curly braces, skipping the artificial block created for constructor
17949 initializers. */
17951 tree
17953 {
17963 }
17965 /* If FNDECL is a class's key method, add the class to the list of
17966 keyed classes that should be emitted. */
17968 static void
17970 {
17974 {
17978 }
17979 }
17981 /* Attempt to add a fix-it hint to RICHLOC suggesting the insertion
17982 of "return *this;" immediately before its location, using FNDECL's
17983 first statement (if any) to give the indentation, if appropriate. */
17985 static void
17987 {
17994 indent);
17995 }
17997 /* This function carries out the subset of finish_function operations needed
17998 to emit the compiler-generated outlined helper functions used by the
17999 coroutines implementation. */
18001 static void
18003 {
18004 /* This is a partial set of the operations done by finish_function()
18005 plus emitting the result. */
18015 /* We must start each function with a clear fold cache. */
18020 /* This function has coroutine IFNs that we should handle in middle
18021 end lowering. */
18025 }
18027 /* Finish up a function declaration and compile that function
18028 all the way to assembler language output. The free the storage
18029 for the function definition. INLINE_P is TRUE if we just
18030 finished processing the body of an in-class inline function
18031 definition. (This processing will have taken place after the
18032 class definition is complete.) */
18034 tree
18036 {
18041 && !processing_template_decl
18045 /* When we get some parse errors, we can end up without a
18046 current_function_decl, so cope. */
18060 /* TREE_READONLY (fndecl) = 1;
18061 This caused &foo to be of type ptr-to-const-function
18062 which then got a warning when stored in a ptr-to-function variable. */
18065 /* The current function is being defined, so its DECL_INITIAL should
18066 be set, and unless there's a multiple definition, it should be
18067 error_mark_node. */
18071 {
18072 /* Only try to emit the coroutine outlined helper functions if the
18073 transforms succeeded. Otherwise, treat errors in the same way as
18074 a regular function. */
18077 /* We should handle coroutine IFNs in middle end lowering. */
18080 /* Do not try to process the ramp's EH unless outlining succeeded. */
18084 current_eh_spec_block);
18085 }
18086 else
18087 /* For a cloned function, we've already got all the code we need;
18088 there's no need to add any extra bits. */
18090 {
18091 /* Make it so that `main' always returns 0 by default. */
18099 current_eh_spec_block);
18100 }
18102 /* If we're saving up tree structure, tie off the function now. */
18107 /* This must come after expand_function_end because cleanups might
18108 have declarations (from inline functions) that need to go into
18109 this function's blocks. */
18111 /* If the current binding level isn't the outermost binding level
18112 for this function, either there is a bug, or we have experienced
18113 syntax errors and the statement tree is malformed. */
18115 {
18116 /* Make sure we have already experienced errors. */
18119 /* Throw away the broken statement tree and extra binding
18120 levels. */
18124 {
18127 else
18129 }
18130 }
18133 /* Statements should always be full-expressions at the outermost set
18134 of curly braces for a function. */
18137 /* If there are no return statements in a function with auto return type,
18138 the return type is void. But if the declared type is something like
18139 auto*, this is an error. */
18142 {
18144 && !current_function_returns_value
18146 {
18147 /* We haven't applied return type deduction because we haven't
18148 seen any return statements. Do that now. */
18152 adc_return_type);
18156 }
18159 {
18164 }
18165 }
18167 /* Remember that we were in class scope. */
18172 {
18176 }
18178 // If this is a concept, check that the definition is reasonable.
18187 /* Complain if there's just no return statement. */
18194 /* Don't complain if we abort or throw. */
18195 && !current_function_returns_abnormally
18196 /* Don't complain if there's an infinite loop. */
18197 && !current_function_infinite_loop
18198 /* Don't complain if we are declared noreturn. */
18202 /* Structor return values (if any) are set by the compiler. */
18206 {
18208 /* Potentially add a "return *this;" fix-it hint for
18209 assignment operators. */
18211 {
18214 && current_class_ref
18215 && same_type_ignoring_top_level_qualifiers_p
18221 }
18227 "no return statement in function returning "
18230 }
18232 /* Lambda closure members are implicitly constexpr if possible. */
18236 = ((processing_template_decl
18240 /* Save constexpr function body before it gets munged by
18241 the NRV transformation. */
18244 /* Invoke the pre-genericize plugin before we start munging things. */
18248 /* Perform delayed folding before NRV transformation. */
18254 /* Set up the named return value optimization, if we can. Candidate
18255 variables are selected in check_return_expr. */
18257 {
18261 }
18263 /* Must mark the RESULT_DECL as being in this function. */
18266 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
18267 to the FUNCTION_DECL node itself. */
18270 /* Store the end of the function, so that we get good line number
18271 info for the epilogue. */
18274 /* Complain about parameters that are only set, but never otherwise used. */
18276 && !processing_template_decl
18279 {
18280 tree decl;
18283 decl;
18297 OPT_Wunused_but_set_parameter,
18300 }
18302 /* Complain about locally defined typedefs that are not used in this
18303 function. */
18306 /* Possibly warn about unused parameters. */
18308 && !processing_template_decl
18312 /* Genericize before inlining. */
18318 /* If this function can't throw any exceptions, remember that. */
18321 && !flag_non_call_exceptions
18326 /* Emit the resumer and destroyer functions now, providing that we have
18327 not encountered some fatal error. */
18329 {
18332 }
18334 cleanup:
18335 /* We're leaving the context of this function, so zap cfun. It's still in
18336 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
18340 /* If this is an in-class inline definition, we may have to pop the
18341 bindings for the template parameters that we added in
18342 maybe_begin_member_template_processing when start_function was
18343 called. */
18347 /* Leave the scope of the class. */
18353 /* Clean up. */
18361 }
18362 \f
18363 /* Create the FUNCTION_DECL for a function definition.
18364 DECLSPECS and DECLARATOR are the parts of the declaration;
18365 they describe the return type and the name of the function,
18366 but twisted together in a fashion that parallels the syntax of C.
18368 This function creates a binding context for the function body
18369 as well as setting up the FUNCTION_DECL in current_function_decl.
18371 Returns a FUNCTION_DECL on success.
18373 If the DECLARATOR is not suitable for a function (it defines a datum
18374 instead), we return 0, which tells yyparse to report a parse error.
18376 May return void_type_node indicating that this method is actually
18377 a friend. See grokfield for more details.
18379 Came here with a `.pushlevel' .
18381 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
18382 CHANGES TO CODE IN `grokfield'. */
18384 tree
18387 {
18397 /* Pass friends other than inline friend functions back. */
18402 {
18407 }
18411 /* p1779 ABI-Isolation makes inline not a default for in-class
18412 definitions in named module purview. If the user explicitly
18413 made it inline, grokdeclarator will already have done the right
18414 things. */
18416 || flag_module_implicit_inline
18417 /* Lambda's operator function remains inline. */
18419 /* If the user explicitly asked for this to be inline, we don't
18420 need to do more, but more importantly we want to warn if we
18421 can't inline it. */
18423 {
18427 /* It's ok if we can't inline this. */
18429 }
18431 /* We process method specializations in finish_struct_1. */
18433 {
18434 /* Avoid calling decl_spec_seq... until we have to. */
18439 }
18442 {
18445 }
18451 }
18452 \f
18454 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
18455 we can lay it out later, when and if its type becomes complete.
18457 Also handle constexpr variables where the initializer involves
18458 an unlowered PTRMEM_CST because the class isn't complete yet. */
18460 void
18462 {
18465 /* Keep track of variables with incomplete types. */
18468 {
18476 /* RTTI TD entries are created while defining the type_info. */
18479 {
18482 }
18486 {
18487 /* When the outermost open class is complete we can resolve any
18488 pointers-to-members. */
18492 }
18493 }
18494 }
18496 /* Called when a class type (given by TYPE) is defined. If there are
18497 any existing VAR_DECLs whose type has been completed by this
18498 declaration, update them now. */
18500 void
18502 {
18507 {
18509 {
18516 {
18517 /* Complete the type of the variable. */
18522 }
18524 /* Remove this entry from the list. */
18526 }
18527 else
18528 ix++;
18529 }
18530 }
18532 /* If DECL is of a type which needs a cleanup, build and return an
18533 expression to perform that cleanup here. Return NULL_TREE if no
18534 cleanup need be done. DECL can also be a _REF when called from
18535 split_nonconstant_init_1. */
18537 tree
18539 {
18540 tree type;
18541 tree attr;
18542 tree cleanup;
18544 /* Assume no cleanup is required. */
18550 /* Handle "__attribute__((cleanup))". We run the cleanup function
18551 before the destructor since the destructor is what actually
18552 terminates the lifetime of the object. */
18555 else
18558 {
18559 tree id;
18560 tree fn;
18561 tree arg;
18563 /* Get the name specified by the user for the cleanup function. */
18565 /* Look up the name to find the cleanup function to call. It is
18566 important to use lookup_name here because that is what is
18567 used in c-common.cc:handle_cleanup_attribute when performing
18568 initial checks on the attribute. Note that those checks
18569 include ensuring that the function found is not an overloaded
18570 function, or an object with an overloaded call operator,
18571 etc.; we can rely on the fact that the function found is an
18572 ordinary FUNCTION_DECL. */
18580 }
18581 /* Handle ordinary C++ destructors. */
18584 {
18586 tree addr;
18587 tree call;
18591 else
18605 else
18607 }
18609 /* build_delete sets the location of the destructor call to the
18610 current location, even though the destructor is going to be
18611 called later, at the end of the current scope. This can lead to
18612 a "jumpy" behavior for users of debuggers when they step around
18613 the end of the block. So let's unset the location of the
18614 destructor call instead. */
18622 /* Treat objects with destructors as used; the destructor may do
18623 something substantive. */
18632 }
18634 \f
18635 /* Return the FUNCTION_TYPE that corresponds to MEMFNTYPE, which can be a
18636 FUNCTION_DECL, METHOD_TYPE, FUNCTION_TYPE, pointer or reference to
18637 METHOD_TYPE or FUNCTION_TYPE, or pointer to member function. */
18639 tree
18641 {
18642 tree fntype;
18643 tree args;
18656 fntype = (cp_build_type_attribute_variant
18660 }
18662 /* DECL was originally constructed as a non-static member function,
18663 but turned out to be static. Update it accordingly. */
18665 void
18667 {
18680 }
18682 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
18683 one of the language-independent trees. */
18685 enum cp_tree_node_structure_enum
18687 {
18689 {
18707 }
18708 }
18710 bool
18712 {
18713 /* A missing noreturn is ok for the `main' function. */
18715 }
18717 /* Return the decl used to identify the COMDAT group into which DECL should
18718 be placed. */
18720 tree
18722 {
18723 /* Virtual tables, construction virtual tables, and virtual table
18724 tables all go in a single COMDAT group, named after the primary
18725 virtual table. */
18728 /* For all other DECLs, the COMDAT group is the mangled name of the
18729 declaration itself. */
18730 else
18731 {
18733 {
18734 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
18735 into the same section as the target function. In that case
18736 we must return target's name. */
18742 else
18744 }
18745 }
18748 }
18750 /* Returns the return type for FN as written by the user, which may include
18751 a placeholder for a deduced return type. */
18753 tree
18755 {
18761 }
18763 /* Returns true iff DECL is a variable or function declared with an auto type
18764 that has not yet been deduced to a real type. */
18766 bool
18768 {
18775 }
18777 /* Complain if DECL has an undeduced return type. */
18779 bool
18781 {
18783 {
18787 {
18788 /* Set the return type of __builtin_source_location. */
18791 {
18794 }
18799 }
18807 }
18809 }
18811 /* Create a representation of the explicit-specifier with
18812 constant-expression of EXPR. COMPLAIN is as for tsubst. */
18814 tree
18816 {
18821 /* Wait for instantiation, tsubst_function_decl will handle it. */
18828 }