| blob | b10a72a87bf0a1cabab52c1e4b657bc8a379b91e |
1 /* Process declarations and variables for -*- C++ -*- compiler.
2 Copyright (C) 1988-2024 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
10 any later version.
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
22 /* Process declarations and symbol lookup for C++ front end.
23 Also constructs types; the standard scalar types at initialization,
24 and structure, union, array and enum types when they are declared. */
26 /* ??? not all decl nodes are given the most useful possible
27 line numbers. For example, the CONST_DECLs for enum values. */
30 #define INCLUDE_MEMORY
64 /* Possible cases of bad specifiers type used by bad_specifiers. */
69 BSP_FIELD /* field */
70 };
100 static tree check_special_function_return_type
111 /* The following symbols are subsumed in the cp_global_trees array, and
112 listed here individually for documentation purposes.
114 C++ extensions
115 tree wchar_decl_node;
117 tree vtable_entry_type;
118 tree delta_type_node;
119 tree __t_desc_type_node;
121 tree class_type_node;
122 tree unknown_type_node;
124 Array type `vtable_entry_type[]'
126 tree vtbl_type_node;
127 tree vtbl_ptr_type_node;
129 Namespaces,
131 tree std_node;
132 tree abi_node;
134 A FUNCTION_DECL which can call `abort'. Not necessarily the
135 one that the user will declare, but sufficient to be called
136 by routines that want to abort the program.
138 tree abort_fndecl;
140 Used by RTTI
141 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
142 tree tinfo_var_id; */
146 /* A list of objects which have constructors or destructors
147 which reside in namespace scope. The decl is stored in
148 the TREE_VALUE slot and the initializer is stored
149 in the TREE_PURPOSE slot. */
150 tree static_aggregates;
152 /* Like static_aggregates, but for thread_local variables. */
153 tree tls_aggregates;
155 /* A hash-map mapping from variable decls to the dynamic initializer for
156 the decl. This is currently only used by OpenMP. */
159 /* -- end of C++ */
161 /* A node for the integer constant 2. */
163 tree integer_two_node;
165 /* vector of static decls. */
168 /* vector of keyed classes. */
171 /* Used only for jumps to as-yet undefined labels, since jumps to
172 defined labels can have their validity checked immediately. */
176 /* The binding level to which this entry is *currently* attached.
177 This is initially the binding level in which the goto appeared,
178 but is modified as scopes are closed. */
180 /* The head of the names list that was current when the goto appeared,
181 or the inner scope popped. These are the decls that will *not* be
182 skipped when jumping to the label. */
183 tree names_in_scope;
184 /* If the use is a possible destination of a computed goto, a vec of decls
185 that aren't destroyed, filled in by poplevel_named_label_1. */
187 /* The location of the goto, for error reporting. */
188 location_t o_goto_locus;
189 /* True if an OpenMP structured block scope has been closed since
190 the goto appeared. This means that the branch from the label will
191 illegally exit an OpenMP scope. */
193 };
195 /* A list of all LABEL_DECLs in the function that have names. Here so
196 we can clear out their names' definitions at the end of the
197 function, and so we can check the validity of jumps to these labels. */
207 /* The binding level to which the label is *currently* attached.
208 This is initially set to the binding level in which the label
209 is defined, but is modified as scopes are closed. */
212 /* The head of the names list that was current when the label was
213 defined, or the inner scope popped. These are the decls that will
214 be skipped when jumping to the label. */
215 tree names_in_scope;
217 /* A vector of all decls from all binding levels that would be
218 crossed by a backward branch to the label. */
221 /* A list of uses of the label, before the label is defined. */
224 /* True if we've seen &&label. Appalently we can't use TREE_ADDRESSABLE for
225 this, it has a more specific meaning for LABEL_DECL. */
228 /* The following bits are set after the label is defined, and are
229 updated as scopes are popped. They indicate that a jump to the
230 label will illegally enter a scope of the given flavor. */
238 };
240 #define named_labels cp_function_chain->x_named_labels
241 \f
242 /* The number of function bodies which we are currently processing.
243 (Zero if we are at namespace scope, one inside the body of a
244 function, two inside the body of a function in a local class, etc.) */
247 /* Whether the exception-specifier is part of a function type (i.e. C++17). */
250 /* States indicating how grokdeclarator() should handle declspecs marked
251 with __attribute__((deprecated)). An object declared as
252 __attribute__((deprecated)) suppresses warnings of uses of other
253 deprecated items. */
256 \f
257 /* A list of VAR_DECLs whose type was incomplete at the time the
258 variable was declared. */
261 tree decl;
262 tree incomplete_type;
263 };
267 \f
268 /* Returns the kind of template specialization we are currently
269 processing, given that it's declaration contained N_CLASS_SCOPES
270 explicit scope qualifications. */
272 tmpl_spec_kind
274 {
280 /* Scan through the template parameter scopes. */
284 {
285 /* If we see a specialization scope inside a parameter scope,
286 then something is wrong. That corresponds to a declaration
287 like:
289 template <class T> template <> ...
291 which is always invalid since [temp.expl.spec] forbids the
292 specialization of a class member template if the enclosing
293 class templates are not explicitly specialized as well. */
295 {
298 else
300 }
305 }
307 /* Handle explicit instantiations. */
309 {
311 /* We've seen a template parameter list during an explicit
312 instantiation. For example:
314 template <class T> template void f(int);
316 This is erroneous. */
318 else
320 }
323 /* We've not seen enough template headers to match all the
324 specialized classes present. For example:
326 template <class T> void R<T>::S<T>::f(int);
328 This is invalid; there needs to be one set of template
329 parameters for each class. */
332 /* We're processing a non-template declaration (even though it may
333 be a member of a template class.) For example:
335 template <class T> void S<T>::f(int);
337 The `class T' matches the `S<T>', leaving no template headers
338 corresponding to the `f'. */
341 /* We've got too many template headers. For example:
343 template <> template <class T> void f (T);
345 There need to be more enclosing classes. */
347 else
348 /* This must be a template. It's of the form:
350 template <class T> template <class U> void S<T>::f(U);
352 This is a specialization if the innermost level was a
353 specialization; otherwise it's just a definition of the
354 template. */
356 }
358 /* Exit the current scope. */
360 void
362 {
364 }
366 /* When a label goes out of scope, check to see if that label was used
367 in a valid manner, and issue any appropriate warnings or errors. */
369 static void
371 {
373 {
375 {
376 location_t location;
380 /* FIXME want (LOCATION_FILE (input_location), (line)0) */
381 /* Avoid crashing later. */
383 }
384 else
386 }
387 }
389 /* Helper function to sort named label entries in a vector by DECL_UID. */
391 static int
393 {
397 /* DECL_UIDs can never be equal. */
399 }
401 /* At the end of a function, all labels declared within the function
402 go out of scope. BLOCK is the top-level block for the
403 function. */
405 static void
407 {
411 /* We need to add the labels to the block chain, so debug
412 information is emitted. But, we want the order to be stable so
413 need to sort them first. Otherwise the debug output could be
414 randomly ordered. I guess it's mostly stable, unless the hash
415 table implementation changes. */
420 {
427 }
432 {
439 }
440 }
442 /* At the end of a block with local labels, restore the outer definition. */
444 static void
446 {
454 else
455 {
458 }
460 }
462 /* The following two routines are used to interface to Objective-C++.
463 The binding level is purposely treated as an opaque type. */
467 {
469 }
471 /* The following routine is used by the NeXT-style SJLJ exceptions;
472 variables get marked 'volatile' so as to not be clobbered by
473 _setjmp()/_longjmp() calls. All variables in the current scope,
474 as well as parent scopes up to (but not including) ENCLOSING_BLK
475 shall be thusly marked. */
477 void
479 {
485 {
486 tree decl;
491 /* Do not climb up past the current function. */
494 }
495 }
497 /* True if B is the level for the condition of a constexpr if. */
499 static bool
501 {
505 }
507 /* True if B is the level for the condition of a consteval if. */
509 static bool
511 {
515 }
517 /* Update data for defined and undefined labels when leaving a scope. */
519 int
521 {
526 {
527 tree decl;
529 /* ENT->NAMES_IN_SCOPE may contain a mixture of DECLs and
530 TREE_LISTs representing OVERLOADs, so be careful. */
540 {
564 }
565 }
567 {
572 {
574 {
581 }
587 }
588 }
591 }
593 /* Saved errorcount to avoid -Wunused-but-set-{parameter,variable} warnings
594 when errors were reported, except for -Werror-unused-but-set-*. */
597 /* Exit a binding level.
598 Pop the level off, and restore the state of the identifier-decl mappings
599 that were in effect when this level was entered.
601 If KEEP == 1, this level had explicit declarations, so
602 and create a "block" (a BLOCK node) for the level
603 to record its declarations and subblocks for symbol table output.
605 If FUNCTIONBODY is nonzero, this level is the body of a function,
606 so create a block as if KEEP were set and also clear out all
607 label names.
609 If REVERSE is nonzero, reverse the order of decls before putting
610 them into the BLOCK. */
612 tree
614 {
615 tree link;
616 /* The chain of decls was accumulated in reverse order.
617 Put it into forward order, just for cleanliness. */
618 tree decls;
619 tree subblocks;
620 tree block;
621 tree decl;
622 scope_kind kind;
625 restart:
638 /* We used to use KEEP == 2 to indicate that the new block should go
639 at the beginning of the list of blocks at this binding level,
640 rather than the end. This hack is no longer used. */
646 /* Any uses of undefined labels, and any defined labels, now operate
647 under constraints of next binding contour. */
652 /* Get the decls in the order they were written.
653 Usually current_binding_level->names is in reverse order.
654 But parameter decls were previously put in forward order. */
658 {
661 }
663 /* If there were any declarations or structure tags in that level,
664 or if this level is a function body,
665 create a BLOCK to record them for the life of this function. */
667 /* Avoid function body block if possible. */
673 {
676 }
678 /* In each subblock, record that this is its superior. */
683 /* Before we remove the declarations first check for unused variables. */
688 {
689 /* There are cases where D itself is a TREE_LIST. See in
690 push_local_binding where the list of decls returned by
691 getdecls is built. */
698 /* For structured bindings, consider only real variables, not
699 subobjects. */
702 /* Don't warn about name-independent declarations. */
709 {
711 {
714 OPT_Wunused_variable,
716 else
720 }
722 // For -Wunused-but-set-variable leave references alone.
725 {
730 else
732 OPT_Wunused_but_set_variable,
735 }
736 }
737 }
739 /* Remove declarations for all the DECLs in this level. */
741 {
742 tree name;
744 {
748 }
749 else
750 {
753 }
755 /* Remove the binding. */
758 else
760 }
762 /* Restore the IDENTIFIER_TYPE_VALUEs. */
767 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
768 list if a `using' declaration put them there. The debugging
769 back ends won't understand OVERLOAD, so we remove them here.
770 Because the BLOCK_VARS are (temporarily) shared with
771 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
772 popped all the bindings. Also remove undeduced 'auto' decls,
773 which LTO doesn't understand, and can't have been used by anything. */
775 {
779 {
781 || (!processing_template_decl
784 else
786 }
787 }
789 /* If the level being exited is the top level of a function,
790 check over all the labels. */
792 {
794 {
795 /* Since this is the top level block of a function, the vars are
796 the function's parameters. Don't leave them in the BLOCK
797 because they are found in the FUNCTION_DECL instead. */
800 }
801 else
803 }
807 {
808 tree stmt;
810 /* If this is a temporary binding created for a cleanup, then we'll
811 have pushed a statement list level. Pop that, create a new
812 BIND_EXPR for the block, and insert it into the stream. */
816 }
820 {
821 /* The current function is being defined, so its DECL_INITIAL
822 should be error_mark_node. */
826 {
828 {
831 }
832 else
834 }
835 }
837 current_binding_level->blocks
840 /* If we did not make a block for the level just exited,
841 any blocks made for inner levels
842 (since they cannot be recorded as subblocks in that level)
843 must be carried forward so they will later become subblocks
844 of something else. */
846 current_binding_level->blocks
849 /* Each and every BLOCK node created here in `poplevel' is important
850 (e.g. for proper debugging information) so if we created one
851 earlier, mark it as "used". */
855 /* All temporary bindings created for cleanups are popped silently. */
860 }
862 /* Call wrapup_globals_declarations for the globals in NAMESPACE. */
863 /* Diagnose odr-used extern inline variables without definitions
864 in the current TU. */
866 int
868 {
870 {
872 {
882 OPT_Wunused_function,
891 }
893 /* Clear out the list, so we don't rescan next time. */
896 /* Write out any globals that need to be output. */
899 }
901 }
902 \f
903 /* In C++, you don't have to write `struct S' to refer to `S'; you
904 can just use `S'. We accomplish this by creating a TYPE_DECL as
905 if the user had written `typedef struct S S'. Create and return
906 the TYPE_DECL for TYPE. */
908 tree
910 {
911 tree decl;
915 /* There are other implicit type declarations, like the one *within*
916 a class that allows you to write `S::S'. We must distinguish
917 amongst these. */
923 }
925 /* Function-scope local entities that need discriminators. Each entry
926 is a {decl,name} pair. VAR_DECLs for anon unions get their name
927 smashed, so we cannot rely on DECL_NAME. */
931 /* Determine the mangling discriminator of local DECL. There are
932 generally very few of these in any particular function. */
934 void
936 {
946 {
954 {
960 /* Replace the saved decl. */
964 }
965 }
968 {
972 }
973 }
975 \f
976 /* True if DECL is a constrained hidden friend as per [temp.friend]/9:
978 A non-template friend declaration with a requires-clause shall be a
979 definition. A friend function template with a constraint that depends on a
980 template parameter from an enclosing template shall be a definition. Such a
981 constrained friend function or function template declaration does not
982 declare the same function or function template as a declaration in any other
983 scope.
985 The ABI calls this a "member-like constrained friend" and mangles it like a
986 member function to avoid collisions. */
988 bool
990 {
997 || (uses_outer_template_parms_in_constraints
999 }
1001 /* Returns true if functions FN1 and FN2 have equivalent trailing
1002 requires clauses. */
1004 static bool
1006 {
1007 /* In the concepts TS, the combined constraints are compared. */
1009 {
1015 }
1017 /* [temp.friend]/9 "Such a constrained friend function does not declare the
1018 same function as a declaration in any other scope." So no need to
1019 actually compare the requirements. */
1024 /* Compare only trailing requirements. */
1030 /* Substitution is needed when friends are involved. */
1035 }
1037 /* Two functions of the same name correspond [basic.scope.scope] if
1039 + both declare functions with the same non-object-parameter-type-list,
1040 equivalent ([temp.over.link]) trailing requires-clauses (if any, except as
1041 specified in [temp.friend]), and, if both are non-static members, they have
1042 corresponding object parameters, or
1044 + both declare function templates with equivalent
1045 non-object-parameter-type-lists, return types (if any), template-heads, and
1046 trailing requires-clauses (if any), and, if both are non-static members,
1047 they have corresponding object parameters.
1049 This is a subset of decls_match: it identifies declarations that cannot be
1050 overloaded with one another. This function does not consider DECL_NAME. */
1052 bool
1054 {
1059 {
1064 }
1072 /* If only one is a non-static member function, ignore ref-quals. */
1075 /* Two non-static member functions have corresponding object parameters if:
1076 + exactly one is an implicit object member function with no ref-qualifier
1077 and the types of their object parameters ([dcl.fct]), after removing
1078 top-level references, are the same, or
1079 + their object parameters have the same type. */
1080 /* ??? We treat member functions of different classes as corresponding even
1081 though that means the object parameters have different types. */
1088 {
1092 }
1094 /* Two function declarations match if either has a requires-clause
1095 then both have a requires-clause and their constraints-expressions
1096 are equivalent. */
1101 }
1103 /* Subroutine of duplicate_decls: return truthvalue of whether
1104 or not types of these decls match.
1106 For C++, we must compare the parameter list so that `int' can match
1107 `int&' in a parameter position, but `int&' is not confused with
1108 `const int&'. */
1110 int
1112 {
1119 /* If the two DECLs are not even the same kind of thing, we're not
1120 interested in their types. */
1126 {
1127 /* Specializations of different templates are different functions
1128 even if they have the same type. */
1143 /* A new declaration doesn't match a built-in one unless it
1144 is also extern "C". */
1154 /* A declaration with deduced return type should use its pre-deduction
1155 type for declaration matching. */
1163 {
1166 {
1170 }
1171 else
1172 types_match =
1178 }
1179 else
1182 /* Two function declarations match if either has a requires-clause
1183 then both have a requires-clause and their constraints-expressions
1184 are equivalent. */
1188 /* The decls dont match if they correspond to two different versions
1189 of the same function. Disallow extern "C" functions to be
1190 versions for now. */
1195 {
1201 }
1202 }
1204 {
1214 /* Two template types match if they are the same. Otherwise, compare
1215 the underlying declarations. */
1218 else
1220 }
1221 else
1222 {
1223 /* Need to check scope for variable declaration (VAR_DECL).
1224 For typedef (TYPE_DECL), scope is ignored. */
1227 /* [dcl.link]
1228 Two declarations for an object with C language linkage
1229 with the same name (ignoring the namespace that qualify
1230 it) that appear in different namespace scopes refer to
1231 the same object. */
1241 else
1244 COMPARE_REDECLARATION);
1245 }
1248 }
1250 /* Mark DECL as versioned if it isn't already. */
1252 static void
1254 {
1256 {
1258 /* If DECL_ASSEMBLER_NAME has already been set, re-mangle
1259 to include the version marker. */
1262 }
1263 }
1265 /* NEWDECL and OLDDECL have identical signatures. If they are
1266 different versions adjust them and return true.
1267 If RECORD is set to true, record function versions. */
1269 bool
1271 {
1277 {
1280 }
1284 {
1285 /* Unfortunately, we can get here before pushdecl naturally calls
1286 push_local_extern_decl_alias, so we need to call it directly. */
1291 }
1297 }
1299 /* If NEWDECL is `static' and an `extern' was seen previously,
1300 warn about it. OLDDECL is the previous declaration.
1302 Note that this does not apply to the C++ case of declaring
1303 a variable `extern const' and then later `const'.
1305 Don't complain about built-in functions, since they are beyond
1306 the user's control. */
1308 void
1310 {
1317 /* Don't get confused by static member functions; that's a different
1318 use of `static'. */
1323 /* If the old declaration was `static', or the new one isn't, then
1324 everything is OK. */
1328 /* It's OK to declare a builtin function as `static'. */
1333 auto_diagnostic_group d;
1338 }
1340 /* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1341 function templates. If their exception specifications do not
1342 match, issue a diagnostic. */
1344 static void
1346 tree old_decl)
1347 {
1351 /* Two default specs are equivalent, don't force evaluation. */
1357 {
1360 }
1364 /* [except.spec]
1366 If any declaration of a function has an exception-specification,
1367 all declarations, including the definition and an explicit
1368 specialization, of that function shall have an
1369 exception-specification with the same set of type-ids. */
1373 {
1378 auto_diagnostic_group d;
1382 /* We used to silently permit mismatched eh specs with
1383 -fno-exceptions, so make them a pedwarn now. */
1385 else
1390 }
1391 }
1393 /* Return true if OLD_DECL and NEW_DECL agree on constexprness.
1394 Otherwise issue diagnostics. */
1396 static bool
1398 {
1406 {
1412 }
1414 {
1415 /* With -fimplicit-constexpr, ignore changes in the constexpr
1416 keyword. */
1422 {
1423 /* Hide a built-in declaration. */
1429 }
1430 /* 7.1.5 [dcl.constexpr]
1431 Note: An explicit specialization can differ from the template
1432 declaration with respect to the constexpr specifier. */
1442 "redeclaration %qD differs in %qs "
1444 kind);
1448 }
1450 }
1452 // If OLDDECL and NEWDECL are concept declarations with the same type
1453 // (i.e., and template parameters), but different requirements,
1454 // emit diagnostics and return true. Otherwise, return false.
1457 {
1469 {
1474 {
1477 }
1478 }
1480 }
1482 /* DECL is a redeclaration of a function or function template. If
1483 it does have default arguments issue a diagnostic. Note: this
1484 function is used to enforce the requirements in C++11 8.3.6 about
1485 no default arguments in redeclarations. */
1487 static void
1489 {
1495 {
1497 "redeclaration of %q#D may not have default "
1500 }
1501 }
1503 /* NEWDECL is a redeclaration of a function or function template OLDDECL,
1504 in any case represented as FUNCTION_DECLs (the DECL_TEMPLATE_RESULTs of
1505 the TEMPLATE_DECLs in case of function templates). This function is used
1506 to enforce the final part of C++17 11.3.6/4, about a single declaration:
1507 "If a friend declaration specifies a default argument expression, that
1508 declaration shall be a definition and shall be the only declaration of
1509 the function or function template in the translation unit." */
1511 static void
1513 {
1523 {
1524 auto_diagnostic_group d;
1526 "friend declaration of %q#D specifies default "
1531 }
1532 }
1534 /* Merge tree bits that correspond to attributes noreturn, nothrow,
1535 const, malloc, and pure from NEWDECL with those of OLDDECL. */
1537 static void
1539 {
1556 }
1558 #define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn) \
1560 DECL_ATTRIBUTES (fn)))
1562 /* A subroutine of duplicate_decls. Emits a diagnostic when newdecl
1563 ambiguates olddecl. Returns true if an error occurs. */
1565 static bool
1567 {
1570 /* Function template declarations can be differentiated by parameter
1571 and return type. */
1576 {
1577 /* ... and also by their template-heads and requires-clauses. */
1580 {
1585 }
1587 /* FIXME: The types are the same but the are differences
1588 in either the template heads or function requirements.
1589 We should be able to diagnose a set of common errors
1590 stemming from these declarations. For example:
1592 template<typename T> requires C void f(...);
1593 template<typename T> void f(...) requires C;
1595 These are functionally equivalent but not equivalent. */
1596 }
1599 }
1601 /* OLD_PARMS is the innermost set of template parameters for some template
1602 declaration, and NEW_PARMS is the corresponding set of template parameters
1603 for a redeclaration of that template. Merge the default arguments within
1604 these two sets of parameters. CLASS_P is true iff the template in
1605 question is a class template. */
1607 bool
1609 {
1613 {
1621 {
1622 auto_diagnostic_group d;
1627 }
1629 /* Update the previous template parameters (which are the ones
1630 that will really count) with the new default value. */
1633 /* Update the new parameters, too; they'll be used as the
1634 parameters for any members. */
1636 }
1638 }
1640 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1641 If the redeclaration is invalid, a diagnostic is issued, and the
1642 error_mark_node is returned. Otherwise, OLDDECL is returned.
1644 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1645 returned.
1647 HIDING is true if the new decl is being hidden. WAS_HIDDEN is true
1648 if the old decl was hidden.
1650 Hidden decls can be anticipated builtins, injected friends, or
1651 (coming soon) injected from a local-extern decl. */
1653 tree
1655 {
1659 tree new_template_info;
1668 /* If either the type of the new decl or the type of the old decl is an
1669 error_mark_node, then that implies that we have already issued an
1670 error (earlier) for some bogus type specification, and in that case,
1671 it is rather pointless to harass the user with yet more error message
1672 about the same declaration, so just pretend the types match here. */
1677 /* Check for redeclaration and other discrepancies. */
1680 {
1682 {
1683 /* Avoid warnings redeclaring built-ins which have not been
1684 explicitly declared. */
1686 {
1690 OPT_Wbuiltin_declaration_mismatch,
1692 newdecl);
1694 }
1696 /* If you declare a built-in or predefined function name as static,
1697 the old definition is overridden, but optionally warn this was a
1698 bad choice of name. */
1700 {
1702 OPT_Wshadow,
1706 /* Discard the old built-in function. */
1708 }
1709 /* If the built-in is not ansi, then programs can override
1710 it even globally without an error. */
1715 else
1717 "declaration of %q#D conflicts with built-in "
1720 }
1722 {
1723 /* Avoid warnings redeclaring built-ins which have not been
1724 explicitly declared. */
1726 {
1729 /* A new declaration doesn't match a built-in one unless it
1730 is also extern "C". */
1740 {
1743 /* FILE, tm types are not known at the time
1744 we create the builtins. */
1750 {
1757 {
1767 }
1769 }
1773 next_arg:;
1774 }
1777 OPT_Wbuiltin_declaration_mismatch,
1778 "declaration of %q#D conflicts with built-in "
1780 }
1785 {
1786 /* Don't really override olddecl for __* prefixed builtins
1787 except for __[^b]*_chk, the compiler might be using those
1788 explicitly. */
1790 {
1801 {
1803 {
1805 "definition of %q#D ambiguates built-in "
1808 }
1809 auto_diagnostic_group d;
1811 "new declaration %q#D ambiguates built-in"
1817 }
1818 }
1820 /* A near match; override the builtin. */
1824 OPT_Wbuiltin_declaration_mismatch,
1825 "new declaration %q#D ambiguates built-in "
1827 else
1832 }
1833 else
1834 /* Discard the old built-in function. */
1837 /* Replace the old RTL to avoid problems with inlining. */
1839 }
1840 else
1841 {
1842 /* Even if the types match, prefer the new declarations type
1843 for built-ins which have not been explicitly declared,
1844 for exception lists, etc... */
1851 }
1853 /* If a function is explicitly declared "throw ()", propagate that to
1854 the corresponding builtin. */
1856 && was_hidden
1859 {
1864 }
1866 /* Whether or not the builtin can throw exceptions has no
1867 bearing on this declarator. */
1871 {
1872 /* If a builtin function is redeclared as `static', merge
1873 the declarations, but make the original one static. */
1877 /* Make the old declaration consistent with the new one so
1878 that all remnants of the builtin-ness of this function
1879 will be banished. */
1882 }
1883 }
1885 {
1886 /* C++ Standard, 3.3, clause 4:
1887 "[Note: a namespace name or a class template name must be unique
1888 in its declarative region (7.3.2, clause 14). ]" */
1909 {
1910 /* One is a function and the other is a template
1911 function. */
1915 /* There can only be one! */
1919 "literal operator %q#D conflicts with"
1923 "raw literal operator %q#D conflicts with"
1925 else
1930 }
1936 /* One is an implicit typedef, that's ok. */
1943 }
1945 {
1947 /* These are certainly not duplicate declarations; they're
1948 from different scopes. */
1952 {
1956 /* The name of a class template may not be declared to refer to
1957 any other template, class, function, object, namespace, value,
1958 or type in the same scope. */
1961 {
1967 }
1971 {
1975 }
1979 }
1981 {
1983 {
1986 newdecl);
1990 }
1991 /* For function versions, params and types match, but they
1992 are not ambiguous. */
1995 /* Let constrained hidden friends coexist for now, we'll
1996 check satisfaction later. */
1999 // The functions have the same parameter types.
2002 // And the same constraints.
2004 {
2010 }
2011 else
2013 }
2014 else
2015 {
2020 }
2021 }
2024 {
2025 /* OMP UDRs are never duplicates. */
2032 }
2042 /* It's OK to have a template specialization and a non-template
2043 with the same type, or to have specializations of two
2044 different templates with the same type. Note that if one is a
2045 specialization, and the other is an instantiation of the same
2046 template, that we do not exit at this point. That situation
2047 can occur if we instantiate a template class, and then
2048 specialize one of its methods. This situation is valid, but
2049 the declarations must be merged in the usual way. */
2056 /* One of the declarations is a template instantiation, and the
2057 other is not a template at all. That's OK. */
2060 {
2061 /* In [namespace.alias] we have:
2063 In a declarative region, a namespace-alias-definition can be
2064 used to redefine a namespace-alias declared in that declarative
2065 region to refer only to the namespace to which it already
2066 refers.
2068 Therefore, if we encounter a second alias directive for the same
2069 alias, we can just ignore the second directive. */
2075 /* Leave it to update_binding to merge or report error. */
2077 }
2078 else
2079 {
2082 {
2083 auto_diagnostic_group d;
2094 {
2099 {
2102 "structured binding at namespace scope is not "
2106 "static structured binding is not "
2110 "extern structured binding is not "
2112 }
2127 }
2129 }
2134 {
2135 /* Prototype decl follows defn w/o prototype. */
2136 auto_diagnostic_group d;
2141 }
2144 {
2145 /* [dcl.link]
2146 If two declarations of the same function or object
2147 specify different linkage-specifications ..., the program
2148 is ill-formed.... Except for functions with C++ linkage,
2149 a function declaration without a linkage specification
2150 shall not precede the first linkage specification for
2151 that function. A function can be declared without a
2152 linkage specification after an explicit linkage
2153 specification has been seen; the linkage explicitly
2154 specified in the earlier declaration is not affected by
2155 such a function declaration.
2157 DR 563 raises the question why the restrictions on
2158 functions should not also apply to objects. Older
2159 versions of G++ silently ignore the linkage-specification
2160 for this example:
2162 namespace N {
2163 extern int i;
2164 extern "C" int i;
2165 }
2167 which is clearly wrong. Therefore, we now treat objects
2168 like functions. */
2170 {
2171 /* There is no explicit linkage-specification, so we use
2172 the linkage from the previous declaration. */
2175 }
2176 else
2177 {
2178 auto_diagnostic_group d;
2185 }
2186 }
2189 ;
2191 {
2192 /* Note: free functions, as TEMPLATE_DECLs, are handled below. */
2195 as FUNCTION_DECLs. */
2197 /* C++11 8.3.6/6.
2198 Default arguments for a member function of a class
2199 template shall be specified on the initial declaration
2200 of the member function within the class template. */
2202 {
2207 {
2211 tree old_parms
2215 }
2216 }
2217 else
2218 {
2226 {
2229 {
2230 auto_diagnostic_group d;
2232 "default argument given for parameter "
2236 olddecl);
2237 }
2238 else
2239 {
2240 auto_diagnostic_group d;
2242 "default argument given for parameter %d "
2246 olddecl);
2247 }
2248 }
2250 /* C++17 11.3.6/4: "If a friend declaration specifies a default
2251 argument expression, that declaration... shall be the only
2252 declaration of the function or function template in the
2253 translation unit." */
2255 }
2256 }
2257 }
2259 /* Do not merge an implicit typedef with an explicit one. In:
2261 class A;
2262 ...
2263 typedef class A A __attribute__ ((foo));
2265 the attribute should apply only to the typedef. */
2281 {
2283 {
2286 else
2287 {
2290 }
2293 }
2298 /* Typedefs are not entities and so are OK to be redeclared
2299 as exported: see [module.interface]/p6. */
2301 {
2304 {
2305 auto_diagnostic_group d;
2309 }
2310 }
2313 }
2315 /* We have committed to returning OLDDECL at this point. */
2317 /* If new decl is `static' and an `extern' was seen previously,
2318 warn about it. */
2321 /* True to merge attributes between the declarations, false to
2322 set OLDDECL's attributes to those of NEWDECL (for template
2323 explicit specializations that specify their own attributes
2324 independent of those specified for the primary template). */
2330 {
2332 {
2338 /* [dcl.attr.noreturn]: The first declaration of a function shall
2339 specify the noreturn attribute if any declaration of that function
2340 specifies the noreturn attribute. */
2341 tree a;
2344 /* This applies to [[noreturn]] only, not its GNU variants. */
2348 {
2352 }
2353 }
2355 /* Now that functions must hold information normally held
2356 by field decls, there is extra work to do so that
2357 declaration information does not get destroyed during
2358 definition. */
2380 /* Optionally warn about more than one declaration for the same
2381 name, but don't warn about a function declaration followed by a
2382 definition. */
2385 /* Don't warn about extern decl followed by definition. */
2387 /* Don't warn if at least one is/was hidden. */
2389 /* Don't warn about declaration followed by specialization. */
2392 {
2393 auto_diagnostic_group d;
2395 OPT_Wredundant_decls,
2397 newdecl))
2400 }
2402 /* [dcl.fct.def.delete] A deleted definition of a function shall be the
2403 first declaration of the function or, for an explicit specialization
2404 of a function template, the first declaration of that
2405 specialization. */
2408 {
2410 {
2411 auto_diagnostic_group d;
2416 }
2418 }
2419 }
2421 /* Deal with C++: must preserve virtual function table size. */
2423 {
2433 }
2435 /* Copy all the DECL_... slots specified in the new decl except for
2436 any that we copy here from the old type. */
2440 else
2444 {
2449 /* The new decl should not already have gathered any
2450 specializations. */
2453 /* Make sure the contracts are equivalent. */
2456 /* Remove contracts from old_result so they aren't appended to
2457 old_result by the merge function. */
2464 {
2467 {
2468 /* Per C++11 8.3.6/4, default arguments cannot be added in
2469 later declarations of a function template. */
2471 /* C++17 11.3.6/4: "If a friend declaration specifies a default
2472 argument expression, that declaration... shall be the only
2473 declaration of the function or function template in the
2474 translation unit." */
2475 check_no_redeclaration_friend_default_args
2482 }
2490 {
2493 else
2504 }
2505 else
2506 {
2514 }
2515 }
2517 /* If the new declaration is a definition, update the file and
2518 line information on the declaration, and also make
2519 the old declaration the same definition. */
2521 {
2527 {
2534 }
2535 }
2538 }
2541 {
2545 /* Automatically handles default parameters. */
2547 tree newtype;
2549 /* For typedefs use the old type, as the new type's DECL_NAME points
2550 at newdecl, which will be ggc_freed. */
2552 {
2553 /* But NEWTYPE might have an attribute, honor that. */
2558 {
2562 }
2564 /* And remove the new type from the variants list. */
2566 {
2569 {
2571 /* If remove is the main variant, no need to remove that
2572 from the list. One of the DECL_ORIGINAL_TYPE
2573 variants, e.g. created for aligned attribute, might still
2574 refer to the newdecl TYPE_DECL though, so remove that one
2575 in that case. */
2581 {
2585 }
2586 }
2587 else
2591 {
2594 }
2595 }
2596 }
2599 else
2603 {
2605 /* For already initialized vars, TREE_READONLY could have been
2606 cleared in cp_finish_decl, because the var needs runtime
2607 initialization or destruction. Make sure not to set
2608 TREE_READONLY on it again. */
2625 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
2628 {
2629 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
2632 }
2633 }
2635 /* An explicit specialization of a function template or of a member
2636 function of a class template can be declared transaction_safe
2637 independently of whether the corresponding template entity is declared
2638 transaction_safe. */
2651 /* Lay the type out, unless already done. */
2665 /* Merge deprecatedness. */
2669 /* Merge unavailability. */
2673 /* Preserve function specific target and optimization options */
2675 {
2688 }
2689 else
2690 {
2691 /* Merge the const type qualifier. */
2694 /* Merge the volatile type qualifier. */
2697 }
2699 /* Merge the initialization information. */
2702 {
2706 {
2709 }
2710 }
2713 {
2726 else
2727 {
2728 /* Merge the noreturn bit. */
2734 }
2735 /* Keep the old RTL. */
2737 }
2740 {
2741 /* Keep the old RTL. We cannot keep the old RTL if the old
2742 declaration was for an incomplete object and the new
2743 declaration is not since many attributes of the RTL will
2744 change. */
2746 }
2747 }
2748 /* If cannot merge, then use the new type and qualifiers,
2749 and don't preserve the old rtl. */
2750 else
2751 {
2752 /* Clean out any memory we had of the old declaration. */
2762 }
2764 /* Merge the storage class information. */
2776 {
2778 /* This can happen if olddecl was brought in from the
2779 enclosing namespace via a using-decl. The new decl is
2780 then not a block-scope extern at all. */
2782 else
2783 {
2791 }
2792 }
2796 {
2808 {
2812 }
2815 {
2820 /* If the OLDDECL is an instantiation and/or specialization,
2821 then the NEWDECL must be too. But, it may not yet be marked
2822 as such if the caller has created NEWDECL, but has not yet
2823 figured out that it is a redeclaration. */
2830 }
2832 /* Don't really know how much of the language-specific
2833 values we should copy from old to new. */
2837 {
2840 {
2844 /* Remember the presence of explicit specialization args. */
2847 }
2849 /* We don't want to copy template info from a non-templated friend
2850 (PR105761), but these shouldn't have DECL_TEMPLATE_INFO now. */
2854 }
2857 {
2858 /* Only functions have these fields. */
2863 /* DECL_THUNKS is only valid for virtual functions,
2864 otherwise it is a DECL_FRIEND_CONTEXT. */
2869 }
2871 {
2872 /* Only variables have this field. */
2875 }
2876 }
2879 {
2880 tree parm;
2882 /* Merge parameter attributes. */
2887 {
2891 }
2895 {
2896 /* If newdecl is not a specialization, then it is not a
2897 template-related function at all. And that means that we
2898 should have exited above, returning 0. */
2902 /* From [temp.expl.spec]:
2904 If a template, a member template or the member of a class
2905 template is explicitly specialized then that
2906 specialization shall be declared before the first use of
2907 that specialization that would cause an implicit
2908 instantiation to take place, in every translation unit in
2909 which such a use occurs. */
2911 olddecl);
2917 /* Don't propagate visibility from the template to the
2918 specialization here. We'll do that in determine_visibility if
2919 appropriate. */
2922 /* [temp.expl.spec/14] We don't inline explicit specialization
2923 just because the primary template says so. */
2933 }
2935 {
2936 /* Never inline re-defined extern inline functions.
2937 FIXME: this could be better handled by keeping both
2938 function as separate declarations. */
2940 }
2941 else
2942 {
2944 {
2948 }
2950 ;
2964 }
2966 /* Preserve abstractness on cloned [cd]tors. */
2969 /* Update newdecl's parms to point at olddecl. */
2975 {
2979 }
2981 {
2982 /* These are the final DECL_ARGUMENTS that will be used within the
2983 body; update any references to old DECL_ARGUMENTS in the
2984 contracts, if present. */
2988 /* These need to be copied so that the names are available.
2989 Note that if the types do match, we'll preserve inline
2990 info and other bits, but if not, we won't. */
2994 /* In some cases, duplicate_contracts will remove contracts from
2995 OLDDECL, to avoid duplications. Sometimes, the contracts end up
2996 shared. If we removed them, re-add them. */
2999 }
3000 /* If redeclaring a builtin function, it stays built in
3001 if newdecl is a gnu_inline definition, or if newdecl is just
3002 a declaration. */
3005 {
3007 /* If we're keeping the built-in definition, keep the rtl,
3008 regardless of declaration matches. */
3011 {
3014 {
3015 /* A compatible prototype of these builtin functions
3016 is seen, assume the runtime implements it with
3017 the expected semantics. */
3019 {
3026 }
3027 }
3030 }
3031 }
3033 /* If defining a function declared with other language
3034 linkage, use the previously declared language linkage. */
3037 {
3039 /* Don't clear out the arguments if we're just redeclaring a
3040 function. */
3042 {
3043 /* If we removed contracts from previous definition, re-attach
3044 them. Otherwise, rewrite the contracts so they match the
3045 parameters of the new declaration. */
3050 else
3051 {
3052 /* Temporarily undo the re-contexting of parameters so we can
3053 actually remap parameters. The inliner won't replace
3054 parameters if we don't do this. */
3059 /* Save new argument names for use in contracts parsing,
3060 unless we've already started parsing the body of olddecl
3061 (particular issues arise when newdecl is from a prior
3062 friend decl with no argument names, see
3063 modules/contracts-tpl-friend-1). */
3067 /* And reverse this operation again. */
3070 }
3073 }
3074 }
3075 }
3079 /* Now preserve various other info from the definition. */
3085 /* Warn about conflicting visibility specifications. */
3089 {
3090 auto_diagnostic_group d;
3092 "%qD: visibility attribute ignored because it "
3096 }
3097 /* Choose the declaration which specified visibility. */
3099 {
3102 }
3103 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
3104 so keep this behavior. */
3106 {
3109 }
3110 /* Likewise for DECL_ALIGN, DECL_USER_ALIGN and DECL_PACKED. */
3112 {
3115 }
3128 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
3129 with that from NEWDECL below. */
3131 {
3135 }
3137 /* Merge the USED information. */
3144 {
3149 }
3156 /* Merge the DECL_FUNCTION_VERSIONED information. newdecl will be copied
3157 to olddecl and deleted. */
3160 {
3161 /* Set the flag for newdecl so that it gets copied to olddecl. */
3163 /* newdecl will be purged after copying to olddecl and is no longer
3164 a version. */
3166 }
3169 {
3183 /* Preserve symtab node mapping. */
3187 /* If newdecl is a template instantiation, it is possible that
3188 the following sequence of events has occurred:
3190 o A friend function was declared in a class template. The
3191 class template was instantiated.
3193 o The instantiation of the friend declaration was
3194 recorded on the instantiation list, and is newdecl.
3196 o Later, however, instantiate_class_template called pushdecl
3197 on the newdecl to perform name injection. But, pushdecl in
3198 turn called duplicate_decls when it discovered that another
3199 declaration of a global function with the same name already
3200 existed.
3202 o Here, in duplicate_decls, we decided to clobber newdecl.
3204 If we're going to do that, we'd better make sure that
3205 olddecl, and not newdecl, is on the list of
3206 instantiations so that if we try to do the instantiation
3207 again we won't get the clobbered declaration. */
3209 new_template_info,
3210 olddecl);
3211 }
3212 else
3213 {
3221 {
3229 {
3242 }
3250 }
3251 }
3254 {
3258 {
3259 /* Merge the section attribute.
3260 We want to issue an error if the sections conflict but that must be
3261 done later in decl_attributes since we are called before attributes
3262 are assigned. */
3267 {
3271 else
3275 }
3276 }
3280 {
3284 }
3285 }
3289 /* NEWDECL contains the merged attribute lists.
3290 Update OLDDECL to be the same. */
3293 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
3294 so that encode_section_info has a chance to look at the new decl
3295 flags and attributes. */
3302 /* The NEWDECL will no longer be needed. Because every out-of-class
3303 declaration of a member results in a call to duplicate_decls,
3304 freeing these nodes represents in a significant savings.
3306 Before releasing the node, be sore to remove function from symbol
3307 table that might have been inserted there to record comdat group.
3308 Be sure to however do not free DECL_STRUCT_FUNCTION because this
3309 structure is shared in between newdecl and oldecl. */
3313 {
3317 }
3320 {
3321 tree clone;
3323 {
3326 }
3327 }
3329 /* Remove the associated constraints for newdecl, if any, before
3330 reclaiming memory. */
3337 }
3338 \f
3339 /* Return zero if the declaration NEWDECL is valid
3340 when the declaration OLDDECL (assumed to be for the same name)
3341 has already been seen.
3342 Otherwise return an error message format string with a %s
3343 where the identifier should go. */
3347 {
3349 {
3350 /* Because C++ can put things into name space for free,
3351 constructs like "typedef struct foo { ... } foo"
3352 would look like an erroneous redeclaration. */
3355 else
3357 }
3359 {
3360 /* If this is a pure function, its olddecl will actually be
3361 the original initialization to `0' (which we force to call
3362 abort()). Don't complain about redefinition in this case. */
3367 /* If both functions come from different namespaces, this is not
3368 a redeclaration - this is a conflict with a used function. */
3374 /* We'll complain about linkage mismatches in
3375 warn_extern_redeclared_static. */
3377 /* Defining the same name twice is no good. */
3380 {
3386 }
3389 {
3394 {
3398 else
3401 }
3402 }
3404 /* [class.compare.default]: A definition of a comparison operator as
3405 defaulted that appears in a class shall be the first declaration of
3406 that function. */
3412 check_abi_tag_redeclaration
3417 }
3419 {
3443 {
3448 {
3452 else
3455 }
3456 }
3458 /* Core issue #226 (C++11):
3460 If a friend function template declaration specifies a
3461 default template-argument, that declaration shall be a
3462 definition and shall be the only declaration of the
3463 function template in the translation unit. */
3474 }
3481 {
3482 /* Only variables can be thread-local, and all declarations must
3483 agree on this property. */
3487 else
3490 }
3492 {
3493 /* The objects have been declared at namespace scope. If either
3494 is a member of an anonymous union, then this is an invalid
3495 redeclaration. For example:
3497 int i;
3498 union { int i; };
3500 is invalid. */
3504 /* If at least one declaration is a reference, there is no
3505 conflict. For example:
3507 int i = 3;
3508 extern int i;
3510 is valid. */
3514 /* Static data member declared outside a class definition
3515 if the variable is defined within the class with constexpr
3516 specifier is declaration rather than definition (and
3517 deprecated). */
3523 {
3525 /* For now, only warn with explicit -Wdeprecated. */
3527 {
3528 auto_diagnostic_group d;
3530 "redundant redeclaration of %<constexpr%> "
3534 }
3536 }
3538 /* Reject two definitions. */
3540 }
3541 else
3542 {
3543 /* Objects declared with block scope: */
3544 /* Reject two definitions, and reject a definition
3545 together with an external reference. */
3549 }
3550 }
3551 \f
3553 /* Hash and equality functions for the named_label table. */
3555 hashval_t
3557 {
3559 }
3561 bool
3563 {
3565 }
3567 /* Look for a label named ID in the current function. If one cannot
3568 be found, create one. Return the named_label_entry, or NULL on
3569 failure. */
3573 {
3576 /* You can't use labels at global scope. */
3578 {
3581 }
3587 named_label_entry **slot
3592 {
3597 {
3601 }
3602 }
3604 /* We are making a new decl, create or reuse the named_label_entry */
3608 else
3609 {
3614 }
3616 /* Now create the LABEL_DECL. */
3622 {
3626 }
3631 }
3633 /* Wrapper for lookup_label_1. */
3635 tree
3637 {
3640 }
3642 /* Remember that we've seen &&ID. */
3644 void
3646 {
3649 }
3651 tree
3653 {
3656 }
3658 /* Returns true if it is ill-formed to jump past the declaration of DECL. */
3660 static bool
3662 {
3663 /* [stmt.dcl]/3: A program that jumps from a point where a local variable
3664 with automatic storage duration is not in scope to a point where it is
3665 in scope is ill-formed unless the variable has scalar type, class type
3666 with a trivial default constructor and a trivial destructor, a
3667 cv-qualified version of one of these types, or an array of one of the
3668 preceding types and is declared without an initializer (8.5). */
3676 }
3678 /* A subroutine of check_previous_goto_1 and check_goto to identify a branch
3679 to the user. */
3681 static bool
3684 {
3687 bool complained
3692 {
3695 else
3697 }
3699 }
3701 /* Check that a single previously seen jump to a newly defined label
3702 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
3703 the jump context; NAMES are the names in scope in LEVEL at the jump
3704 context; LOCUS is the source position of the jump or 0. COMPUTED
3705 is a vec of decls if the jump is a computed goto. Returns
3706 true if all is well. */
3708 static bool
3712 {
3720 {
3722 computed);
3727 }
3730 {
3736 {
3742 {
3744 computed);
3746 }
3750 }
3758 {
3791 {
3795 }
3797 {
3801 }
3806 }
3809 {
3812 computed);
3816 }
3817 }
3820 {
3823 computed);
3827 {
3832 }
3833 }
3836 }
3838 static void
3840 {
3844 }
3846 static bool
3848 {
3851 }
3853 /* Check that a new jump to a label ENT is OK. COMPUTED is true
3854 if this is a possible target of a computed goto. */
3856 void
3858 {
3861 /* If the label hasn't been defined yet, defer checking. */
3863 {
3864 /* Don't bother creating another use if the last goto had the
3865 same data, and will therefore create the same set of errors. */
3870 named_label_use_entry *new_use
3881 }
3885 tree bad;
3892 {
3901 }
3904 {
3908 {
3909 /* Can't skip init of __exception_info. */
3911 {
3915 }
3919 }
3923 }
3926 {
3939 }
3942 {
3945 }
3948 {
3952 {
3954 {
3958 computed);
3960 }
3964 }
3965 }
3967 /* Warn if a computed goto might involve a local variable going out of scope
3968 without being cleaned up. */
3970 {
3974 {
3976 {
3978 {
3979 complained
3983 }
3987 }
3990 {
3993 {
3995 {
3996 complained
4000 }
4004 }
4005 }
4008 }
4009 }
4010 }
4012 /* Check that a new jump to a label DECL is OK. Called by
4013 finish_goto_stmt. */
4015 void
4017 {
4021 {
4022 /* We don't know where a computed goto is jumping,
4023 so check all addressable labels. */
4027 {
4031 }
4032 }
4033 else
4034 {
4036 named_label_entry **slot
4040 }
4041 }
4043 /* Check that a return is ok wrt OpenMP structured blocks.
4044 Called by finish_return_stmt. Returns true if all is well. */
4046 bool
4048 {
4051 {
4054 }
4058 }
4060 /* Define a label, specifying the location in the source file.
4061 Return the LABEL_DECL node for the label. */
4063 tree
4065 {
4068 /* After labels, make any new cleanups in the function go into their
4069 own new (temporary) binding contour. */
4079 {
4082 }
4083 else
4084 {
4085 /* Mark label as having been defined. */
4087 /* Say where in the source. */
4096 }
4099 }
4101 struct cp_switch
4102 {
4105 /* The SWITCH_STMT being built. */
4106 tree switch_stmt;
4107 /* A splay-tree mapping the low element of a case range to the high
4108 element, or NULL_TREE if there is no high element. Used to
4109 determine whether or not a new case label duplicates an old case
4110 label. We need a tree, rather than simply a hash table, because
4111 of the GNU case range extension. */
4112 splay_tree cases;
4113 /* Remember whether a default: case label has been seen. */
4115 /* Remember whether a BREAK_STMT has been seen in this SWITCH_STMT. */
4117 /* Set if inside of {FOR,DO,WHILE}_BODY nested inside of a switch,
4118 where BREAK_STMT doesn't belong to the SWITCH_STMT. */
4120 };
4122 /* A stack of the currently active switch statements. The innermost
4123 switch statement is on the top of the stack. There is no need to
4124 mark the stack for garbage collection because it is only active
4125 during the processing of the body of a function, and we never
4126 collect at that point. */
4130 /* Called right after a switch-statement condition is parsed.
4131 SWITCH_STMT is the switch statement being parsed. */
4133 void
4135 {
4145 }
4147 void
4149 {
4152 /* Emit warnings as needed. */
4155 const bool bool_cond_p
4161 bool_cond_p);
4163 /* For the benefit of block_may_fallthru remember if the switch body
4164 case labels cover all possible values and if there are break; stmts. */
4166 || (!processing_template_decl
4172 /* Now that we're done with the switch warnings, set the switch type
4173 to the type of the condition if the index type was of scoped enum type.
4174 (Such types don't participate in the integer promotions.) We do this
4175 because of bit-fields whose declared type is a scoped enum type:
4176 gimplification will use the lowered index type, but convert the
4177 case values to SWITCH_STMT_TYPE, which would have been the declared type
4178 and verify_gimple_switch doesn't accept that. */
4185 }
4187 /* Note that a BREAK_STMT is about to be added. If it is inside of
4188 a SWITCH_STMT and not inside of a loop body inside of it, note
4189 in switch_stack we've seen a BREAK_STMT. */
4191 void
4193 {
4196 }
4198 /* Note the start of processing of an iteration statement's body.
4199 The note_break_stmt function will do nothing while processing it.
4200 Return a flag that should be passed to note_iteration_stmt_body_end. */
4202 bool
4204 {
4210 }
4212 /* Note the end of processing of an iteration statement's body. */
4214 void
4216 {
4219 }
4221 /* Convert a case constant VALUE in a switch to the type TYPE of the switch
4222 condition. Note that if TYPE and VALUE are already integral we don't
4223 really do the conversion because the language-independent
4224 warning/optimization code will work better that way. */
4226 static tree
4228 {
4238 /* The constant-expression VALUE shall be a converted constant expression
4239 of the adjusted type of the switch condition, which doesn't allow
4240 narrowing conversions. */
4247 else
4248 /* The already integral case. */
4252 }
4254 /* Note that we've seen a definition of a case label, and complain if this
4255 is a bad place for one. */
4257 tree
4259 {
4262 tree type;
4268 {
4269 tree label;
4271 /* For templates, just add the case label; we'll do semantic
4272 analysis at instantiation-time. */
4275 }
4277 /* Find the condition on which this switch statement depends. */
4294 /* After labels, make any new cleanups in the function go into their
4295 own new (temporary) binding contour. */
4302 }
4303 \f
4305 tree scope;
4306 tree name;
4307 tree template_id;
4310 };
4313 {
4316 /* Hash a TYPENAME_TYPE. */
4318 static hashval_t
4320 {
4325 }
4327 static hashval_t
4329 {
4331 }
4333 static hashval_t
4335 {
4337 }
4339 /* Compare two TYPENAME_TYPEs. */
4341 static bool
4343 {
4349 }
4350 };
4352 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
4353 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
4355 Returns the new TYPENAME_TYPE. */
4359 tree
4362 {
4363 typename_info ti;
4377 /* See if we already have this type. */
4382 else
4383 {
4384 /* Build the TYPENAME_TYPE. */
4391 /* Build the corresponding TYPE_DECL. */
4398 /* Store it in the hash table. */
4401 /* TYPENAME_TYPEs must always be compared structurally, because
4402 they may or may not resolve down to another type depending on
4403 the currently open classes. */
4405 }
4408 }
4410 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
4411 provided to name the type. Returns an appropriate type, unless an
4412 error occurs, in which case error_mark_node is returned. If we
4413 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
4414 return that, rather than the _TYPE it corresponds to, in other
4415 cases we look through the type decl. If TF_ERROR is set, complain
4416 about errors, otherwise be quiet. */
4418 tree
4420 tsubst_flags_t complain)
4421 {
4422 tree fullname;
4423 tree t;
4432 {
4437 else
4438 /* Create a TEMPLATE_ID_EXPR for the type. */
4442 }
4449 {
4454 {
4458 }
4459 }
4461 {
4465 }
4467 {
4471 }
4478 {
4482 }
4484 /* When the CONTEXT is a dependent type, NAME could refer to a
4485 dependent base class of CONTEXT. But look inside it anyway
4486 if CONTEXT is a currently open scope, in case it refers to a
4487 member of the current instantiation or a non-dependent base;
4488 lookup will stop when we hit a dependent base. */
4490 {
4491 /* We generally don't ignore non-types during TYPENAME_TYPE lookup
4492 (as per [temp.res.general]/3), unless
4493 - the tag corresponds to a class-key or 'enum' so
4494 [basic.lookup.elab] applies, or
4495 - the tag corresponds to scope_type or tf_qualifying_scope is
4496 set so [basic.lookup.qual]/1 applies.
4497 TODO: If we'd set/track the scope_type tag thoroughly on all
4498 TYPENAME_TYPEs that are followed by :: then we wouldn't need the
4499 tf_qualifying_scope flag. */
4503 }
4504 else
4513 {
4515 {
4518 else
4521 }
4523 }
4525 /* Pull out the template from an injected-class-name (or multiple). */
4530 {
4532 {
4535 }
4537 }
4540 {
4545 }
4547 {
4550 /* The caller permits this typename-specifier to name a template
4552 else
4553 {
4558 }
4559 }
4569 {
4577 }
4585 }
4587 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
4588 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
4589 in which case error_mark_node is returned.
4591 If PARM_LIST is non-NULL, also make sure that the template parameter
4592 list of TEMPLATE_DECL matches.
4594 If COMPLAIN zero, don't complain about any errors that occur. */
4596 tree
4598 tsubst_flags_t complain)
4599 {
4608 {
4618 {
4622 }
4626 {
4628 {
4632 }
4634 }
4637 complain))
4641 }
4644 }
4646 /* Build an UNBOUND_CLASS_TEMPLATE. */
4648 tree
4650 {
4651 /* Build the UNBOUND_CLASS_TEMPLATE. */
4657 /* Build the corresponding TEMPLATE_DECL. */
4666 }
4668 \f
4670 /* Push the declarations of builtin types into the global namespace.
4671 RID_INDEX is the index of the builtin type in the array
4672 RID_POINTERS. NAME is the name used when looking up the builtin
4673 type. TYPE is the _TYPE node for the builtin type.
4675 The calls to set_global_binding below should be
4676 eliminated. Built-in types should not be looked up name; their
4677 names are keywords that the parser can recognize. However, there
4678 is code in c-common.cc that uses identifier_global_value to look up
4679 built-in types by name. */
4681 void
4684 tree type)
4685 {
4689 {
4695 }
4700 {
4706 }
4709 {
4713 }
4714 }
4716 /* Push a type into the namespace so that the back ends ignore it. */
4718 static void
4720 {
4723 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
4730 }
4732 /* Create all the predefined identifiers. */
4734 static void
4736 {
4737 struct predefined_identifier
4738 {
4742 };
4744 /* A table of identifiers to create at startup. */
4748 /* Some of these names have a trailing space so that it is
4749 impossible for them to conflict with names written by users. */
4766 /* The demangler expects anonymous namespaces to be called
4767 something starting with '_GLOBAL__N_'. It no longer needs
4768 to be unique to the TU. */
4798 };
4802 {
4804 /* Some of these identifiers already have a special kind. */
4807 }
4808 }
4810 /* Create the predefined scalar types of C,
4811 and some nodes representing standard constants (0, 1, (void *)0).
4812 Initialize the global binding level.
4813 Make definitions for built-in primitive functions. */
4815 void
4817 {
4818 tree void_ftype;
4819 tree void_ftype_ptr;
4821 /* Create all the identifiers we need. */
4824 /* Create the global variables. */
4829 /* Enter the global namespace. */
4832 void_type_node);
4837 /* Remember whether we want the empty class passing ABI change warning
4838 in this TU. */
4841 debug_hooks->register_main_translation_unit
4849 /* Initially, C. */
4852 /* Create the `std' namespace. */
4862 tree decl
4868 /* The concrete return type of __builtin_source_location is
4869 const std::source_location::__impl*, but we can't form the type
4870 at this point. So we initially declare it with an auto return
4871 type which we then "deduce" from require_deduced_type upon first use. */
4879 NULL_TREE);
4880 decl
4882 bool_vaftype,
4883 CP_BUILT_IN_IS_CORRESPONDING_MEMBER,
4887 decl
4889 bool_vaftype,
4890 CP_BUILT_IN_IS_POINTER_INTERCONVERTIBLE_WITH_CLASS,
4896 /* Guess at the initial static decls size. */
4899 /* ... and keyed classes. */
4911 NULL_TREE);
4913 #if 0
4915 #endif
4924 void_ftype_ptr
4927 /* Create the conversion operator marker. This operator's DECL_NAME
4928 is in the identifier table, so we can use identifier equality to
4929 find it. */
4931 void_ftype);
4933 /* C++ extensions */
4938 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
4941 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
4942 result. */
4949 /* Used when parsing to distinguish parameter-lists () and (void). */
4952 {
4953 /* Make sure we get a unique function type, so we can give
4954 its pointer type a name. (This wins for gdb.) */
4961 }
4964 vtbl_type_node
4980 /* Now, C++. */
4985 {
4987 aligned_new_threshold);
4989 }
4995 {
4998 tree ptr_ftype_sizetype;
4999 tree new_eh_spec;
5001 ptr_ftype_sizetype
5004 {
5005 tree bad_alloc_id;
5006 tree bad_alloc_type_node;
5007 tree bad_alloc_decl;
5013 bad_alloc_decl
5018 new_eh_spec
5020 }
5021 else
5024 /* Ensure attribs.cc is initialized. */
5028 NULL_TREE);
5031 extvisattr);
5051 {
5052 /* Also push the sized deallocation variants:
5053 void operator delete(void*, std::size_t) throw();
5054 void operator delete[](void*, std::size_t) throw(); */
5055 tree void_ftype_ptr_size
5059 extvisattr);
5067 }
5070 {
5077 /* operator new (size_t, align_val_t); */
5091 /* operator delete (void *, align_val_t); */
5104 {
5105 /* operator delete (void *, size_t, align_val_t); */
5108 NULL_TREE);
5117 }
5118 }
5120 /* C++-specific nullptr initialization. */
5124 }
5129 abort_fndecl
5133 /* If no definition is available, resolve references to NULL. */
5136 /* Perform other language dependent initializations. */
5150 /* Show we use EH for cleanups. */
5154 /* Check that the hardware interference sizes are at least
5155 alignof(max_align_t), as required by the standard. */
5158 {
5164 "%<--param destructive-interference-size=%d%> "
5167 }
5172 /* else leave it unset. */
5175 {
5182 "%<--param constructive-interference-size=%d%> "
5185 }
5190 }
5192 /* Enter an abi node in global-module context. returns a cookie to
5193 give to pop_abi_namespace. */
5195 unsigned
5197 {
5203 }
5205 /* Pop an abi namespace, FLAGS is the cookie push_abi_namespace gave
5206 you. */
5208 void
5210 {
5214 }
5216 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give
5217 the decl, LOC is the location to give the decl, NAME is the
5218 initialization string and TYPE_DEP indicates whether NAME depended
5219 on the type of the function. We make use of that to detect
5220 __PRETTY_FUNCTION__ inside a template fn. This is being done lazily
5221 at the point of first use, so we mustn't push the decl now. */
5223 static tree
5225 {
5230 {
5237 {
5238 /* __FUNCTION__ */
5241 }
5242 else
5243 {
5244 /* __PRETTY_FUNCTION__ */
5247 }
5254 }
5261 else
5275 /* For decl_constant_var_p. */
5279 {
5284 }
5285 else
5286 {
5289 }
5292 }
5294 /* Install DECL as a builtin function at current global scope. Return
5295 the new decl (if we found an existing version). Also installs it
5296 into ::std, if it's not '_*'. */
5298 tree
5300 {
5305 /* Runtime library routines are, by definition, available in an
5306 external shared object. */
5314 /* In the user's namespace, it must be declared before use. */
5320 /* Treat __*_chk fortification functions as anticipated as well,
5321 unless they are __builtin_*_chk. */
5324 /* All builtins that don't begin with an '_' should additionally
5325 go in the 'std' namespace. */
5327 {
5334 }
5340 }
5342 /* Like cxx_builtin_function, but guarantee the function is added to the global
5343 scope. This is to allow function specific options to add new machine
5344 dependent builtins when the target ISA changes via attribute((target(...)))
5345 which saves space on program startup if the program does not use non-generic
5346 ISAs. */
5348 tree
5350 {
5356 }
5358 /* Implement LANG_HOOKS_SIMULATE_BUILTIN_FUNCTION_DECL. */
5360 tree
5362 {
5369 }
5371 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
5372 function. Not called directly. */
5374 static tree
5377 {
5385 /* Runtime library routines are, by definition, available in an
5386 external shared object. */
5391 }
5393 /* Returns the _DECL for a library function with C++ linkage. */
5395 static tree
5398 {
5403 }
5405 /* Like build_library_fn, but takes a C string instead of an
5406 IDENTIFIER_NODE. */
5408 tree
5410 {
5412 }
5414 /* Like build_cp_library_fn, but takes a C string instead of an
5415 IDENTIFIER_NODE. */
5417 tree
5419 {
5421 ecf_flags);
5422 }
5424 /* Like build_library_fn, but also pushes the function so that we will
5425 be able to find it via get_global_binding. Also, the function
5426 may throw exceptions listed in RAISES. */
5428 tree
5430 {
5436 }
5438 /* Like build_cp_library_fn, but also pushes the function so that it
5439 will be found by normal lookup. */
5441 static tree
5444 {
5451 }
5453 /* Like push_library_fn, but also note that this function throws
5454 and does not return. Used for __throw_foo and the like. */
5456 tree
5458 {
5462 }
5463 \f
5464 /* When we call finish_struct for an anonymous union, we create
5465 default copy constructors and such. But, an anonymous union
5466 shouldn't have such things; this function undoes the damage to the
5467 anonymous union type T.
5469 (The reason that we create the synthesized methods is that we don't
5470 distinguish `union { int i; }' from `typedef union { int i; } U'.
5471 The first is an anonymous union; the second is just an ordinary
5472 union type.) */
5474 void
5476 {
5477 /* Wipe out memory of synthesized methods. */
5485 /* Splice the implicitly generated functions out of TYPE_FIELDS and diagnose
5486 invalid members. */
5488 {
5491 else
5501 {
5502 /* We already complained about static data members in
5503 finish_static_data_member_decl. */
5505 {
5506 auto_diagnostic_group d;
5510 "only have public non-static data members"
5513 {
5516 {
5519 "this flexibility is deprecated and will be "
5521 }
5522 }
5523 }
5524 }
5525 }
5527 /* Splice all functions out of CLASSTYPE_MEMBER_VEC. */
5535 /* Wipe RTTI info. */
5538 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
5539 assignment operators (because they cannot have these methods themselves).
5540 For anonymous unions this is already checked because they are not allowed
5541 in any union, otherwise we have to check it. */
5543 {
5547 {
5549 /* Avoid ICE after error on anon-struct9.C. */
5551 }
5555 {
5558 {
5568 }
5569 }
5570 }
5571 }
5573 /* Warn for an attribute located at LOCATION that appertains to the
5574 class type CLASS_TYPE that has not been properly placed after its
5575 class-key, in it class-specifier. */
5577 void
5579 tree class_type)
5580 {
5583 auto_diagnostic_group d;
5585 "attribute ignored in declaration "
5590 }
5592 /* Returns the cv-qualifiers that apply to the type specified
5593 by the DECLSPECS. */
5595 static int
5597 {
5608 }
5610 /* Make sure that a declaration with no declarator is well-formed, i.e.
5611 just declares a tagged type or anonymous union.
5613 Returns the type declared; or NULL_TREE if none. */
5615 tree
5618 {
5621 /* If a class, struct, or enum type is declared by the DECLSPECS
5622 (i.e, if a class-specifier, enum-specifier, or non-typename
5623 elaborated-type-specifier appears in the DECLSPECS),
5624 DECLARED_TYPE is set to the corresponding type. */
5632 {
5638 }
5650 {
5652 "%<auto%> can only be specified for variables "
5655 }
5662 /* Check for an anonymous union. */
5665 {
5666 /* 7/3 In a simple-declaration, the optional init-declarator-list
5667 can be omitted only when declaring a class (clause 9) or
5668 enumeration (7.2), that is, when the decl-specifier-seq contains
5669 either a class-specifier, an elaborated-type-specifier with
5670 a class-key (9.1), or an enum-specifier. In these cases and
5671 whenever a class-specifier or enum-specifier is present in the
5672 decl-specifier-seq, the identifiers in these specifiers are among
5673 the names being declared by the declaration (as class-name,
5674 enum-names, or enumerators, depending on the syntax). In such
5675 cases, and except for the declaration of an unnamed bit-field (9.6),
5676 the decl-specifier-seq shall introduce one or more names into the
5677 program, or shall redeclare a name introduced by a previous
5678 declaration. [Example:
5679 enum { }; // ill-formed
5680 typedef class { }; // ill-formed
5681 --end example] */
5683 {
5687 }
5694 }
5696 else
5697 {
5705 && (!current_class_type
5714 "a storage class can only be specified for objects "
5718 "%<const%> can only be specified for objects and "
5722 "%<volatile%> can only be specified for objects and "
5726 "%<__restrict%> can only be specified for objects and "
5730 "%<__thread%> can only be specified for objects "
5744 }
5747 {
5748 location_t loc;
5751 /* For a non-template class, use the name location. */
5753 else
5754 /* For a template class (an explicit instantiation), use the
5755 current location. */
5759 /* [dcl.attr.grammar]/4:
5761 No attribute-specifier-seq shall appertain to an explicit
5762 instantiation. */
5763 {
5766 declared_type))
5768 "no attribute can be applied to "
5770 }
5771 else
5773 }
5775 /* Diagnose invalid application of contracts, if any. */
5778 else
5782 }
5784 /* Called when a declaration is seen that contains no names to declare.
5785 If its type is a reference to a structure, union or enum inherited
5786 from a containing scope, shadow that tag name for the current scope
5787 with a forward reference.
5788 If its type defines a new named structure or union
5789 or defines an enum, it is valid but we need not do anything here.
5790 Otherwise, it is an error.
5792 C++: may have to grok the declspecs to learn about static,
5793 complain for anonymous unions.
5795 Returns the TYPE declared -- or NULL_TREE if none. */
5797 tree
5799 {
5810 /* This is where the variables in an anonymous union are
5811 declared. An anonymous union declaration looks like:
5812 union { ... } ;
5813 because there is no declarator after the union, the parser
5814 sends that declaration here. */
5816 {
5820 {
5824 }
5825 }
5828 }
5829 \f
5830 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
5832 tree
5836 {
5837 tree attrs;
5838 tree type;
5839 enum decl_context context
5845 {
5850 /* A template type parameter or other dependent type. */
5853 else
5855 }
5857 }
5859 /* Process a DECLARATOR for a function-scope or namespace-scope
5860 variable or function declaration.
5861 (Function definitions go through start_function; class member
5862 declarations appearing in the body of the class go through
5863 grokfield.) The DECL corresponding to the DECLARATOR is returned.
5864 If an error occurs, the error_mark_node is returned instead.
5866 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED is
5867 SD_INITIALIZED if an explicit initializer is present, or SD_DEFAULTED
5868 for an explicitly defaulted function, or SD_DELETED for an explicitly
5869 deleted function, but 0 (SD_UNINITIALIZED) if this is a variable
5870 implicitly initialized via a default constructor. It can also be
5871 SD_DECOMPOSITION which behaves much like SD_INITIALIZED, but we also
5872 mark the new decl as DECL_DECOMPOSITION_P.
5874 ATTRIBUTES and PREFIX_ATTRIBUTES are GNU attributes associated with this
5875 declaration.
5877 The scope represented by the context of the returned DECL is pushed
5878 (if it is not the global namespace) and is assigned to
5879 *PUSHED_SCOPE_P. The caller is then responsible for calling
5880 pop_scope on *PUSHED_SCOPE_P if it is set. */
5882 tree
5886 tree attributes,
5887 tree prefix_attributes,
5889 {
5890 tree decl;
5891 tree context;
5895 tree initial;
5915 {
5920 }
5922 /* Save the DECL_INITIAL value in case it gets clobbered to assist
5923 with attribute validation. */
5927 {
5931 decl);
5935 /* Tell 'cplus_decl_attributes' this is an initialized decl,
5936 even though we might not yet have the initializer expression. */
5939 }
5945 /* If this is a typedef that names the class for linkage purposes
5946 (7.1.3p8), apply any attributes directly to the type. */
5951 else
5954 /* Set attributes here so if duplicate decl, will have proper attributes. */
5957 /* Restore the original DECL_INITIAL that we may have clobbered earlier to
5958 assist with attribute validation. */
5961 /* Dllimported symbols cannot be defined. Static data members (which
5962 can be initialized in-class and dllimported) go through grokfield,
5963 not here, so we don't need to exclude those decls when checking for
5964 a definition. */
5966 {
5970 }
5972 /* If #pragma weak was used, mark the decl weak now. */
5984 {
5988 {
5998 {
6004 }
6005 else
6006 {
6011 {
6018 }
6019 /* Static data member are tricky; an in-class initialization
6020 still doesn't provide a definition, so the in-class
6021 declaration will have DECL_EXTERNAL set, but will have an
6022 initialization. Thus, duplicate_decls won't warn
6023 about this situation, and so we check here. */
6031 }
6032 }
6033 else
6034 {
6036 this_tmpl
6037 ? current_template_parms
6042 }
6044 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
6046 /* Do not mark DECL as an explicit specialization if it was not
6047 already marked as an instantiation; a declaration should
6048 never be marked as a specialization unless we know what
6049 template is being specialized. */
6051 {
6056 else
6059 /* [temp.expl.spec] An explicit specialization of a static data
6060 member of a template is a definition if the declaration
6061 includes an initializer; otherwise, it is a declaration.
6063 We check for processing_specialization so this only applies
6064 to the new specialization syntax. */
6067 }
6070 /* Aliases are definitions. */
6072 {
6076 decl);
6080 decl);
6081 }
6082 }
6084 /* Create a DECL_LANG_SPECIFIC so that DECL_DECOMPOSITION_P works. */
6092 {
6093 /* A function-scope decl of some namespace-scope decl. */
6097 "block-scope extern declaration %q#D not permitted"
6099 }
6101 /* Enter this declaration into the symbol table. Don't push the plain
6102 VAR_DECL for a variable template. */
6116 /* But not templated variables. */
6118 {
6119 /* This is a const variable with implicit 'static'. Set
6120 DECL_THIS_STATIC so we can tell it from variables that are
6121 !TREE_PUBLIC because of the anonymous namespace. */
6124 }
6129 {
6133 "%qD defined %<thread_local%> in %qs function only "
6139 "%qD defined %<static%> in %qs function only available "
6143 else
6147 }
6153 }
6155 /* Process the declaration of a variable DECL. INITIALIZED is true
6156 iff DECL is explicitly initialized. (INITIALIZED is false if the
6157 variable is initialized via an implicitly-called constructor.)
6158 This function must be called for ordinary variables (including, for
6159 example, implicit instantiations of templates), but must not be
6160 called for template declarations. */
6162 void
6164 {
6174 bool aggregate_definition_p
6177 /* If an explicit initializer is present, or if this is a definition
6178 of an aggregate, then we need a complete type at this point.
6179 (Scalars are always complete types, so there is nothing to
6180 check.) This code just sets COMPLETE_P; errors (if necessary)
6181 are issued below. */
6183 && !complete_p
6185 {
6187 /* We will not yet have set TREE_READONLY on DECL if the type
6188 was "const", but incomplete, before this point. But, now, we
6189 have a complete type, so we can try again. */
6191 }
6194 /* Is it valid for this decl to have an initializer at all? */
6195 {
6196 /* Don't allow initializations for incomplete types except for
6197 arrays which might be completed by the initialization. */
6203 {
6204 auto_diagnostic_group d;
6210 }
6212 {
6215 /* else we already gave an error in start_decl. */
6216 }
6217 }
6219 {
6222 else
6223 {
6224 auto_diagnostic_group d;
6226 decl);
6230 /* Change the type so that assemble_variable will give
6231 DECL an rtl we can live with: (mem (const_int 0)). */
6233 }
6234 }
6236 /* Create a new scope to hold this declaration if necessary.
6237 Whether or not a new scope is necessary cannot be determined
6238 until after the type has been completed; if the type is a
6239 specialization of a class template it is not until after
6240 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
6241 will be set correctly. */
6243 }
6245 /* Given a parenthesized list of values INIT, create a CONSTRUCTOR to handle
6246 C++20 P0960. TYPE is the type of the object we're initializing. */
6248 tree
6250 {
6254 {
6255 /* If the list has a single element and it's a string literal,
6256 then it's the initializer for the array as a whole. */
6262 /* Handle non-standard extensions like compound literals. This also
6263 prevents triggering aggregate parenthesized-initialization in
6264 compiler-generated code for =default. */
6268 }
6274 }
6276 /* Handle initialization of references. DECL, TYPE, and INIT have the
6277 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
6278 but will be set to a new CLEANUP_STMT if a temporary is created
6279 that must be destroyed subsequently.
6281 Returns an initializer expression to use to initialize DECL, or
6282 NULL if the initialization can be performed statically.
6284 Quotes on semantics can be found in ARM 8.4.3. */
6286 static tree
6288 {
6290 {
6297 }
6301 {
6302 /* This handles (C++20 only) code like
6304 const A& r(1, 2, 3);
6306 where we treat the parenthesized list as a CONSTRUCTOR. */
6311 {
6312 /* We don't know yet if we should treat const A& r(1) as
6313 const A& r{1}. */
6315 {
6318 tf_warning_or_error);
6319 }
6320 /* If the list had more than one element, the code is ill-formed
6321 pre-C++20, so we can build a constructor right away. */
6322 else
6324 }
6325 else
6327 tf_warning_or_error);
6328 }
6332 /* Note: default conversion is only called in very special cases. */
6335 /* check_initializer handles this for non-reference variables, but for
6336 references we need to do it here or the initializer will get the
6337 incomplete array type and confuse later calls to
6338 cp_complete_array_type. */
6343 {
6347 }
6349 /* Convert INIT to the reference type TYPE. This may involve the
6350 creation of a temporary, whose lifetime must be the same as that
6351 of the reference. If so, a DECL_EXPR for the temporary will be
6352 added just after the DECL_EXPR for DECL. That's why we don't set
6353 DECL_INITIAL for local references (instead assigning to them
6354 explicitly); we need to allow the temporary to be initialized
6355 first. */
6357 tf_warning_or_error);
6358 }
6360 /* Designated initializers in arrays are not supported in GNU C++.
6361 The parser cannot detect this error since it does not know whether
6362 a given brace-enclosed initializer is for a class type or for an
6363 array. This function checks that CE does not use a designated
6364 initializer. If it does, an error is issued. Returns true if CE
6365 is valid, i.e., does not have a designated initializer. */
6367 bool
6370 {
6371 /* Designated initializers for array elements are not supported. */
6373 {
6374 /* The parser only allows identifiers as designated
6375 initializers. */
6377 {
6381 }
6383 {
6387 }
6395 {
6396 /* A C99 designator is OK if it matches the current index. */
6398 {
6401 }
6402 else
6404 }
6405 else
6411 }
6414 }
6416 /* When parsing `int a[] = {1, 2};' we don't know the size of the
6417 array until we finish parsing the initializer. If that's the
6418 situation we're in, update DECL accordingly. */
6420 static void
6422 {
6428 {
6429 /* do_default is really a C-ism to deal with tentative definitions.
6430 But let's leave it here to ease the eventual merge. */
6435 /* Check that there are no designated initializers in INIT, as
6436 those are not supported in GNU C++, and as the middle-end
6437 will crash if presented with a non-numeric designated
6438 initializer. */
6440 {
6443 HOST_WIDE_INT i;
6445 {
6450 /* If an un-designated initializer is type-dependent, we can't
6451 check brace elision yet. */
6455 }
6456 }
6460 else
6461 {
6463 do_default);
6465 {
6469 }
6471 {
6473 {
6476 }
6477 /* If a `static' var's size isn't known, make it extern as
6478 well as static, so it does not get allocated. If it's not
6479 `static', then don't mark it extern; finish_incomplete_decl
6480 will give it a default size and it will get allocated. */
6483 }
6485 {
6488 }
6489 }
6494 }
6495 }
6497 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
6498 any appropriate error messages regarding the layout. */
6500 static void
6502 {
6503 tree type;
6509 /* If we haven't already laid out this declaration, do so now.
6510 Note that we must not call complete type for an external object
6511 because it's type might involve templates that we are not
6512 supposed to instantiate yet. (And it's perfectly valid to say
6513 `extern X x' for some incomplete type `X'.) */
6522 {
6523 /* An automatic variable with an incomplete type: that is an error.
6524 Don't talk about array types here, since we took care of that
6525 message in grokdeclarator. */
6529 }
6530 #if 0
6531 /* Keep this code around in case we later want to control debug info
6532 based on whether a type is "used". (jason 1999-11-11) */
6535 /* Let debugger know it should output info for this type. */
6540 #endif
6545 {
6549 else
6550 {
6555 }
6556 }
6558 /* If the final element initializes a flexible array field, add the size of
6559 that initializer to DECL's size. */
6569 {
6572 {
6579 {
6585 }
6586 }
6587 }
6588 }
6590 /* If a local static variable is declared in an inline function, or if
6591 we have a weak definition, we must endeavor to create only one
6592 instance of the variable at link-time. */
6594 void
6596 {
6597 /* Don't mess with __FUNCTION__ and similar. But do handle structured
6598 bindings. */
6602 /* Static data in a function with comdat linkage also has comdat
6603 linkage. */
6608 {
6610 {
6611 /* With weak symbols, we simply make the variable COMDAT;
6612 that will cause copies in multiple translations units to
6613 be merged. */
6615 }
6616 else
6617 {
6620 {
6621 /* Without weak symbols, we can use COMMON to merge
6622 uninitialized variables. */
6625 }
6626 else
6627 {
6628 /* While for initialized variables, we must use internal
6629 linkage -- which means that multiple copies will not
6630 be merged. */
6637 "%q#D are wrong (you%'ll wind up with "
6639 else
6641 "static data %q#D are wrong (you%'ll wind "
6647 }
6648 }
6649 }
6650 }
6652 /* Issue an error message if DECL is an uninitialized const variable.
6653 CONSTEXPR_CONTEXT_P is true when the function is called in a constexpr
6654 context from potential_constant_expression. Returns true if all is well,
6655 false otherwise. */
6657 bool
6659 tsubst_flags_t complain)
6660 {
6663 /* ``Unless explicitly declared extern, a const object does not have
6664 external linkage and must be initialized. ($8.4; $12.1)'' ARM
6665 7.1.6 */
6669 /* C++20 permits trivial default initialization in constexpr
6670 context (P1331R2). */
6672 && (constexpr_context_p
6675 {
6683 {
6685 {
6689 }
6690 else
6691 {
6695 "uninitialized variable %qD in %<constexpr%> "
6697 else
6700 }
6701 }
6705 decl);
6708 {
6709 tree defaulted_ctor;
6716 "constructor is not user-provided because it is "
6719 "and the implicitly-defined constructor does not "
6721 }
6724 }
6727 }
6728 \f
6729 /* Structure holding the current initializer being processed by reshape_init.
6730 CUR is a pointer to the current element being processed, END is a pointer
6731 after the last element present in the initializer. */
6732 struct reshape_iter
6733 {
6736 };
6740 /* FIELD is an element of TYPE_FIELDS or NULL. In the former case, the value
6741 returned is the next FIELD_DECL (possibly FIELD itself) that can be
6742 initialized as if for an aggregate class. If there are no more such fields,
6743 the return value will be NULL. */
6745 tree
6747 {
6752 /* In C++17, aggregates can have bases. */
6757 }
6759 /* FIELD is an element of TYPE_FIELDS or NULL. In the former case, the value
6760 returned is the next FIELD_DECL (possibly FIELD itself) that corresponds
6761 to a subobject. If there are no more such fields, the return value will be
6762 NULL. */
6764 tree
6766 {
6776 }
6778 /* Return true for [dcl.init.list] direct-list-initialization from
6779 single element of enumeration with a fixed underlying type. */
6781 bool
6783 {
6790 /* DR 2374: The single element needs to be implicitly
6791 convertible to the underlying type of the enum. */
6799 }
6801 /* Subroutine of reshape_init_array and reshape_init_vector, which does
6802 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
6803 INTEGER_CST representing the size of the array minus one (the maximum index),
6804 or NULL_TREE if the array was declared without specifying the size. D is
6805 the iterator within the constructor. */
6807 static tree
6810 {
6811 tree new_init;
6816 /* The initializer for an array is always a CONSTRUCTOR. If this is the
6817 outermost CONSTRUCTOR and the element type is non-aggregate, we don't need
6818 to build a new one. But don't reuse if not complaining; if this is
6819 tentative, we might also reshape to another type (95319). */
6826 else
6830 {
6831 /* Minus 1 is used for zero sized arrays. */
6837 /* sizetype is sign extended, not zero extended. */
6838 else
6840 }
6842 /* Loop until there are no more initializers. */
6846 {
6847 tree elt_init;
6855 complain);
6860 {
6863 }
6864 else
6870 /* This can happen with an invalid initializer (c++/54501). */
6873 }
6876 }
6878 /* Subroutine of reshape_init_r, processes the initializers for arrays.
6879 Parameters are the same of reshape_init_r. */
6881 static tree
6883 tsubst_flags_t complain)
6884 {
6894 }
6896 /* Subroutine of reshape_init_r, processes the initializers for vectors.
6897 Parameters are the same of reshape_init_r. */
6899 static tree
6901 {
6907 {
6910 {
6915 }
6918 }
6920 /* For a vector, we initialize it as an array of the appropriate size. */
6926 }
6928 /* Subroutine of reshape_init*: We're initializing an element with TYPE from
6929 INIT, in isolation from any designator or other initializers. */
6931 static tree
6933 {
6934 /* We could also implement this by wrapping init in a new CONSTRUCTOR and
6935 calling reshape_init, but this way can just live on the stack. */
6940 complain);
6941 }
6943 /* Subroutine of reshape_init_r, processes the initializers for classes
6944 or union. Parameters are the same of reshape_init_r. */
6946 static tree
6948 tsubst_flags_t complain)
6949 {
6950 tree field;
6951 tree new_init;
6955 /* The initializer for a class is always a CONSTRUCTOR. */
6962 {
6963 /* We get here from maybe_aggr_guide for C++20 class template argument
6964 deduction. In this case we need to look through the binfo because a
6965 template doesn't have base fields. */
6968 }
6971 else
6975 {
6976 /* [dcl.init.aggr]
6978 An initializer for an aggregate member that is an
6979 empty class shall have the form of an empty
6980 initializer-list {}. */
6982 {
6986 }
6988 }
6990 /* For C++20 CTAD, handle pack expansions in the base list. */
6993 /* Loop through the initializable fields, gathering initializers. */
6995 {
6996 tree field_init;
7000 /* Handle C++20 designated initializers. */
7002 {
7007 {
7008 /* We already reshaped this; we should have returned early from
7009 reshape_init. */
7012 {
7017 }
7018 }
7020 {
7024 }
7025 else
7026 {
7031 }
7034 /* Apparently the designator isn't for a member of this anonymous
7035 struct, so head back to the enclosing class. */
7039 {
7041 {
7043 {
7047 }
7048 else
7051 }
7053 }
7055 /* If the element is an anonymous union object and the initializer
7056 list is a designated-initializer-list, the anonymous union object
7057 is initialized by the designated-initializer-list { D }, where D
7058 is the designated-initializer-clause naming a member of the
7059 anonymous union object. */
7062 {
7063 /* Find the anon aggr that is a direct member of TYPE. */
7065 {
7070 }
7072 /* Not found, e.g. FIELD is a member of a base class. */
7077 found:
7078 /* Now find the TYPE member with that anon aggr type. */
7086 }
7087 }
7089 /* If we processed all the member of the class, we are done. */
7096 /* Each non-trailing aggregate element that is a pack expansion is
7097 assumed to correspond to no elements of the initializer list. */
7101 {
7102 /* The designated field F is initialized from this one element.
7104 Note that we don't want to do this if we found the designator
7105 inside an anon aggr above; we use the normal code to implement:
7107 "If the element is an anonymous union member and the initializer
7108 list is a brace-enclosed designated- initializer-list, the element
7109 is initialized by the designated-initializer-list { D }, where D
7110 is the designated- initializer-clause naming a member of the
7111 anonymous union member." */
7115 }
7116 else
7119 complain);
7125 {
7126 /* This can happen with an invalid initializer for a flexible
7127 array member (c++/54441). */
7131 }
7135 /* [dcl.init.aggr]
7137 When a union is initialized with a brace-enclosed
7138 initializer, the braces shall only contain an
7139 initializer for the first member of the union. */
7143 continue_:
7145 {
7148 else
7150 }
7151 else
7153 }
7155 /* A trailing aggregate element that is a pack expansion is assumed to
7156 correspond to all remaining elements of the initializer list (if any). */
7158 {
7163 }
7166 }
7168 /* Subroutine of reshape_init_r. We're in a context where C99 initializer
7169 designators are not valid; either complain or return true to indicate
7170 that reshape_init_r should return error_mark_node. */
7172 static bool
7174 {
7176 {
7181 else
7183 }
7185 }
7187 /* Subroutine of reshape_init, which processes a single initializer (part of
7188 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
7189 iterator within the CONSTRUCTOR which points to the initializer to process.
7190 If this is the first initializer of the outermost CONSTRUCTOR node,
7191 FIRST_INITIALIZER_P is that CONSTRUCTOR; otherwise, it is NULL_TREE. */
7193 static tree
7195 tsubst_flags_t complain)
7196 {
7209 {
7210 /* A complex type can be initialized from one or two initializers,
7211 but braces are not elided. */
7214 {
7216 {
7219 else
7221 }
7222 }
7224 {
7232 }
7234 }
7236 /* A non-aggregate type is always initialized with a single
7237 initializer. */
7239 /* As is an array with dependent bound, which we can see
7240 during C++20 aggregate CTAD. */
7244 {
7245 /* It is invalid to initialize a non-aggregate type with a
7246 brace-enclosed initializer before C++0x.
7247 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
7248 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
7249 a CONSTRUCTOR (with a record type). */
7251 /* Don't complain about a capture-init. */
7254 {
7256 {
7258 {
7261 type);
7263 }
7266 && (BRACE_ENCLOSED_INITIALIZER_P
7268 {
7273 }
7274 }
7275 else
7277 }
7281 }
7283 /* "If T is a class type and the initializer list has a single element of
7284 type cv U, where U is T or a class derived from T, the object is
7285 initialized from that element." Even if T is an aggregate. */
7287 && first_initializer_p
7288 /* But not if it's a designated init. */
7292 {
7295 }
7297 /* [dcl.init.aggr]
7299 All implicit type conversions (clause _conv_) are considered when
7300 initializing the aggregate member with an initializer from an
7301 initializer-list. If the initializer can initialize a member,
7302 the member is initialized. Otherwise, if the member is itself a
7303 non-empty subaggregate, brace elision is assumed and the
7304 initializer is considered for the initialization of the first
7305 member of the subaggregate. */
7307 /* But don't try this for the first initializer, since that would be
7308 looking through the outermost braces; A a2 = { a1 }; is not a
7309 valid aggregate initialization. */
7310 && !first_initializer_p
7313 complain)))
7314 {
7317 }
7319 /* [dcl.init.string]
7321 A char array (whether plain char, signed char, or unsigned char)
7322 can be initialized by a string-literal (optionally enclosed in
7323 braces); a wchar_t array can be initialized by a wide
7324 string-literal (optionally enclosed in braces). */
7327 {
7330 reshape_iter stripd = {};
7332 /* Strip one level of braces if and only if they enclose a single
7333 element (as allowed by [dcl.init.string]). */
7337 {
7341 }
7343 /* If it's a string literal, then it's the initializer for the array
7344 as a whole. Otherwise, continue with normal initialization for
7345 array types (one value per array element). */
7347 {
7353 }
7354 }
7356 /* The following cases are about aggregates. If we are not within a full
7357 initializer already, and there is not a CONSTRUCTOR, it means that there
7358 is a missing set of braces (that is, we are processing the case for
7359 which reshape_init exists). */
7362 {
7364 {
7367 /* There is no need to call reshape_init for pointer-to-member
7368 function initializers, as they are always constructed correctly
7369 by the front end. Here we have e.g. {.__pfn=0B, .__delta=0},
7370 which is missing outermost braces. We should warn below, and
7372 /* For a nested compound literal, proceed to specialized routines,
7373 to handle initialization of arrays and similar. */
7376 /* If we have an unresolved designator, we need to find the member it
7377 designates within TYPE, so proceed to the routines below. For
7378 FIELD_DECL or INTEGER_CST designators, we're already initializing
7379 the designated element. */
7382 /* Brace elision with designators is only permitted for anonymous
7383 aggregates. */
7385 /* A CONSTRUCTOR of the target's type is a previously
7386 digested initializer. */
7388 {
7391 }
7392 else
7393 {
7394 /* Something that hasn't been reshaped yet. */
7398 }
7399 }
7404 type);
7406 }
7408 /* Dispatch to specialized routines. */
7409 tree new_init;
7416 else
7424 }
7426 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
7427 brace-enclosed aggregate initializer.
7429 INIT is the CONSTRUCTOR containing the list of initializers describing
7430 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
7431 It may not presently match the shape of the TYPE; for example:
7433 struct S { int a; int b; };
7434 struct S a[] = { 1, 2, 3, 4 };
7436 Here INIT will hold a vector of four elements, rather than a
7437 vector of two elements, each itself a vector of two elements. This
7438 routine transforms INIT from the former form into the latter. The
7439 revised CONSTRUCTOR node is returned. */
7441 tree
7443 {
7445 reshape_iter d;
7446 tree new_init;
7452 /* An empty constructor does not need reshaping, and it is always a valid
7453 initializer. */
7458 /* Already reshaped. */
7461 /* Brace elision is not performed for a CONSTRUCTOR representing
7462 parenthesized aggregate initialization. */
7464 {
7466 /* If we're initializing a char array from a string-literal that is
7467 enclosed in braces, unwrap it here. */
7474 }
7476 /* Handle [dcl.init.list] direct-list-initialization from
7477 single element of enumeration with a fixed underlying type. */
7479 {
7483 {
7487 tf_warning_or_error);
7488 }
7489 else
7491 }
7493 /* Recurse on this CONSTRUCTOR. */
7501 /* Make sure all the element of the constructor were used. Otherwise,
7502 issue an error about exceeding initializers. */
7504 {
7508 }
7519 }
7521 /* Verify array initializer. Returns true if errors have been reported. */
7523 bool
7525 {
7528 /* Structured binding when initialized with an array type needs
7529 to have complete type. */
7534 {
7539 }
7541 /* The array type itself need not be complete, because the
7542 initializer may tell us how many elements are in the array.
7543 But, the elements of the array must be complete. */
7545 {
7549 else
7552 }
7558 /* A compound literal can't have variable size. */
7562 {
7565 }
7567 }
7569 /* Subroutine of check_initializer; args are passed down from that function.
7570 Set stmts_are_full_exprs_p to 1 across a call to build_aggr_init. */
7572 static tree
7574 {
7579 }
7581 /* Verify INIT (the initializer for DECL), and record the
7582 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
7583 grok_reference_init.
7585 If the return value is non-NULL, it is an expression that must be
7586 evaluated dynamically to initialize DECL. */
7588 static tree
7590 {
7591 tree type;
7593 tree core_type;
7595 /* Things that are going to be initialized need to have complete
7596 type. */
7600 {
7601 /* A variable with DECL_HAS_VALUE_EXPR_P set is just a placeholder,
7602 it doesn't have storage to be initialized. */
7605 }
7608 /* We will have already complained. */
7612 {
7615 }
7617 {
7622 }
7623 else
7624 /* There is no way to make a variable-sized class type in GNU C++. */
7628 {
7631 {
7633 {
7636 }
7638 {
7640 "scalar object %qD requires one element in "
7644 }
7645 }
7646 }
7649 {
7656 }
7658 ;
7661 {
7663 {
7666 }
7669 tf_warning_or_error);
7670 /* Do not reshape constructors of vectors (they don't need to be
7671 reshaped. */
7673 {
7675 {
7677 tf_warning_or_error);
7679 }
7681 {
7682 /* Don't reshape if the class has constructors. */
7685 "in C++98 %qD must be initialized by "
7687 decl);
7688 }
7690 {
7693 }
7694 else
7695 {
7698 }
7699 }
7700 /* [dcl.init] "Otherwise, if the destination type is an array, the object
7701 is initialized as follows..." So handle things like
7703 int a[](1, 2, 3);
7705 which is permitted in C++20 by P0960. */
7715 {
7718 /* We get here with code like `int a (2);' */
7720 tf_warning_or_error);
7721 }
7723 /* If DECL has an array type without a specific bound, deduce the
7724 array size from the initializer. */
7735 /* The call to build_aggr_init below could end up
7736 calling build_vec_init, which may break when we
7737 are processing a template. */
7738 || processing_template_decl
7742 {
7745 /* A constructor call is a non-trivial initializer even if
7746 it isn't explicitly written. */
7750 /* If this is a constexpr initializer, expand_default_init will
7751 have returned an INIT_EXPR rather than a CALL_EXPR. In that
7752 case, pull the initializer back out and pass it down into
7753 store_init_value. */
7755 {
7762 else
7764 }
7766 {
7767 /* In C++20, the call to build_aggr_init could have created
7768 an INIT_EXPR with a CONSTRUCTOR as the RHS to handle
7769 A(1, 2). */
7772 /* Avoid leaking TARGET_EXPR into template trees. */
7777 /* Don't call digest_init; it's unnecessary and will complain
7778 about aggregate initialization of non-aggregate classes. */
7780 }
7783 {
7784 /* Declared constexpr or constinit, but no suitable initializer;
7785 massage init appropriately so we can pass it into
7786 store_init_value for the error. */
7796 {
7801 }
7803 }
7804 else
7806 }
7809 {
7815 {
7820 }
7832 }
7833 }
7834 else
7835 {
7843 tf_warning_or_error);
7844 }
7854 {
7855 /* We might have set these in cp_finish_decl. */
7858 }
7863 {
7871 else
7875 {
7879 }
7881 }
7884 }
7886 /* If DECL is not a local variable, give it RTL. */
7888 static void
7890 {
7894 /* Set the DECL_ASSEMBLER_NAME for the object. */
7896 {
7897 /* The `register' keyword, when used together with an
7898 asm-specification, indicates that the variable should be
7899 placed in a particular register. */
7901 {
7904 }
7905 else
7906 {
7913 /* We have to propagate the name to the ns-alias.
7914 This is horrible, as we're affecting a
7915 possibly-shared decl. Again, a one-true-decl
7916 model breaks down. */
7919 }
7920 }
7922 /* Handle non-variables up front. */
7924 {
7927 }
7929 /* If we see a class member here, it should be a static data
7930 member. */
7932 {
7934 /* An in-class declaration of a static data member should be
7935 external; it is only a declaration, and not a definition. */
7939 }
7941 /* We don't create any RTL for local variables. */
7945 /* We defer emission of local statics until the corresponding
7946 DECL_EXPR is expanded. But with constexpr its function might never
7947 be expanded, so go ahead and tell cgraph about the variable now. */
7952 /* Defer template instantiations. */
7957 /* If we're not deferring, go ahead and assemble the variable. */
7960 }
7962 /* walk_tree helper for wrap_temporary_cleanups, below. */
7964 static tree
7966 {
7967 /* Stop at types or full-expression boundaries. */
7970 {
7973 }
7976 {
7982 {
7984 /* Tell honor_protect_cleanup_actions to handle this as a separate
7985 cleanup. */
7988 }
7989 }
7992 }
7994 /* We're initializing a local variable which has a cleanup GUARD. If there
7995 are any temporaries used in the initializer INIT of this variable, we
7996 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
7997 variable will be cleaned up properly if one of them throws.
7999 Unfortunately, there's no way to express this properly in terms of
8000 nesting, as the regions for the temporaries overlap the region for the
8001 variable itself; if there are two temporaries, the variable needs to be
8002 the first thing destroyed if either of them throws. However, we only
8003 want to run the variable's cleanup if it actually got constructed. So
8004 we need to guard the temporary cleanups with the variable's cleanup if
8005 they are run on the normal path, but not if they are run on the
8006 exceptional path. We implement this by telling
8007 honor_protect_cleanup_actions to strip the variable cleanup from the
8008 exceptional path.
8010 Another approach could be to make the variable cleanup region enclose
8011 initialization, but depend on a flag to indicate that the variable is
8012 initialized; that's effectively what we do for arrays. But the current
8013 approach works fine for non-arrays, and has no code overhead in the usual
8014 case where the temporary destructors are noexcept. */
8016 static void
8018 {
8020 {
8021 /* An array cleanup region already encloses any temporary cleanups,
8022 don't wrap it around them again. */
8025 }
8027 }
8029 /* Generate code to initialize DECL (a local variable). */
8031 static void
8033 {
8035 tree cleanup;
8043 {
8044 /* If we used it already as memory, it must stay in memory. */
8048 }
8053 /* Compute and store the initial value. */
8058 /* Generate a cleanup, if necessary. */
8061 /* Perform the initialization. */
8063 {
8068 {
8069 /* Stick simple initializers in DECL_INITIAL so that
8070 -Wno-init-self works (c++/34772). */
8074 {
8078 OPT_Winit_self,
8080 }
8081 }
8082 else
8083 {
8086 /* If we're only initializing a single object, guard the
8087 destructors of any temporaries used in its initializer with
8088 its destructor. */
8097 saved_stmts_are_full_exprs_p;
8098 }
8099 }
8101 /* Set this to 0 so we can tell whether an aggregate which was
8102 initialized was ever used. Don't do this if it has a
8103 destructor, so we don't complain about the 'resource
8104 allocation is initialization' idiom. Now set
8105 attribute((unused)) on types so decls of that type will be
8106 marked used. (see TREE_USED, above.) */
8108 && ! already_used
8117 }
8119 /* DECL is a VAR_DECL for a compiler-generated variable with static
8120 storage duration (like a virtual table) whose initializer is a
8121 compile-time constant. Initialize the variable and provide it to the
8122 back end. */
8124 void
8126 {
8127 tree init;
8133 /* Mark the decl as constexpr so that we can access its content
8134 at compile time. */
8141 }
8143 /* INIT is the initializer for a variable, as represented by the
8144 parser. Returns true iff INIT is value-dependent. */
8146 static bool
8148 {
8150 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
8153 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
8154 {
8167 }
8168 else
8169 /* It must be a simple expression, e.g., int i = 3; */
8173 }
8175 // Returns true if a DECL is VAR_DECL with the concept specifier.
8178 {
8180 // Not all variables have DECL_LANG_SPECIFIC.
8183 }
8185 /* A helper function to be called via walk_tree. If any label exists
8186 under *TP, it is (going to be) forced. Set has_forced_label_in_static. */
8188 static tree
8190 {
8196 }
8198 /* Return true if DECL has either a trivial destructor, or for C++20
8199 is constexpr and has a constexpr destructor. */
8201 static bool
8203 {
8209 }
8213 /* Helper function of omp_declare_variant_finalize. Finalize one
8214 "omp declare variant base" attribute. Return true if it should be
8215 removed. */
8217 static bool
8219 {
8221 {
8226 }
8230 OMP_TRAIT_CONSTRUCT_SIMD);
8232 {
8236 /* FIXME, adjusting simd args unimplemented. */
8238 }
8241 location_t varid_loc
8250 releasing_vec args;
8259 else
8264 {
8266 /* In C++20, we may need to perform ADL for a template
8267 name. */
8270 {
8272 {
8276 tf_warning_or_error);
8277 }
8278 else
8280 }
8282 {
8288 {
8292 tf_warning_or_error);
8293 }
8294 }
8295 }
8300 else
8310 {
8313 {
8317 }
8322 {
8325 }
8326 else
8327 {
8328 tree construct
8334 }
8335 }
8337 {
8340 }
8343 }
8345 /* Helper function, finish up "omp declare variant base" attribute
8346 now that there is a DECL. ATTR is the first "omp declare variant base"
8347 attribute. */
8349 void
8351 {
8361 {
8364 }
8366 {
8369 }
8371 {
8374 }
8376 {
8379 }
8381 {
8384 }
8385 /* This loop is like private_lookup_attribute, except that it works
8386 with tree * rather than tree, as we might want to remove the
8387 attributes that are diagnosed as errorneous. */
8389 {
8394 {
8396 {
8399 }
8400 }
8402 }
8403 }
8407 /* Finish processing of a declaration;
8408 install its line number and initial value.
8409 If the length of an array type is not known before,
8410 it must be determined now, from the initial value, or it is an error.
8412 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
8413 true, then INIT is an integral constant expression.
8415 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
8416 if the (init) syntax was used.
8418 DECOMP is first identifier's DECL and identifier count in a structured
8419 bindings, nullptr if not a structured binding. */
8421 void
8424 {
8429 tree auto_node;
8434 {
8438 }
8441 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
8451 /* Warn about register storage specifiers except when in GNU global
8452 or local register variable extension. */
8454 {
8457 "ISO C++17 does not allow %<register%> storage "
8459 else
8462 }
8464 /* If a name was specified, get the string. */
8470 bool in_class_decl
8471 = (current_class_type
8482 {
8483 tree d_init;
8485 {
8489 {
8490 /* init is null because we're deferring instantiating the
8491 initializer until we need it. Well, we need it now. */
8494 }
8498 else
8499 {
8500 /* Ordinary auto deduction without an initializer, a situation
8501 which grokdeclarator already detects and rejects for the most
8502 part. But we can still get here if we're instantiating a
8503 variable template before we've fully parsed (and attached) its
8504 initializer, e.g. template<class> auto x = x<int>; */
8509 }
8510 }
8513 {
8517 tf_warning_or_error);
8519 /* Force auto deduction now. Use tf_none to avoid redundant warnings
8520 on deprecated-14.C. */
8522 }
8531 /* The outer template arguments might be needed for satisfaction.
8532 (For function scope variables, do_auto_deduction will obtain the
8533 outer template arguments from current_function_decl.) */
8541 {
8546 }
8547 /* As in start_decl_1, complete so TREE_READONLY is set properly. */
8551 {
8557 }
8560 /* Update the type of the corresponding TEMPLATE_DECL to match. */
8565 }
8568 {
8571 {
8574 }
8575 }
8585 {
8587 ? TCTX_THREAD_STORAGE
8590 }
8593 {
8594 tree clone;
8596 {
8597 /* FIXME check this is 1st decl. */
8602 {
8606 }
8608 }
8610 {
8613 else
8615 }
8616 }
8619 {
8621 /* If DECL is a reference, then we want to know whether init is a
8622 reference constant; init_const_expr_p as passed tells us whether
8623 it's an rvalue constant. */
8627 {
8628 /* Set these flags now for templates. We'll update the flags in
8629 store_init_value for instantiations. */
8632 /* FIXME setting TREE_CONSTANT on refs breaks the back end. */
8635 }
8636 /* This is handled mostly by gimplify.cc, but we have to deal with
8637 not warning about int x = x; as it is a GCC extension to turn off
8638 this warning but only if warn_init_self is zero. */
8644 }
8650 /* We have no initializer but there's nothing to initialize anyway.
8651 Treat DECL as constant due to c++/109876. */
8656 /* #pragma omp declare variant on methods handled in finish_struct
8657 instead. */
8665 {
8668 /* Add this declaration to the statement-tree. */
8675 {
8678 }
8680 /* Generally, initializers in templates are expanded when the
8681 template is instantiated. But, if DECL is a variable constant
8682 then it can be used in future constant expressions, so its value
8683 must be available. */
8690 {
8693 }
8699 {
8700 /* This variable seems to be a non-dependent constant, so process
8701 its initializer. If check_initializer returns non-null the
8702 initialization wasn't constant after all. */
8703 tree init_code;
8709 }
8710 else
8711 {
8713 /* Try to deduce array size. */
8715 /* And complain about multiple initializers. */
8719 tf_warning_or_error);
8720 }
8726 {
8729 }
8732 {
8735 }
8737 }
8739 /* Just store non-static data member initializers for later. */
8743 /* Take care of TYPE_DECLs up front. */
8745 {
8748 {
8752 }
8754 /* If we have installed this as the canonical typedef for this
8755 type, and that type has not been defined yet, delay emitting
8756 the debug information for it, as we will emit it later. */
8762 at_eof);
8764 }
8766 /* A reference will be modified here, as it is initialized. */
8770 {
8773 }
8775 /* This needs to happen before extend_ref_init_temps. */
8777 {
8781 }
8784 {
8786 /* [dcl.constinit]/1 "The constinit specifier shall be applied
8787 only to a declaration of a variable with static or thread storage
8788 duration." */
8791 {
8793 "%<constinit%> can only be applied to a variable with "
8796 }
8801 /* If this is a local variable that will need a mangled name,
8802 register it now. We must do this before processing the
8803 initializer for the variable, since the initialization might
8804 require a guard variable, and since the mangled name of the
8805 guard variable will depend on the mangled name of this
8806 variable. */
8810 {
8811 /* The variable holding an anonymous union will have had its
8812 discriminator set in finish_anon_union, after which it's
8813 NAME will have been cleared. */
8816 /* Normally has_forced_label_in_static is set during GIMPLE
8817 lowering, but [cd]tors are never actually compiled directly.
8818 We need to set this early so we can deal with the label
8819 address extension. */
8823 {
8826 }
8827 /* And make sure it's in the symbol table for
8828 c_parse_final_cleanups to find. */
8830 }
8832 /* Convert the initializer to the type of DECL, if we have not
8833 already initialized DECL. */
8835 /* If !DECL_EXTERNAL then DECL is being defined. In the
8836 case of a static data member initialized inside the
8837 class-specifier, there can be an initializer even if DECL
8838 is *not* defined. */
8840 {
8844 /* Handle:
8846 [dcl.init]
8848 The memory occupied by any object of static storage
8849 duration is zero-initialized at program startup before
8850 any other initialization takes place.
8852 We cannot create an appropriate initializer until after
8853 the type of DECL is finalized. If DECL_INITIAL is set,
8854 then the DECL is statically initialized, and any
8855 necessary zero-initialization has already been performed. */
8860 /* Remember that the initialization for this variable has
8861 taken place. */
8863 /* This declaration is the definition of this variable,
8864 unless we are initializing a static data member within
8865 the class specifier. */
8868 }
8869 /* If the variable has an array type, lay out the type, even if
8870 there is no initializer. It is valid to index through the
8871 array, and we must get TYPE_ALIGN set correctly on the array
8872 type. */
8879 /* So decl is a global variable or a static member of a
8880 non local class. Record the types it uses
8881 so that we can decide later to emit debug info for them. */
8883 }
8885 /* Add this declaration to the statement-tree. This needs to happen
8886 after the call to check_initializer so that the DECL_EXPR for a
8887 reference temp is added before the DECL_EXPR for the reference itself. */
8889 {
8890 /* If we're building a variable sized type, and we might be
8891 reachable other than via the top of the current binding
8892 level, then create a new BIND_EXPR so that we deallocate
8893 the object at the right time. */
8898 {
8899 tree bind;
8904 }
8906 }
8908 /* Let the middle end know about variables and functions -- but not
8909 static data members in uninstantiated class templates. */
8911 {
8913 {
8916 /* Check again now that we have an initializer. */
8918 /* A class-scope constexpr variable with an out-of-class declaration.
8919 C++17 makes them implicitly inline, but still force it out. */
8925 }
8928 /* With -fmerge-all-constants, gimplify_init_constructor
8929 might add TREE_STATIC to aggregate variables. */
8933 {
8934 /* If a TREE_READONLY variable needs initialization
8935 at runtime, it is no longer readonly and we need to
8936 avoid MEM_READONLY_P being set on RTL created for it. */
8938 {
8942 }
8946 /* Likewise if it needs destruction. */
8949 }
8955 {
8956 /* TLS variables need dynamic initialization by the TLS wrapper
8957 function, we don't want to hoist accesses to it before the
8958 wrapper. */
8961 }
8965 /* Check for abstractness of the type. */
8970 /* No initialization required. */
8971 ;
8973 {
8975 {
8977 {
8978 /* An out-of-class default definition is defined at
8979 the point where it is explicitly defaulted. */
8984 }
8985 else
8989 decl);
8990 }
8991 /* else no initialization required. */
8992 }
8996 {
8997 /* check_initializer will have done any constant initialization. */
8998 }
8999 /* A variable definition. */
9001 /* Initialize the local variable. */
9004 /* If a variable is defined, and then a subsequent
9005 definition with external linkage is encountered, we will
9006 get here twice for the same variable. We want to avoid
9007 calling expand_static_init more than once. For variables
9008 that are not static data members, we can call
9009 expand_static_init only when we actually process the
9010 initializer. It is not legal to redeclare a static data
9011 member, so this issue does not arise in that case. */
9014 }
9016 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
9017 reference, insert it in the statement-tree now. */
9019 {
9021 {
9023 /* As in initialize_local_var. */
9025 }
9027 }
9036 {
9042 {
9048 }
9053 {
9059 {
9062 {
9066 }
9067 }
9068 }
9069 }
9071 /* This is the last point we can lower alignment so give the target the
9072 chance to do so. */
9079 }
9081 /* For class TYPE return itself or some its bases that contain
9082 any direct non-static data members. Return error_mark_node if an
9083 error has been diagnosed. */
9085 static tree
9087 {
9097 {
9101 else
9106 }
9108 {
9116 }
9117 else
9127 {
9132 {
9134 {
9139 }
9143 {
9145 "classes %qT and %qT have non-static data "
9148 }
9149 else
9151 }
9152 }
9154 }
9156 /* Return std::tuple_size<TYPE>::value. */
9158 static tree
9160 {
9180 else
9182 }
9184 /* Return std::tuple_element<I,TYPE>::type. */
9186 static tree
9188 {
9196 tf_warning_or_error);
9199 }
9201 /* Return e.get<i>() or get<i>(e). */
9203 static tree
9205 {
9212 /* [The id-expression] e is an lvalue if the type of the entity e is an
9213 lvalue reference and an xvalue otherwise. */
9222 /* To use a member get, member lookup must find at least one
9223 declaration that is a function template
9224 whose first template parameter is a non-type parameter. */
9226 {
9229 {
9233 {
9236 }
9237 }
9238 }
9241 {
9246 }
9247 else
9248 {
9254 }
9255 }
9257 /* It's impossible to recover the decltype of a tuple decomposition variable
9258 based on the actual type of the variable, so store it in a hash table. */
9262 tree
9264 {
9266 }
9268 /* Mangle a decomposition declaration if needed. Arguments like
9269 in cp_finish_decomp. */
9271 static void
9273 {
9277 {
9284 {
9293 {
9298 }
9301 }
9304 }
9305 }
9307 /* Finish a decomposition declaration. DECL is the underlying declaration
9308 "e", FIRST is the head of a chain of decls for the individual identifiers
9309 chained through DECL_CHAIN in reverse order and COUNT is the number of
9310 those decls. */
9312 void
9314 {
9318 {
9319 error_out:
9321 {
9324 {
9327 }
9329 }
9333 }
9337 /* This happens for range for when not in templates.
9338 Still add the DECL_VALUE_EXPRs for later processing. */
9339 || (!processing_template_decl
9341 {
9343 {
9345 {
9351 }
9355 }
9357 }
9363 {
9366 }
9372 {
9378 {
9380 type);
9382 }
9383 }
9388 {
9389 tree nelts;
9394 {
9397 }
9400 {
9401 cnt_mismatch:
9406 else
9415 }
9418 {
9427 }
9428 }
9429 /* 2 GNU extensions. */
9431 {
9437 {
9446 }
9447 }
9449 {
9451 {
9454 }
9459 {
9470 }
9471 }
9473 {
9475 {
9479 }
9481 {
9488 }
9494 {
9505 {
9509 }
9511 {
9515 }
9516 /* Save the decltype away before reference collapse. */
9522 {
9523 /* In this case the names are variables, not just proxies. */
9526 }
9528 {
9532 }
9533 }
9534 /* Ignore reads from the underlying decl performed during initialization
9535 of the individual variables. If those will be read, we'll mark
9536 the underlying decl as read at that point. */
9538 }
9540 {
9543 }
9545 {
9548 }
9550 {
9553 }
9558 type);
9559 else
9560 {
9565 {
9569 }
9575 else
9576 eltscnt++;
9581 {
9585 }
9592 else
9593 {
9595 NULL_TREE);
9601 {
9604 }
9605 i++;
9606 }
9607 }
9609 {
9612 {
9617 }
9618 }
9619 }
9621 /* Returns a declaration for a VAR_DECL as if:
9623 extern "C" TYPE NAME;
9625 had been seen. Used to create compiler-generated global
9626 variables. */
9628 static tree
9630 {
9637 /* If the user has explicitly declared this variable (perhaps
9638 because the code we are compiling is part of a low-level runtime
9639 library), then it is possible that our declaration will be merged
9640 with theirs by pushdecl. */
9646 }
9648 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
9649 if "__cxa_atexit" is not being used) corresponding to the function
9650 to be called when the program exits. */
9652 static tree
9654 {
9655 tree fn_type;
9658 {
9659 tree arg_type;
9662 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
9664 else
9665 /* The parameter to "atexit" is "void (*)(void)". */
9671 }
9674 }
9676 /* Returns a pointer to the `atexit' function. Note that if
9677 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
9678 `__cxa_atexit' function specified in the IA64 C++ ABI. */
9680 static tree
9682 {
9683 tree atexit_fndecl;
9684 tree fn_type;
9685 tree fn_ptr_type;
9694 {
9695 /* The declaration for `__cxa_atexit' is:
9697 int __cxa_atexit (void (*)(void *), void *, void *)
9699 We build up the argument types and then the function type
9700 itself. */
9704 /* First, build the pointer-to-function type for the first
9705 argument. */
9707 /* Then, build the rest of the argument types. */
9710 {
9713 }
9714 else
9715 {
9718 }
9719 /* And the final __cxa_atexit type. */
9722 NULL_TREE);
9723 /* ... which needs noexcept. */
9726 {
9734 }
9735 else
9736 {
9739 }
9740 }
9741 else
9742 {
9743 /* The declaration for `atexit' is:
9745 int atexit (void (*)());
9747 We build up the argument types and then the function type
9748 itself. */
9750 /* Build the final atexit type. */
9753 /* ... which needs noexcept. */
9756 }
9758 /* Now, build the function declaration. */
9763 /* Install as hidden builtin so we're (a) more relaxed about
9764 exception spec matching and (b) will not give a confusing location
9765 in diagnostic and (c) won't magically appear in user-visible name
9766 lookups. */
9775 }
9777 /* Like get_atexit_node, but for thread-local cleanups. */
9779 static tree
9781 {
9785 /* The declaration for `__cxa_thread_atexit' is:
9787 int __cxa_thread_atexit (void (*)(void *), void *, void *) */
9791 NULL_TREE);
9793 /* Now, build the function declaration, as with __cxa_atexit. */
9805 }
9807 /* Returns the __dso_handle VAR_DECL. */
9809 static tree
9811 {
9815 /* Declare the variable. */
9817 ptr_type_node);
9819 #ifdef HAVE_GAS_HIDDEN
9821 {
9824 }
9825 #endif
9828 }
9830 /* Begin a new function with internal linkage whose job will be simply
9831 to destroy some particular variable. */
9835 static tree
9837 {
9842 /* No need to mangle this. */
9845 /* Build the name of the function. */
9847 /* Build the function declaration. */
9851 /* It's a function with internal linkage, generated by the
9852 compiler. */
9855 /* Make the function `inline' so that it is only emitted if it is
9856 actually needed. It is unlikely that it will be inlined, since
9857 it is only called via a function pointer, but we avoid unnecessary
9858 emissions this way. */
9862 {
9863 /* Build the parameter. */
9868 }
9876 }
9878 /* Finish the cleanup function begun by start_cleanup_fn. */
9880 static void
9882 {
9886 }
9888 /* Generate code to handle the destruction of DECL, an object with
9889 static storage duration. */
9891 tree
9893 {
9894 tree cleanup;
9895 tree addr;
9896 tree compound_stmt;
9897 tree fcall;
9898 tree type;
9901 tree atex_node;
9909 {
9912 }
9914 /* If we're using "__cxa_atexit" (or "__cxa_thread_atexit" or
9915 "__aeabi_atexit"), and DECL is a class object, we can just pass the
9916 destructor to "__cxa_atexit"; we don't have to build a temporary
9917 function to do the cleanup. */
9918 dso_parm = (flag_use_cxa_atexit
9923 {
9926 /* Make sure it is accessible. */
9928 tf_warning_or_error);
9929 }
9930 else
9931 {
9932 /* Call build_cleanup before we enter the anonymous function so
9933 that any access checks will be done relative to the current
9934 scope, rather than the scope of the anonymous function. */
9937 /* Now start the function. */
9940 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
9941 to the original function, rather than the anonymous one. That
9942 will make the back end think that nested functions are in use,
9943 which causes confusion. */
9948 /* Create the body of the anonymous function. */
9953 }
9955 /* Call atexit with the cleanup function. */
9961 else
9965 {
9966 /* We must convert CLEANUP to the type that "__cxa_atexit"
9967 expects. */
9969 /* "__cxa_atexit" will pass the address of DECL to the
9970 cleanup function. */
9973 /* The declared type of the parameter to "__cxa_atexit" is
9974 "void *". For plain "T*", we could just let the
9975 machinery in cp_build_function_call convert it -- but if the
9976 type is "cv-qualified T *", then we need to convert it
9977 before passing it in, to avoid spurious errors. */
9979 }
9980 else
9981 /* Since the cleanup functions we build ignore the address
9982 they're given, there's no reason to pass the actual address
9983 in, and, in general, it's cheaper to pass NULL than any
9984 other value. */
9989 tf_warning_or_error);
9991 /* Just pass NULL to the dso handle parm if we don't actually
9992 have a DSO handle on this target. */
9994 else
9998 {
10001 {
10004 }
10005 else
10006 {
10009 }
10010 }
10011 else
10012 {
10015 }
10018 }
10020 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
10021 is its initializer. Generate code to handle the construction
10022 and destruction of DECL. */
10024 static void
10026 {
10030 /* Some variables require no dynamic initialization. */
10032 {
10033 /* Make sure the destructor is callable. */
10037 }
10041 {
10046 else
10051 {
10055 }
10057 }
10060 {
10061 /* Emit code to perform this initialization but once. */
10066 /* We don't need thread-safety code for thread-local vars. */
10070 /* Emit code to perform this initialization but once. This code
10071 looks like:
10073 static <type> guard;
10074 if (!__atomic_load (guard.first_byte)) {
10075 if (__cxa_guard_acquire (&guard)) {
10076 bool flag = false;
10077 try {
10078 // Do initialization.
10079 flag = true; __cxa_guard_release (&guard);
10080 // Register variable for destruction at end of program.
10081 } catch {
10082 if (!flag) __cxa_guard_abort (&guard);
10083 }
10084 }
10085 }
10087 Note that the `flag' variable is only set to 1 *after* the
10088 initialization is complete. This ensures that an exception,
10089 thrown during the construction, will cause the variable to
10090 reinitialized when we pass through this code again, as per:
10092 [stmt.dcl]
10094 If the initialization exits by throwing an exception, the
10095 initialization is not complete, so it will be tried again
10096 the next time control enters the declaration.
10098 This process should be thread-safe, too; multiple threads
10099 should not be able to initialize the variable more than
10100 once. */
10102 /* Create the guard variable. */
10105 /* Begin the conditional initialization. */
10112 {
10125 acquire_fn = push_library_fn
10128 NULL_TREE),
10133 NULL_TREE);
10136 ECF_NOTHROW);
10143 inner_if_stmt);
10151 void_node,
10155 /* Do the initialization itself. */
10161 /* Use atexit to register a function for destroying this static
10162 variable. Do this before calling __cxa_guard_release. */
10166 guard_addr));
10167 }
10168 else
10169 {
10172 /* Use atexit to register a function for destroying this static
10173 variable. */
10175 }
10180 {
10184 }
10189 }
10192 else
10194 }
10196 \f
10197 /* Make TYPE a complete type based on INITIAL_VALUE.
10198 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
10199 2 if there was no information (in which case assume 0 if DO_DEFAULT),
10200 3 if the initializer list is empty (in pedantic mode). */
10202 int
10204 {
10208 /* Don't get confused by a CONSTRUCTOR for some other type. */
10215 {
10216 /* An array of character type can be initialized from a
10217 brace-enclosed string constant so call reshape_init to
10218 remove the optional braces from a braced string literal. */
10222 tf_warning_or_error);
10224 /* If any of the elements are parameter packs, we can't actually
10225 complete this type now because the array size is dependent. */
10230 }
10234 /* We can create the array before the element type is complete, which
10235 means that we didn't have these two bits set in the original type
10236 either. In completing the type, we are expected to propagate these
10237 bits. See also complete_type which does the same thing for arrays
10238 of fixed size. */
10241 {
10246 }
10249 }
10251 /* As above, but either give an error or reject zero-size arrays, depending
10252 on COMPLAIN. */
10254 int
10257 {
10260 /* In SFINAE context we can't be lenient about zero-size arrays. */
10267 {
10273 {
10276 }
10280 }
10282 }
10283 \f
10284 /* Return zero if something is declared to be a member of type
10285 CTYPE when in the context of CUR_TYPE. STRING is the error
10286 message to print in that case. Otherwise, quietly return 1. */
10288 static int
10290 {
10292 {
10295 else
10298 }
10300 }
10301 \f
10302 /* Subroutine of `grokdeclarator'. */
10304 /* Generate errors possibly applicable for a given set of specifiers.
10305 This is for ARM $7.1.2. */
10307 static void
10316 {
10318 {
10362 }
10366 && !flag_noexcept_type
10372 }
10374 /* DECL is a member function or static data member and is presently
10375 being defined. Check that the definition is taking place in a
10376 valid namespace. */
10378 static void
10380 {
10381 /* These checks only apply to member functions and static data
10382 members. */
10384 /* We check for problems with specializations in pt.cc in
10385 check_specialization_namespace, where we can issue better
10386 diagnostics. */
10389 /* We check this in check_explicit_instantiation_namespace. */
10392 /* [class.mfct]
10394 A member function definition that appears outside of the
10395 class definition shall appear in a namespace scope enclosing
10396 the class definition.
10398 [class.static.data]
10400 The definition for a static data member shall appear in a
10401 namespace scope enclosing the member's class definition. */
10405 }
10407 /* Build a PARM_DECL for the "this" parameter of FN. TYPE is the
10408 METHOD_TYPE for a non-static member function; QUALS are the
10409 cv-qualifiers that apply to the function. */
10411 tree
10413 {
10414 tree this_type;
10415 tree qual_type;
10416 tree parm;
10417 cp_cv_quals this_quals;
10420 {
10421 this_type
10424 }
10425 else
10427 /* The `this' parameter is implicitly `const'; it cannot be
10428 assigned to. */
10434 }
10436 /* DECL is a static member function. Complain if it was declared
10437 with function-cv-quals. */
10439 static void
10441 {
10444 decl);
10445 }
10447 // Check that FN takes no arguments and returns bool.
10448 static void
10450 {
10451 // A constraint is nullary.
10456 // The declared return type of the concept shall be bool, and
10457 // it shall not be deduced from it definition.
10465 }
10467 /* Helper function. Replace the temporary this parameter injected
10468 during cp_finish_omp_declare_simd with the real this parameter. */
10470 static tree
10472 {
10481 }
10483 /* CTYPE is class type, or null if non-class.
10484 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
10485 or METHOD_TYPE.
10486 DECLARATOR is the function's name.
10487 PARMS is a chain of PARM_DECLs for the function.
10488 VIRTUALP is truthvalue of whether the function is virtual or not.
10489 FLAGS are to be passed through to `grokclassfn'.
10490 QUALS are qualifiers indicating whether the function is `const'
10491 or `volatile'.
10492 RAISES is a list of exceptions that this function can raise.
10493 CHECK is 1 if we must find this method in CTYPE, 0 if we should
10494 not look, and -1 if we should not call `grokclassfn' at all.
10496 SFK is the kind of special function (if any) for the new function.
10498 Returns `NULL_TREE' if something goes wrong, after issuing
10499 applicable error messages. */
10501 static tree
10503 tree type,
10504 tree declarator,
10505 tree parms,
10506 tree orig_declarator,
10508 tree decl_reqs,
10511 cp_cv_quals quals,
10512 cp_ref_qualifier rqual,
10513 tree raises,
10520 special_function_kind sfk,
10524 tree in_namespace,
10526 location_t location)
10527 {
10528 tree decl;
10529 tree t;
10534 /* Was the concept specifier present? */
10537 /* Concept declarations must have a corresponding definition. */
10539 {
10542 }
10548 /* Set the constraints on the declaration. */
10550 {
10555 && (current_template_depth
10558 {
10560 /* If there are no template parameters, something must have
10561 gone wrong. */
10563 else
10565 }
10568 {
10571 }
10572 /* C++20 CA378: Remove non-templated constrained functions. */
10573 /* [temp.friend]/9 A non-template friend declaration with a
10574 requires-clause shall be a definition. A friend function template with
10575 a constraint that depends on a template parameter from an enclosing
10576 template shall be a definition. */
10578 && (block_local
10579 || (!flag_concepts_ts
10580 && (!processing_template_decl
10582 {
10585 else
10589 }
10595 }
10598 {
10603 /* Allocate space to hold the vptr bit if needed. */
10605 }
10611 /* Propagate volatile out from type to decl. */
10615 /* Setup decl according to sfk. */
10617 {
10629 /* Give deduction guides a definition even though they don't really
10630 have one: the restriction that you can't repeat a deduction guide
10631 makes them more like a definition anyway. */
10636 }
10639 {
10643 orig_declarator);
10644 else
10645 {
10650 {
10651 /* Something like `template <class T> friend void f<T>()'. */
10653 "invalid use of template-id %qD in declaration "
10655 orig_declarator);
10657 }
10659 /* A friend declaration of the form friend void f<>(). Record
10660 the information in the TEMPLATE_ID_EXPR. */
10669 {
10671 "default arguments are not allowed in declaration "
10673 decl);
10675 }
10678 {
10680 "%<inline%> is not allowed in declaration of friend "
10682 decl);
10684 }
10685 }
10686 }
10688 /* C++17 11.3.6/4: "If a friend declaration specifies a default argument
10689 expression, that declaration shall be a definition..." */
10691 {
10695 {
10697 "friend declaration of %qD specifies default "
10700 }
10701 }
10703 /* If this decl has namespace scope, set that up. */
10708 else
10711 /* `main' and builtins have implicit 'C' linkage. */
10737 {
10753 }
10755 /* Members of anonymous types and local classes have no linkage; make
10756 them internal. If a typedef is made later, this will be changed. */
10762 {
10763 /* [basic.link]: A name with no linkage (notably, the name of a class
10764 or enumeration declared in a local scope) shall not be used to
10765 declare an entity with linkage.
10767 DR 757 relaxes this restriction for C++0x. */
10769 }
10773 {
10776 }
10778 /* If the declaration was declared inline, mark it as such. */
10780 {
10784 }
10788 {
10791 }
10793 // If the concept declaration specifier was found, check
10794 // that the declaration satisfies the necessary requirements.
10796 {
10799 }
10803 {
10806 TYPE_UNQUALIFIED,
10807 REF_QUAL_NONE);
10808 auto_diagnostic_group d;
10812 : !xobj_func_p
10816 decl);
10820 : !xobj_func_p
10824 decl);
10832 }
10835 {
10839 {
10844 }
10847 {
10851 }
10855 }
10860 {
10864 /* [over.literal]/6: Literal operators shall not have C linkage. */
10866 {
10870 }
10873 {
10876 {
10879 }
10883 {
10887 }
10889 {
10893 }
10894 /* 17.6.3.3.5 */
10898 "literal operator suffixes not preceded by %<_%>"
10900 }
10901 else
10902 {
10905 }
10906 }
10909 /* Make the init_value nonzero so pushdecl knows this is not
10910 tentative. error_mark_node is replaced later with the BLOCK. */
10917 {
10918 /* Adjust "omp declare simd" attributes. */
10921 {
10922 tree attr;
10925 {
10930 {
10932 cl = c_omp_declare_simd_clauses_to_numbers
10936 else
10938 }
10939 }
10940 }
10941 }
10943 /* Caller will do the rest of this. */
10950 /* 12.4/3 */
10960 template_count,
10972 {
10975 }
10980 /* Check main's type after attributes have been applied. */
10982 {
10984 integer_type_node))
10985 {
10987 tree newtype;
10992 }
10995 }
10998 {
11000 (current_template_depth
11002 ? current_template_parms
11009 {
11010 tree ok;
11011 tree pushed_scope;
11014 /* Because grokfndecl is always supposed to return a
11015 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
11016 here. We depend on our callers to figure out that its
11017 really a template that's being returned. */
11022 {
11023 /* Remove the `this' parm added by grokclassfn. */
11026 }
11028 {
11031 }
11033 {
11038 }
11040 /* Since we've smashed OLD_DECL to its
11041 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
11045 /* Attempt to merge the declarations. This can fail, in
11046 the case of some invalid specialization declarations. */
11052 {
11056 }
11060 }
11061 }
11073 }
11075 /* decl is a FUNCTION_DECL.
11076 specifiers are the parsed virt-specifiers.
11078 Set flags to reflect the virt-specifiers.
11080 Returns decl. */
11082 static tree
11084 {
11092 }
11094 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
11095 the linkage that DECL will receive in the object file. */
11097 static void
11099 {
11100 /* A static data member always has static storage duration and
11101 external linkage. Note that static data members are forbidden in
11102 local classes -- the only situation in which a class has
11103 non-external linkage. */
11106 /* For non-template classes, static data members are always put
11107 out in exactly those files where they are defined, just as
11108 with ordinary namespace-scope variables. */
11111 }
11113 /* Create a VAR_DECL named NAME with the indicated TYPE.
11115 If SCOPE is non-NULL, it is the class type or namespace containing
11116 the variable. If SCOPE is NULL, the variable should is created in
11117 the innermost enclosing scope. */
11119 static tree
11121 tree name,
11122 tree orig_declarator,
11129 tree scope,
11130 location_t location)
11131 {
11132 tree decl;
11133 tree explicit_scope;
11140 /* Compute the scope in which to place the variable, but remember
11141 whether or not that scope was explicitly specified by the user. */
11144 {
11145 /* An explicit "extern" specifier indicates a namespace-scope
11146 variable. */
11151 }
11155 template, we need DECL_LANG_SPECIFIC. */
11157 /* Similarly for namespace-scope variables with language linkage
11158 other than C++. */
11161 /* Similarly for static data members. */
11163 /* Similarly for explicit specializations. */
11164 || (orig_declarator
11167 else
11172 else
11176 {
11179 }
11182 {
11184 /* This function is only called with out-of-class definitions. */
11187 }
11188 /* At top level, either `static' or no s.c. makes a definition
11189 (perhaps tentative), and absence of `static' makes it public. */
11191 {
11194 || ! constp
11195 || volatilep
11196 || inlinep
11199 }
11200 /* Not at top level, only `static' makes a static definition. */
11201 else
11202 {
11205 }
11210 {
11212 {
11216 }
11219 }
11221 /* If the type of the decl has no linkage, make sure that we'll
11222 notice that in mark_used. */
11231 {
11232 /* [basic.link]: A name with no linkage (notably, the name of a class
11233 or enumeration declared in a local scope) shall not be used to
11234 declare an entity with linkage.
11236 DR 757 relaxes this restriction for C++0x. */
11239 }
11240 else
11249 /* Check that the variable can be safely declared as a concept.
11250 Note that this also forbids explicit specializations. */
11252 {
11254 {
11258 }
11260 {
11264 }
11265 else
11271 {
11274 }
11275 }
11278 {
11281 }
11283 // Handle explicit specializations and instantiations of variable templates.
11289 }
11291 /* Create and return a canonical pointer to member function type, for
11292 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
11294 tree
11296 {
11298 tree t;
11303 /* Make sure that we always have the unqualified pointer-to-member
11304 type first. */
11306 {
11309 }
11311 /* If a canonical type already exists for this type, use it. We use
11312 this method instead of type_hash_canon, because it only does a
11313 simple equality check on the list of field members. */
11321 /* Let the front end know this is a pointer to member function. */
11329 delta_type_node);
11336 /* Zap out the name so that the back end will give us the debugging
11337 information for this anonymous RECORD_TYPE. */
11340 /* Cache this pointer-to-member type so that we can find it again
11341 later. */
11350 }
11352 /* Create and return a pointer to data member type. */
11354 tree
11356 {
11358 {
11363 }
11364 else
11365 {
11368 }
11369 }
11371 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
11372 Check to see that the definition is valid. Issue appropriate error
11373 messages. */
11375 static void
11377 {
11378 /* Avoid redundant diagnostics on out-of-class definitions. */
11380 ;
11381 /* Can't check yet if we don't know the type. */
11383 ;
11384 /* If DECL is declared constexpr, we'll do the appropriate checks
11385 in check_initializer. Similarly for inline static data members. */
11389 ;
11391 {
11394 "in-class initialization of static data member %q#D of "
11398 "%<constexpr%> needed for in-class initialization of "
11400 else
11402 "in-class initialization of static data member %q#D of "
11404 }
11405 /* Motion 10 at San Diego: If a static const integral data member is
11406 initialized with an integral constant expression, the initializer
11407 may appear either in the declaration (within the class), or in
11408 the definition, but not both. If it appears in the class, the
11409 member is a member constant. The file-scope definition is always
11410 required. */
11413 "invalid in-class initialization of static data member "
11415 type);
11418 "ISO C++ forbids in-class initialization of non-const "
11420 decl);
11423 "ISO C++ forbids initialization of member constant "
11425 }
11427 /* *expr_p is part of the TYPE_SIZE of a variably-sized array. If any
11428 SAVE_EXPRs in *expr_p wrap expressions with side-effects, break those
11429 expressions out into temporary variables so that walk_tree doesn't
11430 step into them (c++/15764). */
11432 static tree
11434 {
11438 {
11444 }
11448 }
11450 /* Entry point for the above. */
11452 static void
11454 {
11456 /* Break out any function calls into temporary variables. */
11458 }
11460 /* Reduce a SIZEOF_EXPR to its value. */
11462 tree
11464 {
11465 tree r;
11474 else
11481 }
11483 /* Given the SIZE (i.e., number of elements) in an array, compute
11484 an appropriate index type for the array. If non-NULL, NAME is
11485 the name of the entity being declared. */
11487 static tree
11489 tsubst_flags_t complain)
11490 {
11494 /* The type of the index being computed. */
11495 tree itype;
11497 /* The original numeric size as seen in the source code before
11498 conversion to size_t. */
11504 {
11509 /* In C++98, we mark a non-constant array bound with a magic
11511 else
11512 {
11514 /* Pedantically a constant expression is required here and so
11515 __builtin_is_constant_evaluated () should fold to true if it
11516 is successfully folded into a constant. */
11522 }
11527 /* The array bound must be an integer type. */
11530 {
11536 else
11539 }
11540 }
11542 /* A type is dependent if it is...an array type constructed from any
11543 dependent type or whose size is specified by a constant expression
11544 that is value-dependent. */
11545 /* We can only call value_dependent_expression_p on integral constant
11546 expressions. */
11550 {
11551 /* Just build the index type and mark that it requires
11552 structural equality checks. */
11553 in_template:
11560 }
11563 {
11566 {
11570 else
11573 }
11575 /* We might have lost the TREE_CONSTANT flag e.g. when we are
11576 folding a conversion from a pointer to integral type. In that
11578 else
11579 /* Use the folded result for VLAs, too; it will have resolved
11580 SIZEOF_EXPR. */
11582 }
11584 /* Normally, the array-bound will be a constant. */
11586 {
11587 /* The size to use in diagnostics that reflects the constant
11588 size used in the source, rather than SIZE massaged above. */
11591 /* If the original size before conversion to size_t was signed
11592 and negative, convert it to ssizetype to restore the sign. */
11596 {
11599 /* Clear the overflow bit that may have been set as a result
11600 of the conversion from the sizetype of the new size to
11601 ssizetype. */
11603 }
11605 /* Verify that the array has a positive number of elements
11606 and issue the appropriate diagnostic if it doesn't. */
11608 {
11612 }
11613 /* As an extension we allow zero-sized arrays. */
11615 {
11617 /* We must fail if performing argument deduction (as
11618 indicated by the state of complain), so that
11619 another substitution can be found. */
11624 else
11627 }
11628 }
11630 /* We don't allow VLAs at non-function scopes, or during
11631 tentative template substitution. */
11634 {
11637 /* `(int) &fn' is not a valid array bound. */
11641 name);
11642 else
11645 }
11647 {
11651 else
11654 }
11656 {
11660 else
11663 }
11667 else
11668 {
11670 {
11671 /* A variable sized array. Arrange for the SAVE_EXPR on the inside
11672 of the MINUS_EXPR, which allows the -1 to get folded with the +1
11673 that happens when building TYPE_SIZE. */
11676 }
11678 /* Compute the index of the largest element in the array. It is
11679 one less than the number of elements in the array. We save
11680 and restore PROCESSING_TEMPLATE_DECL so that computations in
11681 cp_build_binary_op will be appropriately folded. */
11682 {
11683 processing_template_decl_sentinel s;
11685 MINUS_EXPR,
11688 complain),
11689 complain);
11691 }
11694 {
11697 {
11698 /* We have to add 1 -- in the ubsan routine we generate
11699 LE_EXPR rather than LT_EXPR. */
11704 }
11705 }
11706 /* Make sure that there was no overflow when creating to a signed
11707 index type. (For example, on a 32-bit machine, an array with
11708 size 2^32 - 1 is too big.) */
11711 {
11716 }
11717 }
11719 /* Create and return the appropriate index type. */
11722 /* If the index type were dependent, we would have returned early, so
11723 remember that it isn't. */
11727 }
11729 tree
11731 {
11733 }
11735 /* Returns the scope (if any) in which the entity declared by
11736 DECLARATOR will be located. If the entity was declared with an
11737 unqualified name, NULL_TREE is returned. */
11739 tree
11741 {
11745 /* If the declarator-id is a SCOPE_REF, the scope in which the
11746 declaration occurs is the first operand. */
11751 /* Otherwise, the declarator is not a qualified name; the entity will
11752 be declared in the current scope. */
11754 }
11756 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
11757 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
11758 with this type. */
11760 static tree
11762 {
11765 /* If things have already gone awry, bail now. */
11769 /* [dcl.type.class.deduct] prohibits forming an array of placeholder
11770 for a deduced class type. */
11772 {
11776 else
11779 }
11781 /* If there are some types which cannot be array elements,
11782 issue an error-message and return. */
11784 {
11788 else
11795 else
11802 else
11809 name);
11810 else
11816 }
11822 /* [dcl.array]
11824 The constant expressions that specify the bounds of the arrays
11825 can be omitted only for the first member of the sequence. */
11827 {
11831 name);
11832 else
11837 }
11839 /* Figure out the index type for the array. */
11841 {
11843 tf_warning_or_error);
11846 {
11849 }
11850 }
11853 }
11855 /* Returns the smallest location that is not UNKNOWN_LOCATION. */
11857 static location_t
11859 {
11865 }
11867 /* Returns the smallest location != UNKNOWN_LOCATION among the
11868 three stored in LOCATIONS[ds_const], LOCATIONS[ds_volatile],
11869 and LOCATIONS[ds_restrict]. */
11871 static location_t
11873 {
11886 }
11888 /* Returns the smallest among the latter and locations[ds_type_spec]. */
11890 static location_t
11892 {
11895 }
11897 static location_t
11899 {
11902 }
11904 /* Check that it's OK to declare a function with the indicated TYPE
11905 and TYPE_QUALS. SFK indicates the kind of special function (if any)
11906 that this function is. OPTYPE is the type given in a conversion
11907 operator declaration, or the class type for a constructor/destructor.
11908 Returns the actual return type of the function; that may be different
11909 than TYPE if an error occurs, or for certain special functions. */
11911 static tree
11913 tree type,
11914 tree optype,
11917 {
11919 {
11930 else
11942 /* We can't use the proper return type here because we run into
11943 problems with ambiguous bases and covariant returns. */
11946 else
11956 "qualifiers are not allowed on declaration of "
11968 "qualifiers are not allowed on declaration of "
11971 {
11975 }
11976 else
11986 }
11989 }
11991 /* A variable or data member (whose unqualified name is IDENTIFIER)
11992 has been declared with the indicated TYPE. If the TYPE is not
11993 acceptable, issue an error message and return a type to use for
11994 error-recovery purposes. */
11996 tree
11998 {
12000 {
12004 {
12007 identifier);
12008 }
12009 else
12012 }
12015 }
12017 /* Handle declaring DECL as an inline variable. */
12019 static void
12021 {
12024 {
12028 }
12033 {
12036 }
12037 }
12040 /* Assign a typedef-given name to a class or enumeration type declared
12041 as anonymous at first. This was split out of grokdeclarator
12042 because it is also used in libcc1. */
12044 void
12046 {
12049 /* Replace the anonymous decl with the real decl. Be careful not to
12050 rename other typedefs (such as the self-reference) of type. */
12056 /* If this is a typedef within a template class, the nested
12057 type is a (non-primary) template. The name for the
12058 template needs updating as well. */
12062 /* Adjust linkage now that we aren't unnamed anymore. */
12065 /* FIXME remangle member functions; member functions of a
12066 type with external linkage have external linkage. */
12068 /* Check that our job is done, and that it would fail if we
12069 attempted to do it again. */
12071 }
12073 /* Check that decltype(auto) was well-formed: only plain decltype(auto)
12074 is allowed. TYPE might contain a decltype(auto). Returns true if
12075 there was a problem, false otherwise. */
12077 static bool
12079 {
12081 {
12083 {
12085 {
12089 }
12091 {
12094 }
12095 }
12096 }
12098 }
12100 /* Given declspecs and a declarator (abstract or otherwise), determine
12101 the name and type of the object declared and construct a DECL node
12102 for it.
12104 DECLSPECS points to the representation of declaration-specifier
12105 sequence that precedes declarator.
12107 DECL_CONTEXT says which syntactic context this declaration is in:
12108 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
12109 FUNCDEF for a function definition. Like NORMAL but a few different
12110 error messages in each case. Return value may be zero meaning
12111 this definition is too screwy to try to parse.
12112 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
12113 handle member functions (which have FIELD context).
12114 Return value may be zero meaning this definition is too screwy to
12115 try to parse.
12116 PARM for a parameter declaration (either within a function prototype
12117 or before a function body). Make a PARM_DECL, or return void_type_node.
12118 TPARM for a template parameter declaration.
12119 CATCHPARM for a parameter declaration before a catch clause.
12120 TYPENAME if for a typename (in a cast or sizeof).
12121 Don't make a DECL node; just return the ..._TYPE node.
12122 FIELD for a struct or union field; make a FIELD_DECL.
12123 BITFIELD for a field with specified width.
12125 INITIALIZED is as for start_decl.
12127 ATTRLIST is a pointer to the list of attributes, which may be NULL
12128 if there are none; *ATTRLIST may be modified if attributes from inside
12129 the declarator should be applied to the declaration.
12131 When this function is called, scoping variables (such as
12132 CURRENT_CLASS_TYPE) should reflect the scope in which the
12133 declaration occurs, not the scope in which the new declaration will
12134 be placed. For example, on:
12136 void S::f() { ... }
12138 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
12139 should not be `S'.
12141 Returns a DECL (if a declarator is present), a TYPE (if there is no
12142 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
12143 error occurs. */
12145 tree
12151 {
12164 /* True if this declarator is a function definition. */
12168 #if 0
12169 /* See the code below that used this. */
12171 #endif
12173 /* Keep track of what sort of function is being processed
12174 so that we can warn about default return values, or explicit
12175 return values which do not match prescribed defaults. */
12181 /* cv-qualifiers that apply to the declarator, for a declaration of
12182 a member function. */
12184 /* virt-specifiers that apply to the declarator, for a declaration of
12185 a member function. */
12187 /* ref-qualifier that applies to the declarator, for a declaration of
12188 a member function. */
12190 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
12197 /* The unqualified name of the declarator; either an
12198 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
12199 tree unqualified_id;
12200 /* The class type, if any, in which this entity is located,
12201 or NULL_TREE if none. Note that this value may be different from
12202 the current class type; for example if an attempt is made to declare
12203 "A::f" inside "B", this value will be "A". */
12205 /* The NAMESPACE_DECL for the namespace in which this entity is
12206 located. If an unqualified name is used to declare the entity,
12207 this value will be NULL_TREE, even if the entity is located at
12208 namespace scope. */
12210 cp_storage_class storage_class;
12233 // Was concept_p specified? Note that ds_concept
12234 // implies ds_constexpr!
12256 location_t id_loc;
12257 location_t init_loc;
12259 {
12262 }
12263 else
12266 /* Look inside a declarator for the name being declared
12267 and get it as a string, for an error message. */
12269 id_declarator;
12271 {
12276 {
12280 {
12284 }
12288 {
12294 {
12299 {
12300 /* [dcl.meaning]
12302 A declarator-id shall not be qualified except
12303 for ...
12305 None of the cases are permitted in block
12306 scope. */
12309 decl);
12313 else
12317 }
12319 {
12322 {
12326 }
12328 && current_class_type
12330 current_class_type))
12331 {
12336 }
12337 }
12340 }
12342 {
12344 {
12346 {
12350 }
12353 {
12357 }
12364 }
12368 {
12374 }
12375 /* Fall through. */
12382 {
12384 dname);
12386 }
12389 else
12390 {
12397 else
12399 }
12404 }
12406 }
12423 }
12426 }
12428 /* [dcl.fct.edf]
12430 The declarator in a function-definition shall have the form
12431 D1 ( parameter-declaration-clause) ... */
12433 {
12436 }
12441 {
12444 }
12447 {
12450 {
12453 }
12456 {
12458 {
12461 }
12463 {
12466 }
12467 }
12468 }
12470 /* Anything declared one level down from the top level
12471 must be one of the parameters of a function
12472 (because the body is at least two levels down). */
12474 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
12475 by not allowing C++ class definitions to specify their parameters
12476 with xdecls (must be spec.d in the parmlist).
12478 Since we now wait to push a class scope until we are sure that
12479 we are in a legitimate method context, we must set oldcname
12480 explicitly (since current_class_name is not yet alive).
12482 We also want to avoid calling this a PARM if it is in a namespace. */
12485 {
12491 }
12497 {
12501 }
12504 {
12508 }
12511 {
12515 }
12518 {
12522 }
12525 {
12529 }
12531 /* [dcl.spec]/2 "At most one of the constexpr, consteval, and constinit
12532 keywords shall appear in a decl-specifier-seq." */
12534 {
12538 "can use at most one of the %<constinit%> and %<constexpr%> "
12541 }
12543 /* If there were multiple types specified in the decl-specifier-seq,
12544 issue an error message. */
12546 {
12550 }
12555 /* Extract the basic type from the decl-specifier-seq. */
12558 {
12561 }
12563 /* Ignore erroneous attributes. */
12567 /* An object declared as __attribute__((unavailable)) suppresses
12568 any reports of being declared with unavailable or deprecated
12569 items. An object declared as __attribute__((deprecated))
12570 suppresses warnings of uses of other deprecated items. */
12579 {
12585 }
12586 /* No type at all: default to `int', and set DEFAULTED_INT
12587 because it was not a user-defined typedef. */
12589 {
12591 {
12592 /* These imply 'int'. */
12595 }
12596 /* If we just have "complex", it is equivalent to "complex double". */
12599 {
12602 "ISO C++ does not support plain %<complex%> meaning "
12604 }
12605 }
12606 /* Gather flags. */
12610 #if 0
12611 /* See the code below that used this. */
12614 #endif
12619 else
12623 {
12625 ctor_return_type,
12626 type_quals,
12629 }
12631 {
12636 /* We handle `main' specially here, because 'main () { }' is so
12637 common. With no options, it is allowed. With -Wreturn-type,
12638 it is a warning. It is only an error with -pedantic-errors. */
12639 is_main = (funcdef_flag
12652 name);
12656 else
12661 /* FIXME we should be able to propagate the error_mark_node as is
12662 for other contexts too. */
12664 else
12666 }
12671 {
12673 {
12678 }
12679 /* Don't pedwarn if the alternate "__intN__" form has been used instead
12680 of "__intN". */
12685 }
12687 /* Now process the modifiers that were specified
12688 and check for invalid combinations. */
12690 /* Long double is a special combination. */
12692 {
12696 }
12698 /* Check all other uses of type modifiers. */
12701 {
12702 location_t loc;
12705 {
12708 }
12710 {
12713 }
12715 {
12718 }
12720 {
12723 }
12725 {
12728 }
12733 {
12738 }
12740 {
12744 }
12754 {
12756 {
12761 /* PR108099: __int128_t comes from c_common_nodes_and_builtins,
12762 and is not built as a typedef. */
12765 }
12768 else
12770 }
12771 else
12774 /* Discard the type modifiers if they are invalid. */
12776 {
12782 }
12783 }
12785 /* Decide whether an integer type is signed or not.
12786 Optionally treat bitfields as signed by default. */
12788 /* [class.bit]
12790 It is implementation-defined whether a plain (neither
12791 explicitly signed or unsigned) char, short, int, or long
12792 bit-field is signed or unsigned.
12794 Naturally, we extend this to long long as well. Note that
12795 this does not include wchar_t. */
12797 && !signed_p
12798 /* A typedef for plain `int' without `signed' can be
12799 controlled just like plain `int', but a typedef for
12800 `signed int' cannot be so controlled. */
12801 && !(typedef_decl
12805 {
12818 else
12820 }
12835 {
12839 /* If a modifier is specified, the resulting complex is the complex
12840 form of TYPE. E.g, "complex short" is "complex short int". */
12849 else
12851 }
12853 /* If we're using the injected-class-name to form a compound type or a
12854 declaration, replace it with the underlying class so we don't get
12855 redundant typedefs in the debug output. But if we are returning the
12856 type unchanged, leave it alone so that it's available to
12857 maybe_get_template_decl_from_type_decl. */
12865 type = cp_build_qualified_type
12869 /* We might have ignored or rejected some of the qualifiers. */
12874 /* Placeholder in parm gets a better error below. */
12878 {
12879 auto_diagnostic_group g;
12883 "for deduction, template placeholder must be followed "
12887 }
12898 /* Treat class-scope deduction guides as static member functions
12899 so that they get a FUNCTION_TYPE instead of a METHOD_TYPE. */
12903 {
12905 {
12912 }
12914 {
12918 "declared both %<virtual%> and %<constexpr%> only in "
12920 }
12921 }
12924 /* Issue errors about use of storage classes for parameters. */
12926 {
12928 {
12932 }
12934 {
12938 name);
12940 }
12944 {
12949 }
12951 /* Function parameters cannot be concept. */
12953 {
12958 }
12959 /* Function parameters cannot be constexpr. If we saw one, moan
12960 and pretend it wasn't there. */
12962 {
12966 }
12968 {
12972 }
12974 {
12978 }
12979 }
12981 /* Give error if `virtual' is used outside of class declaration. */
12984 {
12988 }
12991 {
13008 "structured binding declaration can be %qs only in "
13010 declspecs->gnu_thread_keyword_p
13015 /* [dcl.struct.bind] "A cv that includes volatile is deprecated." */
13020 {
13030 "structured binding declaration can be %qs only in "
13047 }
13050 {
13052 {
13053 auto_diagnostic_group d;
13057 "type must be cv-qualified %<auto%> or reference to "
13059 }
13062 }
13065 "structured binding declaration cannot have constrained "
13073 {
13076 }
13077 }
13079 /* Static anonymous unions are dealt with here. */
13085 /* Warn about storage classes that are invalid for certain
13086 kinds of declarations (parameters, typenames, etc.). */
13088 && ((storage_class
13092 {
13093 location_t loc
13098 }
13103 {
13107 ;
13109 ;
13111 /* C++ allows static class elements. */
13113 /* C++ also allows inlines and signed and unsigned elements,
13114 but in those cases we don't come in here. */
13115 ;
13116 else
13117 {
13118 location_t loc
13125 else
13132 }
13133 }
13138 {
13142 }
13146 {
13152 /* When thread_local is applied to a variable of block scope the
13153 storage-class-specifier static is implied if it does not appear
13154 explicitly. */
13157 }
13160 {
13163 "storage class specifiers invalid in friend function "
13167 }
13171 else
13172 {
13175 {
13188 }
13189 }
13193 {
13199 }
13204 /* Skip over build_memfn_type when a FUNCTION_DECL is an xobj memfn. */
13206 /* Determine the type of the entity declared by recurring on the
13207 declarator. */
13209 {
13211 tree attrs;
13218 {
13230 /* Assume that any attributes that get applied late to
13231 templates will DTRT when applied to the declaration
13232 as a whole. */
13236 attrs),
13237 attr_flags);
13239 }
13243 /* Check that contracts aren't misapplied. */
13249 /* We don't want to warn in parameter context because we don't
13250 yet know if the parse will succeed, and this might turn out
13251 to be a constructor call. */
13254 && !typedef_p
13256 /* If the type is class-like and the inner name used a
13257 global namespace qualifier, we need the parens.
13258 Unfortunately all we can tell is whether a qualified name
13259 was used or not. */
13260 && !(inner_declarator
13265 {
13268 name))
13269 {
13274 }
13275 }
13280 {
13291 /* [dcl.array]/1:
13293 The optional attribute-specifier-seq appertains to the
13294 array. */
13300 {
13301 tree arg_types;
13304 /* Declaring a function type. */
13306 /* Pick up type qualifiers which should be applied to `this'. */
13308 /* Pick up virt-specifiers. */
13310 /* And ref-qualifier, too */
13312 /* And tx-qualifier. */
13314 /* Pick up the exception specifications. */
13316 /* If the exception-specification is ill-formed, let's pretend
13317 there wasn't one. */
13322 {
13323 /* There is no need to iterate over the list,
13324 only the first parm can be a valid xobj parm. */
13327 /* If we make it here, we are looking at an xobj parm.
13329 Non-null 'purpose' usually means the parm has a default
13330 argument, we don't want to violate this assumption. */
13333 };
13335 tree xobj_parm
13341 "explicit object member function only available "
13345 {
13346 /* We inform in every case, just differently depending on what
13347 case it is. */
13348 auto_diagnostic_group d;
13350 /* If declarator->kind is cdk_function and we are at the end of
13351 the declarator chain, we are looking at a function type. */
13353 {
13355 "a function type cannot "
13358 }
13361 "a pointer to function type cannot "
13365 "a pointer to member function type "
13367 else
13370 /* The locations being used here are probably not correct. */
13373 "the type of a pointer to explicit object member "
13375 else
13377 "the type of an explicit object "
13379 /* Ideally we should synthesize the correct syntax
13380 for the user, perhaps this could be added later. */
13381 }
13382 /* Since a valid xobj parm has its purpose cleared in find_xobj_parm
13383 the first parm node will never erroneously be detected here. */
13384 {
13385 auto_diagnostic_group d;
13390 {
13394 gcc_rich_location bad_xobj_parm
13397 "Only the first parameter of a member function "
13399 }
13403 }
13409 /* Say it's a definition only for the CALL_EXPR
13410 closest to the identifier. */
13413 /* Handle a late-specified return type. */
13416 {
13418 {
13425 {
13427 "%<auto%> type specifier without "
13430 "deduced return type only available "
13432 }
13434 {
13438 }
13439 }
13441 {
13443 "return type has %qT as its type rather "
13446 }
13448 {
13451 "%qs function with trailing return type "
13452 "has %<decltype(auto)%> as its type "
13454 else
13458 }
13464 {
13466 {
13467 auto_diagnostic_group g;
13474 }
13476 {
13478 "for %qT must have trailing return "
13483 }
13489 else
13493 }
13494 }
13497 {
13501 /* Not using maybe_warn_cpp0x because this should
13502 always be an error. */
13504 "trailing return type only available "
13506 else
13508 "return type not declared with %<auto%> "
13511 }
13513 {
13516 }
13522 {
13525 }
13528 {
13529 /* It's wrong, for instance, to issue a -Wignored-qualifiers
13530 warning for
13531 static_assert(!is_same_v<void(*)(), const void(*)()>);
13532 because there the qualifier matters. */
13536 /* [dcl.fct] "A volatile-qualified return type is
13537 deprecated." */
13540 "%<volatile%>-qualified return type is "
13543 /* We now know that the TYPE_QUALS don't apply to the
13544 decl, but to its return type. */
13546 }
13548 /* Error about some types functions can't return. */
13551 {
13555 }
13557 {
13561 }
13563 {
13565 "%<constinit%> on function return type is not "
13568 }
13575 && funcdecl_p
13581 {
13582 /* We are within a class's scope. If our declarator name
13583 is the same as the class name, and we are defining
13584 a function, then it is a constructor/destructor, and
13585 therefore returns a void type. */
13587 /* ISO C++ 12.4/2. A destructor may not be declared
13588 const or volatile. A destructor may not be static.
13589 A destructor may not be declared with ref-qualifier.
13591 ISO C++ 12.1. A constructor may not be declared
13592 const or volatile. A constructor may not be
13593 virtual. A constructor may not be static.
13594 A constructor may not be declared with ref-qualifier. */
13603 {
13608 }
13611 {
13617 }
13621 current_class_type,
13622 flags))
13626 {
13627 /* It's a constructor. */
13631 {
13635 }
13639 }
13642 }
13644 {
13646 {
13647 /* Cannot be both friend and virtual. */
13652 }
13657 {
13659 "cannot define friend function %qs in a local "
13662 }
13663 /* [class.friend]/6: A function can be defined in a friend
13664 declaration if the function name is unqualified. */
13666 {
13669 "friend function definition %qs cannot have "
13671 else
13673 "friend function definition %qs cannot have "
13675 in_namespace);
13676 }
13677 }
13679 {
13681 {
13684 }
13685 }
13687 {
13690 }
13693 {
13696 && (in_namespace
13699 "a non-member function cannot have "
13701 else
13702 {
13704 {
13705 auto_diagnostic_group d;
13707 "an explicit object member function cannot "
13712 }
13714 {
13715 auto_diagnostic_group d;
13717 "an explicit object member function cannot "
13721 }
13722 }
13723 }
13729 pushed_scope
13741 {
13746 }
13752 {
13754 /* transaction_safe applies to the type, but
13755 transaction_safe_dynamic applies to the function. */
13758 else
13760 }
13762 /* Actually apply the contract attributes to the declaration. */
13764 {
13767 {
13769 /* Intentionally reverse order of contracts so they're
13770 reversed back into their lexical order. */
13773 }
13774 else
13776 }
13779 /* [dcl.fct]/2:
13781 The optional attribute-specifier-seq appertains to
13782 the function type. */
13787 }
13793 /* Filter out pointers-to-references and references-to-references.
13794 We can get these if a TYPE_DECL is used. */
13797 {
13799 {
13802 }
13804 /* In C++0x, we allow reference to reference declarations
13805 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
13806 and template type arguments [14.3.1/4 temp.arg.type]. The
13807 check for direct reference to reference declarations, which
13808 are still forbidden, occurs below. Reasoning behind the change
13809 can be found in DR106, DR540, and the rvalue reference
13810 proposals. */
13812 {
13815 }
13816 }
13818 {
13823 }
13825 /* We now know that the TYPE_QUALS don't apply to the decl,
13826 but to the target of the pointer. */
13829 /* This code used to handle METHOD_TYPE, but I don't think it's
13830 possible to get it here anymore. */
13834 {
13838 memfn_quals,
13839 rqual);
13845 }
13853 type);
13855 /* When the pointed-to type involves components of variable size,
13856 care must be taken to ensure that the size evaluation code is
13857 emitted early enough to dominate all the possible later uses
13858 and late enough for the variables on which it depends to have
13859 been assigned.
13861 This is expected to happen automatically when the pointed-to
13862 type has a name/declaration of it's own, but special attention
13863 is required if the type is anonymous.
13865 We handle the NORMAL and FIELD contexts here by inserting a
13866 dummy statement that just evaluates the size at a safe point
13867 and ensures it is not deferred until e.g. within a deeper
13868 conditional context (c++/43555).
13870 We expect nothing to be needed here for PARM or TYPENAME.
13871 Evaluating the size at this point for TYPENAME would
13872 actually be incorrect, as we might be in the middle of an
13873 expression with side effects on the pointed-to type size
13874 "arguments" prior to the pointer declaration point and the
13875 size evaluation could end up prior to the side effects. */
13881 {
13885 }
13888 {
13889 /* In C++0x, the type we are creating a reference to might be
13890 a typedef which is itself a reference type. In that case,
13891 we follow the reference collapsing rules in
13892 [7.1.3/8 dcl.typedef] to create the final reference type:
13894 "If a typedef TD names a type that is a reference to a type
13895 T, an attempt to create the type 'lvalue reference to cv TD'
13896 creates the type 'lvalue reference to T,' while an attempt
13897 to create the type "rvalue reference to cv TD' creates the
13898 type TD."
13899 */
13903 {
13906 else
13908 }
13909 else
13910 type = cp_build_reference_type
13913 /* In C++0x, we need this check for direct reference to
13914 reference declarations, which are forbidden by
13915 [8.3.2/5 dcl.ref]. Reference to reference declarations
13916 are only allowed indirectly through typedefs and template
13917 type arguments. Example:
13919 void foo(int & &); // invalid ref-to-ref decl
13921 typedef int & int_ref;
13922 void foo(int_ref &); // valid ref-to-ref decl
13923 */
13927 }
13931 {
13935 /* We will already have complained. */
13937 else
13939 type);
13940 }
13941 else
13944 /* Process a list of type modifier keywords (such as
13945 const or volatile) that were given inside the `*' or `&'. */
13948 {
13949 type
13953 }
13955 /* Apply C++11 attributes to the pointer, and not to the
13956 type pointed to. This is unlike what is done for GNU
13957 attributes above. It is to comply with [dcl.ptr]/1:
13959 [the optional attribute-specifier-seq (7.6.1) appertains
13960 to the pointer and not to the object pointed to]. */
13973 }
13974 }
13979 /* Don't check this if it can be the artifical decltype(auto)
13980 we created when building a constraint in a compound-requirement:
13981 that the type-constraint is plain is going to be checked in
13982 cp_parser_compound_requirement. */
13987 /* A `constexpr' specifier used in an object declaration declares
13988 the object as `const'. */
13990 {
13991 /* DR1688 says that a `constexpr' specifier in combination with
13992 `volatile' is valid. */
13995 {
13998 }
13999 }
14004 {
14006 unqualified_id);
14008 }
14010 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
14011 qualified with a class-name, turn it into a METHOD_TYPE, unless
14012 we know that the function is static. We take advantage of this
14013 opportunity to do other processing that pertains to entities
14014 explicitly declared to be class members. Note that if DECLARATOR
14015 is non-NULL, we know it is a cdk_id declarator; otherwise, we
14016 would not have exited the loop above. */
14021 {
14027 {
14029 {
14031 "member functions are implicitly "
14034 }
14035 else
14038 }
14040 can skip the following checks. */
14043 qualifying type must certainly be complete. */
14044 funcdef_flag
14045 /* A friend declaration of "T::f" is OK, even if
14046 "T" is a template parameter. But, if this
14047 function is not a friend, the qualifying type
14048 must be a class. */
14050 /* For a declaration, the type need not be
14051 complete, if either it is dependent (since there
14052 is no meaningful definition of complete in that
14053 case) or the qualifying class is currently being
14054 defined. */
14057 /* Check that the qualifying type is complete. */
14061 {
14064 {
14072 }
14073 }
14075 {
14079 }
14080 }
14085 /* Now TYPE has the actual type. */
14088 {
14091 else
14093 }
14099 {
14100 /* [dcl.meaning]/1: The optional attribute-specifier-seq following
14101 a declarator-id appertains to the entity that is declared. */
14104 else
14105 /* We should have already diagnosed the issue (c++/78344). */
14107 }
14109 /* Handle parameter packs. */
14111 {
14113 /* Turn the type into a pack expansion.*/
14115 else
14117 }
14120 && !processing_template_decl
14122 {
14126 else
14130 }
14133 {
14134 /* [dcl.fct.spec] (C++11) The explicit specifier shall be used only
14135 in the declaration of a constructor or conversion function within
14136 a class definition. */
14143 else
14145 "only declarations of constructors and conversion operators "
14148 }
14151 {
14154 {
14156 name);
14158 }
14160 {
14163 name);
14165 }
14167 {
14169 name);
14171 }
14173 {
14175 name);
14177 }
14179 {
14181 name);
14183 }
14185 {
14187 name);
14189 }
14190 }
14192 /* If this is declaring a typedef name, return a TYPE_DECL. */
14194 {
14196 tree decl;
14199 {
14203 else
14207 }
14209 /* This declaration:
14211 typedef void f(int) const;
14213 declares a function type which is not a member of any
14214 particular class, but which is cv-qualified; for
14215 example "f S::*" declares a pointer to a const-qualified
14216 member function of S. We record the cv-qualification in the
14217 function type. */
14219 {
14222 /* We have now dealt with these qualifiers. */
14225 }
14228 {
14232 else
14236 }
14242 {
14245 }
14249 else
14253 {
14257 /* The TYPE_DECL is "abstract" because there will be
14258 clones of this constructor/destructor, and there will
14259 be copies of this TYPE_DECL generated in those
14260 clones. The decloning optimization (for space) may
14261 revert this subsequently if it determines that
14262 the clones should share a common implementation. */
14266 }
14271 unqualified_id);
14273 /* If the user declares "typedef struct {...} foo" then the
14274 struct will have an anonymous name. Fill that name in now.
14275 Nothing can refer to it, so nothing needs know about the name
14276 change. */
14278 && unqualified_id
14297 /* Acknowledge that this was written:
14298 `using analias = atype;'. */
14302 }
14304 /* Detect the case of an array type of unspecified size
14305 which came, as such, direct from a typedef name.
14306 We must copy the type, so that the array's domain can be
14307 individually set by the object's initializer. */
14314 /* Detect where we're using a typedef of function type to declare a
14315 function. PARMS will not be set, so we must create it now. */
14318 {
14320 tree args;
14325 {
14331 }
14336 {
14337 /* The qualifiers on the function type become the qualifiers on
14338 the non-static member function. */
14343 }
14344 }
14346 /* If this is a type name (such as, in a cast or sizeof),
14347 compute the type and return it now. */
14350 {
14351 /* Note that here we don't care about type_quals. */
14353 /* Special case: "friend class foo" looks like a TYPENAME context. */
14355 {
14357 {
14360 }
14363 {
14364 /* Don't allow friend declaration without a class-key. */
14371 else
14374 type);
14375 }
14377 /* Only try to do this stuff if we didn't already give up. */
14379 {
14380 /* A friendly class? */
14384 else
14386 type);
14389 }
14390 }
14392 {
14399 /* Core issue #547: need to allow this in template type args.
14400 Allow it in general in C++11 for alias-declarations. */
14404 else
14406 }
14412 }
14416 && ! bitfield
14418 {
14421 }
14424 {
14425 /* Only functions may be declared using an operator-function-id. */
14427 {
14430 }
14435 type);
14436 }
14438 /* We don't check parameter types here because we can emit a better
14439 error message later. */
14441 {
14445 }
14447 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
14448 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
14451 {
14457 {
14460 {
14465 {
14466 auto_diagnostic_group g;
14470 "missing template argument list after %qE; template "
14476 }
14480 else
14481 /* Do not issue an error while tentatively parsing a function
14482 parameter: for T t(auto(a), 42);, when we just saw the 1st
14483 parameter, we don't know yet that this construct won't be
14484 a function declaration. Defer the checking to
14485 cp_parser_parameter_declaration_clause. */
14487 }
14488 else
14492 }
14494 /* A parameter declared as an array of T is really a pointer to T.
14495 One declared as a function is really a pointer to a function.
14496 One declared as a member is really a pointer to member. */
14499 {
14500 /* Transfer const-ness of array into that of type pointed to. */
14504 }
14507 }
14510 /* Don't convert xobj member functions to METHOD_TYPE. */
14511 && !is_xobj_member_function
14512 && !(unqualified_id
14515 {
14521 }
14523 {
14527 {
14535 }
14537 {
14540 {
14546 else
14550 }
14552 /* The C99 flexible array extension. */
14555 {
14559 {
14562 }
14563 else
14564 {
14565 /* Array is a flexible member. */
14569 else
14573 /* Flexible array member has a null domain. */
14575 }
14576 }
14579 {
14580 /* Happens when declaring arrays of sizes which
14581 are error_mark_node, for example. */
14583 }
14585 {
14586 /* Something like struct S { int N::j; }; */
14589 }
14591 {
14593 tree function_context;
14596 {
14597 /* This should never happen in pure C++ (the check
14598 could be an assert). It could happen in
14599 Objective-C++ if someone writes invalid code that
14600 uses a function declaration for an instance
14601 variable or property (instance variables and
14602 properties are parsed as FIELD_DECLs, but they are
14603 part of an Objective-C class, not a C++ class).
14604 That code is invalid and is caught by this
14605 check. */
14607 {
14609 unqualified_id);
14611 }
14613 /* ``A union may [ ... ] not [ have ] virtual functions.''
14614 ARM 9.5 */
14616 {
14619 unqualified_id);
14621 }
14626 {
14628 "%qD cannot be declared %<virtual%>, since it "
14631 }
14632 }
14634 /* Check that the name used for a destructor makes sense. */
14636 {
14640 {
14645 }
14648 {
14652 }
14654 {
14658 }
14660 {
14662 "%<constexpr%> destructors only available"
14665 }
14667 {
14671 }
14672 }
14674 {
14679 }
14682 {
14686 }
14688 {
14692 }
14696 {
14700 }
14703 {
14706 {
14712 }
14713 }
14715 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
14716 function_context
14725 parms,
14726 unqualified_id,
14727 declspecs,
14728 reqs,
14741 #if 0
14742 /* This clobbers the attrs stored in `decl' from `attrlist'. */
14743 /* The decl and setting of decl_attr is also turned off. */
14745 #endif
14747 /* [class.conv.ctor]
14749 A constructor declared without the function-specifier
14750 explicit that can be called with a single parameter
14751 specifies a conversion from the type of its first
14752 parameter to the type of its class. Such a constructor
14753 is called a converting constructor. */
14759 }
14761 && ((current_class_type
14767 {
14770 {
14772 {
14776 }
14777 else
14782 }
14783 }
14785 staticp
14786 ? TCTX_STATIC_STORAGE
14788 {
14791 }
14792 else
14793 {
14795 {
14798 "%qE is neither function nor member function; "
14800 else
14804 }
14806 }
14809 {
14810 /* Packages tend to use GNU attributes on friends, so we only
14811 warn for standard attributes. */
14813 && !funcdef_flag
14816 {
14821 }
14822 /* Friends are treated specially. */
14826 {
14830 /* Kludge: We need funcdef_flag to be true in do_friend for
14831 in-class defaulted functions, but that breaks grokfndecl.
14832 So set it here. */
14842 }
14843 else
14845 }
14847 /* Structure field. It may not be a function, except for C++. */
14850 {
14852 {
14853 /* C++ allows static class members. All other work
14854 for this is done by grokfield. */
14859 {
14861 template_count,
14865 }
14872 {
14874 "%<constexpr%> static data member %qD must "
14877 }
14888 /* Even if there is an in-class initialization, DECL
14889 is considered undefined until an out-of-class
14890 definition is provided, unless this is an inline
14891 variable. */
14895 {
14901 }
14903 /* Set the constraints on the declaration. */
14907 {
14910 }
14911 }
14912 else
14913 {
14915 {
14921 }
14923 {
14928 }
14930 {
14935 }
14937 {
14942 }
14949 {
14952 }
14955 {
14956 /* An attempt is being made to initialize a non-static
14957 member. This is new in C++11. */
14960 /* If this has been parsed with static storage class, but
14961 errors forced staticp to be cleared, ensure NSDMI is
14962 not present. */
14965 }
14966 }
14973 }
14974 }
14976 {
14977 tree original_name;
14985 else
14987 // FIXME:gcc_assert (original_name == dname);
14995 name);
14997 {
15001 name);
15002 else
15004 "storage class %<thread_local%> invalid for "
15006 }
15014 /* Function declaration not at top level.
15015 Storage classes other than `extern' are not allowed
15016 and `extern' makes no difference. */
15021 {
15024 "%<static%> specifier invalid for function %qs "
15026 else
15028 "%<inline%> specifier invalid for function %qs "
15030 }
15033 {
15035 {
15038 }
15041 {
15046 }
15047 }
15051 {
15055 }
15057 /* Record whether the function is public. */
15062 declspecs,
15065 publicp,
15070 funcdef_flag,
15071 late_return_type_p,
15073 id_loc);
15080 {
15083 /* Don't allow a static member function in a class, and forbid
15084 declaring main to be static. */
15086 {
15090 }
15092 {
15093 /* 7.1.1: There can be no static function declarations within a
15094 block. */
15098 }
15101 {
15104 }
15105 }
15108 }
15109 else
15110 {
15111 /* It's a variable. */
15113 /* An uninitialized decl with `extern' is a reference. */
15115 declspecs,
15116 initialized,
15117 type_quals,
15118 inlinep,
15119 concept_p,
15120 template_count,
15122 id_loc);
15132 {
15135 {
15137 "%<static%> may not be used when defining "
15141 }
15143 {
15146 }
15148 {
15150 "cannot explicitly declare member %q#D to have "
15153 }
15154 }
15156 {
15158 "declaration of %<constexpr%> variable %qD "
15161 }
15163 {
15167 }
15172 {
15177 }
15178 }
15183 {
15187 }
15190 {
15192 {
15193 /* It's common practice (and completely valid) to have a const
15194 be initialized and declared extern. */
15198 }
15199 else
15200 {
15204 }
15205 }
15207 /* Record `register' declaration for warnings on &
15208 and in case doing stupid register allocation. */
15211 {
15213 /* Warn about register storage specifiers on PARM_DECLs. */
15215 {
15218 "ISO C++17 does not allow %<register%> storage "
15220 else
15223 }
15224 }
15231 {
15232 /* Set constexpr flag on vars (functions got it in grokfndecl). */
15235 /* And the constinit flag (which only applies to variables). */
15238 }
15240 {
15241 /* If we saw a return type, record its location. */
15246 {
15252 }
15255 }
15257 /* Record constancy and volatility on the DECL itself . There's
15258 no need to do this when processing a template; we'll do this
15259 for the instantiated declaration based on the type of DECL. */
15264 }
15265 }
15266 \f
15267 /* Subroutine of start_function. Ensure that each of the parameter
15268 types (as listed in PARMS) is complete, as is required for a
15269 function definition. */
15271 static void
15273 {
15275 {
15280 {
15287 }
15288 else
15289 /* grokparms or complete_type_or_else will have already issued
15290 an error. */
15292 }
15293 }
15295 /* Returns nonzero if T is a local variable. */
15297 int
15299 {
15308 }
15310 /* Like local_variable_p, but suitable for use as a tree-walking
15311 function. */
15313 static tree
15316 {
15318 {
15319 /* DR 2082 permits local variables in unevaluated contexts
15320 within a default argument. */
15323 }
15332 }
15334 /* Check that ARG, which is a default-argument expression for a
15335 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
15336 something goes wrong. DECL may also be a _TYPE node, rather than a
15337 DECL, if there is no DECL available. */
15339 tree
15341 {
15342 tree var;
15343 tree decl_type;
15346 /* We get a DEFERRED_PARSE when looking at an in-class declaration
15347 with a default argument. Ignore the argument for now; we'll
15348 deal with it after the class is complete. */
15352 {
15355 }
15356 else
15363 /* Something already went wrong. There's no need to check
15364 further. */
15367 /* [dcl.fct.default]
15369 A default argument expression is implicitly converted to the
15370 parameter type. */
15372 /* Avoid digest_init clobbering the initializer. */
15375 LOOKUP_IMPLICIT);
15378 /* Avoid redundant -Wzero-as-null-pointer-constant warnings at
15379 the call sites. */
15382 /* Don't lose side-effects as in PR90473. */
15386 /* [dcl.fct.default]
15388 Local variables shall not be used in default argument
15389 expressions.
15391 The keyword `this' shall not be used in a default argument of a
15392 member function. */
15395 {
15397 {
15401 else
15403 }
15405 }
15407 /* All is well. */
15409 }
15411 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
15413 static tree
15415 {
15420 {
15423 else
15424 {
15427 }
15428 }
15430 /* Do warn about using typedefs to a deprecated class. */
15442 return type_is_deprecated
15446 }
15448 /* Returns an unavailable type used within TYPE, or NULL_TREE if none. */
15450 static tree
15452 {
15457 {
15460 else
15461 {
15464 }
15465 }
15467 /* Do warn about using typedefs to a deprecated class. */
15479 return type_is_unavailable
15483 }
15485 /* Decode the list of parameter types for a function type.
15486 Given the list of things declared inside the parens,
15487 return a list of types.
15489 If this parameter does not end with an ellipsis, we append
15490 void_list_node.
15492 *PARMS is set to the chain of PARM_DECLs created. */
15494 tree
15496 {
15499 tree parm;
15503 {
15512 {
15515 }
15519 {
15521 && !init
15524 /* DR 577: A parameter list consisting of a single
15525 unnamed parameter of non-dependent type 'void'. */
15529 "invalid use of cv-qualified type %qT in "
15531 else
15533 "invalid use of type %<void%> in parameter "
15535 /* It's not a good idea to actually create parameters of
15536 type `void'; other parts of the compiler assume that a
15537 void type terminates the parameter list. */
15540 }
15543 {
15545 {
15549 }
15552 {
15556 }
15558 /* [dcl.fct] "A parameter with volatile-qualified type is
15559 deprecated." */
15562 "%<volatile%>-qualified parameter is "
15565 /* Top-level qualifiers on the parameters are
15566 ignored for function types. */
15569 {
15573 }
15575 {
15576 /* Before C++17 DR 393:
15577 [dcl.fct]/6, parameter types cannot contain pointers
15578 (references) to arrays of unknown bound. */
15583 {
15591 }
15594 ptr
15600 }
15604 }
15609 }
15619 /* We had parm errors, recover by giving the function (...) type. */
15623 }
15625 \f
15626 /* D is a constructor or overloaded `operator='.
15628 Let T be the class in which D is declared. Then, this function
15629 returns:
15631 -1 if D's is an ill-formed constructor or copy assignment operator
15632 whose first parameter is of type `T'.
15633 0 if D is not a copy constructor or copy assignment
15634 operator.
15635 1 if D is a copy constructor or copy assignment operator whose
15636 first parameter is a reference to non-const qualified T.
15637 2 if D is a copy constructor or copy assignment operator whose
15638 first parameter is a reference to const qualified T.
15640 This function can be used as a predicate. Positive values indicate
15641 a copy constructor and nonzero values indicate a copy assignment
15642 operator. */
15644 int
15646 {
15647 tree args;
15648 tree arg_type;
15656 /* Instantiations of template member functions are never copy
15657 functions. Note that member functions of templated classes are
15658 represented as template functions internally, and we must
15659 accept those as copy functions. */
15667 {
15671 /* Reject unrelated object parameters. */
15676 }
15677 else
15687 {
15688 /* Pass by value copy assignment operator. */
15690 }
15694 {
15697 }
15698 else
15704 /* There are more non-optional args. */
15708 }
15710 /* D is a constructor or overloaded `operator='.
15712 Let T be the class in which D is declared. Then, this function
15713 returns true when D is a move constructor or move assignment
15714 operator, false otherwise. */
15716 bool
15718 {
15720 /* There are no move constructors if we are in C++98 mode. */
15726 /* Instantiations of template member functions are never move
15727 functions. Note that member functions of templated classes are
15728 represented as template functions internally, and we must
15729 accept those as move functions. */
15733 }
15735 /* D is a constructor or overloaded `operator='.
15737 Then, this function returns true when D has the same signature as a move
15738 constructor or move assignment operator (because either it is such a
15739 ctor/op= or it is a template specialization with the same signature),
15740 false otherwise. */
15742 bool
15744 {
15745 tree args;
15746 tree arg_type;
15754 {
15758 /* Reject unrelated object parameters. */
15763 }
15764 else
15782 /* There are more non-optional args. */
15786 }
15788 /* Remember any special properties of member function DECL. */
15790 void
15792 {
15793 tree class_type;
15801 {
15808 {
15809 /* [class.copy]
15811 A non-template constructor for class X is a copy
15812 constructor if its first parameter is of type X&, const
15813 X&, volatile X& or const volatile X&, and either there
15814 are no other parameters or else all other parameters have
15815 default arguments. */
15819 }
15830 }
15832 {
15833 /* [class.copy]
15835 A non-template assignment operator for class X is a copy
15836 assignment operator if its parameter is of type X, X&, const
15837 X&, volatile X& or const volatile X&. */
15842 {
15846 }
15847 }
15851 /* Destructors are handled in check_methods. */
15852 }
15854 /* Check a constructor DECL has the correct form. Complains
15855 if the class has a constructor of the form X(X). */
15857 bool
15859 {
15863 {
15864 /* [class.copy]
15866 A declaration of a constructor for a class X is ill-formed if
15867 its first parameter is of type (optionally cv-qualified) X
15868 and either there are no other parameters or else all other
15869 parameters have default arguments.
15871 We *don't* complain about member template instantiations that
15872 have this form, though; they can occur as we try to decide
15873 what constructor to use during overload resolution. Since
15874 overload resolution will never prefer such a constructor to
15875 the non-template copy constructor (which is either explicitly
15876 or implicitly defined), there's no need to worry about their
15877 existence. Theoretically, they should never even be
15878 instantiated, but that's hard to forestall. */
15883 }
15886 }
15888 /* DECL is a declaration for an overloaded or conversion operator. If
15889 COMPLAIN is true, errors are issued for invalid declarations. */
15891 bool
15893 {
15903 tree_code operator_code;
15906 {
15907 /* Conversion operators are TYPE_EXPR for the purposes of this
15908 function. */
15911 }
15912 else
15913 {
15920 }
15923 {
15924 /* operator new and operator delete are quite special. */
15927 {
15946 }
15948 /* [basic.std.dynamic.allocation]/1:
15950 A program is ill-formed if an allocation function is declared
15951 in a namespace scope other than global scope or declared
15952 static in global scope.
15954 The same also holds true for deallocation functions. */
15956 {
15958 {
15960 decl);
15962 }
15965 {
15968 }
15969 }
15972 {
15975 }
15976 else
15977 {
15980 }
15983 }
15985 /* An operator function must either be a non-static member function
15986 or have at least one parameter of a class, a reference to a class,
15987 an enumeration, or a reference to an enumeration. 13.4.0.6 */
15989 {
15993 {
15996 }
15999 {
16001 {
16004 }
16006 /* For lambdas we diagnose static lambda specifier elsewhere. */
16008 /* For instantiations, we have diagnosed this already. */
16012 decl);
16014 /* static operator[] should have exactly one argument
16015 for C++20 and earlier, so that it isn't multidimensional. */
16017 }
16019 {
16023 }
16024 else
16026 {
16028 {
16033 }
16039 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
16040 because these checks are performed even on template
16041 functions. */
16045 }
16046 }
16049 /* There are no further restrictions on the arguments to an overloaded
16050 "operator ()". */
16053 /* C++23 allows an arbitrary number of parameters and default arguments for
16054 operator[], and none of the other checks below apply. */
16059 {
16060 /* 13.4.0.3 */
16063 }
16065 /* Count the number of arguments and check for ellipsis. */
16068 {
16070 {
16072 decl);
16074 }
16076 }
16077 /* FIXME: We need tests for these errors with xobj member functions. */
16078 /* Verify correct number of arguments. */
16080 {
16083 {
16084 /* We have a unary instance of an ambi-ary op. Remap to the
16085 unary one. */
16091 }
16093 {
16094 /* This was an ambiguous operator but is invalid. */
16096 methodp
16100 }
16103 && ! processing_template_decl
16104 /* x++ and x--'s second argument must be an int. */
16106 integer_type_node))
16107 {
16109 methodp
16112 decl);
16114 }
16119 {
16121 methodp
16125 }
16130 {
16132 methodp
16136 }
16141 }
16143 /* There can be no default arguments. */
16147 {
16151 }
16153 /* At this point the declaration is well-formed. It may not be
16154 sensible though. */
16156 /* Check member function warnings only on the in-class declaration.
16157 There's no point warning on an out-of-class definition. */
16161 /* Warn about conversion operators that will never be used. */
16165 {
16176 {
16179 ref
16184 class_type);
16185 /* Don't force t to be complete here. */
16190 ref
16196 }
16197 }
16202 /* Effective C++ rules below. */
16204 /* More Effective C++ rule 7. */
16211 /* More Effective C++ rule 6. */
16216 {
16225 {
16230 }
16231 else
16232 {
16236 }
16237 }
16239 /* Effective C++ rule 23. */
16250 }
16251 \f
16252 /* Return a string giving the keyword associate with CODE. */
16256 {
16258 {
16271 }
16272 }
16274 /* Name lookup in an elaborated-type-specifier (after the keyword
16275 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
16276 elaborated-type-specifier is invalid, issue a diagnostic and return
16277 error_mark_node; otherwise, return the *_TYPE to which it referred.
16278 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
16280 tree
16282 tree decl,
16284 {
16285 tree type;
16287 /* In the case of:
16289 struct S { struct S *p; };
16291 name lookup will find the TYPE_DECL for the implicit "S::S"
16292 typedef. Adjust for that here. */
16298 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
16299 is false for this case as well. */
16301 {
16305 }
16306 /* Accept template template parameters. */
16310 ;
16311 /* [dcl.type.elab]
16313 If the identifier resolves to a typedef-name or the
16314 simple-template-id resolves to an alias template
16315 specialization, the elaborated-type-specifier is ill-formed.
16317 In other words, the only legitimate declaration to use in the
16318 elaborated type specifier is the implicit typedef created when
16319 the type is declared. */
16323 {
16327 else
16332 }
16337 {
16341 }
16344 {
16348 }
16352 {
16353 /* If a class template appears as elaborated type specifier
16354 without a template header such as:
16356 template <class T> class C {};
16357 void f(class C); // No template header here
16359 then the required template argument is missing. */
16364 }
16367 }
16369 /* Lookup NAME of an elaborated type specifier according to SCOPE and
16370 issue diagnostics if necessary. Return *_TYPE node upon success,
16371 NULL_TREE when the NAME is not found, and ERROR_MARK_NODE for type
16372 error. */
16374 static tree
16377 {
16378 tree decl;
16380 {
16381 /* First try ordinary name lookup, ignoring hidden class name
16382 injected via friend declaration. */
16385 /* If that fails, the name will be placed in the smallest
16386 non-class, non-function-prototype scope according to 3.3.1/5.
16387 We may already have a hidden name declared as friend in this
16388 scope. So lookup again but not ignoring hidden names.
16389 If we find one, that name will be made visible rather than
16390 creating a new tag. */
16393 }
16394 else
16398 /* We found nothing. */
16402 {
16406 }
16409 && !template_header_p
16411 {
16416 }
16419 /* If scope is TAG_how::CURRENT_ONLY we're defining a class,
16420 so ignore a template template parameter. */
16425 /* Found not-a-type. */
16428 /* Look for invalid nested type:
16429 class C {
16430 class C {};
16431 }; */
16433 {
16437 }
16439 /* Two cases we need to consider when deciding if a class
16440 template is allowed as an elaborated type specifier:
16441 1. It is a self reference to its own class.
16442 2. It comes with a template header.
16444 For example:
16446 template <class T> class C {
16447 class C *c1; // DECL_SELF_REFERENCE_P is true
16448 class D;
16449 };
16450 template <class U> class C; // template_header_p is true
16451 template <class T> class C<T>::D {
16452 class C *c2; // DECL_SELF_REFERENCE_P is true
16453 }; */
16456 template_header_p
16461 {
16470 }
16473 }
16475 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
16476 Define the tag as a forward-reference if it is not defined.
16478 If a declaration is given, process it here, and report an error if
16479 multiple declarations are not identical.
16481 SCOPE is TS_CURRENT when this is also a definition. Only look in
16482 the current frame for the name (since C++ allows new names in any
16483 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
16484 declaration. Only look beginning from the current scope outward up
16485 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
16487 TEMPLATE_HEADER_P is true when this declaration is preceded by
16488 a set of template parameters. */
16490 tree
16493 {
16502 {
16515 }
16517 /* In case of anonymous name, xref_tag is only called to
16518 make type node and push name. Name lookup is not required. */
16529 {
16533 /* Since HOW is not TAG_how::CURRENT_ONLY, we are not looking at
16534 a definition of this tag. Since, in addition, we are
16535 currently processing a (member) template declaration of a
16536 template class, we must be very careful; consider:
16538 template <class X> struct S1
16540 template <class U> struct S2
16541 {
16542 template <class V> friend struct S1;
16543 };
16545 Here, the S2::S1 declaration should not be confused with the
16546 outer declaration. In particular, the inner version should
16547 have a template parameter of level 2, not level 1.
16549 On the other hand, when presented with:
16551 template <class T> struct S1
16552 {
16553 template <class U> struct S2 {};
16554 template <class U> friend struct S2;
16555 };
16557 the friend must find S1::S2 eventually. We accomplish this
16558 by making sure that the new type we create to represent this
16559 declaration has the right TYPE_CONTEXT. */
16562 }
16565 {
16566 /* If no such tag is yet defined, create a forward-reference node
16567 and record it as the "definition".
16568 When a real declaration of this type is found,
16569 the forward-reference will be altered into a real type. */
16571 {
16574 }
16579 /* Mark it as a lambda type right now. Our caller will
16580 correct the value. */
16583 }
16584 else
16585 {
16587 {
16588 /* Check that we aren't trying to overload a class with different
16589 constraints. */
16593 }
16597 {
16601 }
16605 {
16608 {
16609 auto_diagnostic_group d;
16613 }
16620 {
16621 auto_diagnostic_group d;
16625 }
16634 {
16635 /* Push it into this TU's symbol slot. */
16638 /* We're in the template parm binding level.
16639 Pushtag has logic to slide under that, but we're
16640 not pushing a *new* type. */
16646 }
16649 }
16650 }
16653 }
16655 /* Create the binfo hierarchy for REF with (possibly NULL) base list
16656 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
16657 access_* node, and the TREE_VALUE is the type of the base-class.
16658 Non-NULL TREE_TYPE indicates virtual inheritance. */
16660 void
16662 {
16669 tree default_access;
16675 /* The base of a derived class is private by default, all others are
16676 public. */
16681 /* First, make sure that any templates in base-classes are
16682 instantiated. This ensures that if we call ourselves recursively
16683 we do not get confused about which classes are marked and which
16684 are not. */
16687 {
16690 /* The dependent_type_p call below should really be dependent_scope_p
16691 so that we give a hard error about using an incomplete type as a
16692 base, but we allow it with a pedwarn for backward
16693 compatibility. */
16699 /* An incomplete type. Remove it from the list. */
16701 else
16702 {
16703 max_bases++;
16705 max_dvbases++;
16709 }
16710 }
16715 /* The binfo slot should be empty, unless this is an (ill-formed)
16716 redefinition. */
16727 /* Apply base-class info set up to the variants of this type. */
16731 {
16733 /* A C++98 POD cannot have base classes. */
16737 {
16740 }
16741 }
16748 {
16749 /* An aggregate can't have virtual base classes. */
16757 }
16760 {
16768 /* Before C++17, an aggregate cannot have base classes. In C++17, an
16769 aggregate can't have virtual, private, or protected base classes. */
16780 {
16782 basetype);
16784 }
16788 {
16790 /* The original basetype could have been a typedef'd type. */
16793 /* Inherit flags from the base. */
16804 }
16806 /* We must do this test after we've seen through a typedef
16807 type. */
16809 {
16812 else
16815 }
16818 /* Regenerate the pack expansion for the bases. */
16832 dropped_base:
16833 /* Update max_vbases to reflect the reality that we are dropping
16834 this base: if it reaches zero we want to undo the vec_alloc
16835 above to avoid inconsistencies during error-recovery: eg, in
16836 build_special_member_call, CLASSTYPE_VBASECLASSES non null
16837 and vtt null (c++/27952). */
16839 max_vbases--;
16841 max_vbases
16843 }
16850 /* If we didn't get max_vbases vbases, we must have shared at
16851 least one of them, and are therefore diamond shaped. */
16854 /* Unmark all the types. */
16859 /* Now see if we have a repeated base type. */
16861 {
16864 {
16866 {
16869 }
16871 }
16876 else
16878 }
16879 }
16881 \f
16882 /* Copies the enum-related properties from type SRC to type DST.
16883 Used with the underlying type of an enum and the enum itself. */
16884 static void
16886 {
16887 tree t;
16889 {
16899 else
16903 }
16904 }
16906 /* Begin compiling the definition of an enumeration type.
16907 NAME is its name,
16909 if ENUMTYPE is not NULL_TREE then the type has alredy been found.
16911 UNDERLYING_TYPE is the type that will be used as the storage for
16912 the enumeration type. This should be NULL_TREE if no storage type
16913 was specified.
16915 ATTRIBUTES are any attributes specified after the enum-key.
16917 SCOPED_ENUM_P is true if this is a scoped enumeration type.
16919 if IS_NEW is not NULL, gets TRUE iff a new type is created.
16921 Returns the type object, as yet incomplete.
16922 Also records info about it so that build_enumerator
16923 may be used to declare the individual values as they are read. */
16925 tree
16928 {
16934 /* [C++0x dcl.enum]p5:
16936 If not explicitly specified, the underlying type of a scoped
16937 enumeration type is int. */
16944 /* If this is the real definition for a previous forward reference,
16945 fill in the contents in the same object that used to be the
16946 forward reference. */
16952 /* In case of a template_decl, the only check that should be deferred
16953 to instantiation time is the comparison of underlying types. */
16955 {
16957 {
16963 }
16965 {
16971 }
16975 {
16981 }
16984 {
16986 {
16992 }
16994 }
16995 }
16999 {
17000 /* In case of error, make a dummy enum to allow parsing to
17001 continue. */
17003 {
17006 }
17008 /* enumtype may be an ENUMERAL_TYPE if this is a redefinition
17009 of an opaque enum, or an opaque enum of an already defined
17010 enumeration (C++11).
17011 In any other case, it'll be NULL_TREE. */
17013 {
17016 }
17019 /* Do not push the decl more than once. */
17022 {
17026 /* std::byte aliases anything. */
17031 }
17032 else
17038 /* The enum is considered opaque until the opening '{' of the
17039 enumerator list. */
17042 }
17049 {
17051 /* We already checked that it matches, don't change it to a different
17054 {
17057 }
17060 else
17061 {
17065 }
17066 }
17068 /* If into a template class, the returned enum is always the first
17069 declaration (opaque or not) seen. This way all the references to
17070 this type will be to the same declaration. The following ones are used
17071 only to check for definition errors. */
17074 else
17076 }
17078 /* After processing and defining all the values of an enumeration type,
17079 install their decls in the enumeration type.
17080 ENUMTYPE is the type object. */
17082 void
17084 {
17085 tree values;
17086 tree underlying_type;
17087 tree decl;
17088 tree value;
17090 tree t;
17092 bool fixed_underlying_type_p
17095 /* We built up the VALUES in reverse order. */
17098 /* For an enum defined in a template, just set the type of the values;
17099 all further processing is postponed until the template is
17100 instantiated. We need to set the type so that tsubst of a CONST_DECL
17101 works. */
17103 {
17105 values;
17109 }
17111 /* Determine the minimum and maximum values of the enumerators. */
17113 {
17117 values;
17119 {
17122 /* [dcl.enum]: Following the closing brace of an enum-specifier,
17123 each enumerator has the type of its enumeration. Prior to the
17124 closing brace, the type of each enumerator is the type of its
17125 initializing value. */
17128 /* Update the minimum and maximum values, if appropriate. */
17132 /* Figure out what the minimum and maximum values of the
17133 enumerators are. */
17140 }
17141 }
17142 else
17143 /* [dcl.enum]
17145 If the enumerator-list is empty, the underlying type is as if
17146 the enumeration had a single enumerator with value 0. */
17150 {
17151 /* Compute the number of bits require to represent all values of the
17152 enumeration. We must do this before the type of MINNODE and
17153 MAXNODE are transformed, since tree_int_cst_min_precision relies
17154 on the TREE_TYPE of the value it is passed. */
17162 /* Determine the underlying type of the enumeration.
17164 [dcl.enum]
17166 The underlying type of an enumeration is an integral type that
17167 can represent all the enumerator values defined in the
17168 enumeration. It is implementation-defined which integral type is
17169 used as the underlying type for an enumeration except that the
17170 underlying type shall not be larger than int unless the value of
17171 an enumerator cannot fit in an int or unsigned int.
17173 We use "int" or an "unsigned int" as the underlying type, even if
17174 a smaller integral type would work, unless the user has
17175 explicitly requested that we use the smallest possible type. The
17176 user can request that for all enumerations with a command line
17177 flag, or for just one enumeration with an attribute. */
17179 use_short_enum = flag_short_enums
17182 /* If the precision of the type was specified with an attribute and it
17183 was too small, give an error. Otherwise, use it. */
17185 {
17188 else
17189 {
17192 }
17193 }
17197 itk++)
17198 {
17204 }
17206 {
17207 /* DR 377
17209 IF no integral type can represent all the enumerator values, the
17210 enumeration is ill-formed. */
17215 }
17217 /* [dcl.enum]
17219 The value of sizeof() applied to an enumeration type, an object
17220 of an enumeration type, or an enumerator, is the value of sizeof()
17221 applied to the underlying type. */
17224 /* Compute the minimum and maximum values for the type.
17226 [dcl.enum]
17228 For an enumeration where emin is the smallest enumerator and emax
17229 is the largest, the values of the enumeration are the values of the
17230 underlying type in the range bmin to bmax, where bmin and bmax are,
17231 respectively, the smallest and largest values of the smallest bit-
17232 field that can store emin and emax. */
17234 /* The middle-end currently assumes that types with TYPE_PRECISION
17235 narrower than their underlying type are suitably zero or sign
17236 extended to fill their mode. Similarly, it assumes that the front
17237 end assures that a value of a particular type must be within
17238 TYPE_MIN_VALUE and TYPE_MAX_VALUE.
17240 We used to set these fields based on bmin and bmax, but that led
17241 to invalid assumptions like optimizing away bounds checking. So
17242 now we just set the TYPE_PRECISION, TYPE_MIN_VALUE, and
17243 TYPE_MAX_VALUE to the values for the mode above and only restrict
17244 the ENUM_UNDERLYING_TYPE for the benefit of diagnostics. */
17248 set_min_and_max_values_for_integral_type
17251 /* If -fstrict-enums, still constrain TYPE_MIN/MAX_VALUE. */
17256 {
17259 }
17260 }
17261 else
17264 /* If the enum is exported, mark the consts too. */
17269 /* Convert each of the enumerators to the type of the underlying
17270 type of the enumeration. */
17272 {
17276 /* If the enumeration type has a fixed underlying type, we
17277 already checked all of the enumerator values. */
17279 else
17282 tf_warning_or_error);
17283 /* Do not clobber shared ints. */
17285 {
17289 }
17293 }
17295 /* Fix up all variant types of this enum type. */
17302 {
17304 /* TYPE_FIELDS needs fixup. */
17306 }
17308 /* Finish debugging output for this type. */
17311 /* Each enumerator now has the type of its enumeration. Clear the cache
17312 so that this change in types doesn't confuse us later on. */
17314 }
17316 /* Finishes the enum type. This is called only the first time an
17317 enumeration is seen, be it opaque or odinary.
17318 ENUMTYPE is the type object. */
17320 void
17322 {
17324 {
17328 }
17330 /* If this is a forward declaration, there should not be any variants,
17331 though we can get a variant in the middle of an enum-specifier with
17332 wacky code like 'enum E { e = sizeof(const E*) };' */
17336 }
17338 /* Build and install a CONST_DECL for an enumeration constant of the
17339 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
17340 Apply ATTRIBUTES if available. LOC is the location of NAME.
17341 Assignment of sequential values by default is handled here. */
17343 tree
17345 location_t loc)
17346 {
17347 tree decl;
17348 tree context;
17349 tree type;
17351 /* scalar_constant_value will pull out this expression, so make sure
17352 it's folded as appropriate. */
17356 /* If the VALUE was erroneous, pretend it wasn't there; that will
17357 result in the enum being assigned the next value in sequence. */
17361 /* Remove no-op casts from the value. */
17366 {
17367 /* Validate and default VALUE. */
17369 {
17371 {
17376 }
17379 value = perform_implicit_conversion_flags
17387 {
17390 {
17392 "enumerator value for %qD must have integral or "
17395 }
17396 else
17397 {
17401 {
17405 }
17406 }
17407 }
17408 }
17410 /* Default based on previous value. */
17412 {
17414 {
17415 tree prev_value;
17417 /* C++03 7.2/4: If no initializer is specified for the first
17418 enumerator, the type is an unspecified integral
17419 type. Otherwise the type is the same as the type of the
17420 initializing value of the preceding enumerator unless the
17421 incremented value is not representable in that type, in
17422 which case the type is an unspecified integral type
17423 sufficient to contain the incremented value. */
17427 else
17428 {
17435 {
17438 {
17441 {
17447 }
17454 }
17457 else
17459 }
17462 {
17465 }
17466 }
17467 }
17468 else
17470 }
17472 /* Remove no-op casts from the value. */
17475 /* If the underlying type of the enum is fixed, check whether
17476 the enumerator values fits in the underlying type. If it
17477 does not fit, the program is ill-formed [C++0x dcl.enum]. */
17479 && value
17481 {
17486 /* Convert the value to the appropriate type. */
17488 }
17489 }
17491 /* C++ associates enums with global, function, or class declarations. */
17494 /* Build the actual enumeration constant. Note that the enumeration
17495 constants have the underlying type of the enum (if it is fixed)
17496 or the type of their initializer (if the underlying type of the
17497 enum is not fixed):
17499 [ C++0x dcl.enum ]
17501 If the underlying type is fixed, the type of each enumerator
17502 prior to the closing brace is the underlying type; if the
17503 initializing value of an enumerator cannot be represented by
17504 the underlying type, the program is ill-formed. If the
17505 underlying type is not fixed, the type of each enumerator is
17506 the type of its initializing value.
17508 If the underlying type is not fixed, it will be computed by
17509 finish_enum and we will reset the type of this enumerator. Of
17510 course, if we're processing a template, there may be no value. */
17524 {
17525 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
17526 on the TYPE_FIELDS list for `S'. (That's so that you can say
17527 things like `S::i' later.) */
17529 /* The enumerator may be getting declared outside of its enclosing
17530 class, like so:
17532 class S { public: enum E : int; }; enum S::E : int { i = 7; };
17534 For which case we need to make sure that the access of `S::i'
17535 matches the access of `S::E'. */
17539 }
17540 else
17543 /* Add this enumeration constant to the list for this type. */
17547 }
17549 /* Look for an enumerator with the given NAME within the enumeration
17550 type ENUMTYPE. This routine is used primarily for qualified name
17551 lookup into an enumerator in C++0x, e.g.,
17553 enum class Color { Red, Green, Blue };
17555 Color color = Color::Red;
17557 Returns the value corresponding to the enumerator, or
17558 NULL_TREE if no such enumerator was found. */
17559 tree
17561 {
17562 tree e;
17567 }
17569 /* Implement LANG_HOOKS_SIMULATE_ENUM_DECL. */
17571 tree
17574 {
17581 {
17586 }
17600 }
17602 /* Implement LANG_HOOKS_SIMULATE_RECORD_DECL. */
17604 tree
17607 {
17614 {
17617 }
17636 }
17637 \f
17638 /* We're defining DECL. Make sure that its type is OK. */
17640 static void
17642 {
17646 /* In a function definition, arg types must be complete. */
17653 {
17658 /* Make it return void instead. */
17661 void_type_node,
17663 else
17665 fntype = (cp_build_type_attribute_variant
17669 }
17670 else
17671 {
17675 }
17676 }
17678 /* True iff FN is an implicitly-defined default constructor. */
17680 static bool
17682 {
17686 }
17688 /* Clobber the contents of *this to let the back end know that the object
17689 storage is dead when we enter the constructor or leave the destructor. */
17691 static tree
17693 {
17694 /* Clobbering an empty base is pointless, and harmful if its one byte
17695 TYPE_SIZE overlays real data. */
17699 /* If we have virtual bases, clobber the whole object, but only if we're in
17700 charge. If we don't have virtual bases, clobber the as-base type so we
17701 don't mess with tail padding. */
17712 {
17715 }
17722 }
17724 /* Create the FUNCTION_DECL for a function definition.
17725 DECLSPECS and DECLARATOR are the parts of the declaration;
17726 they describe the function's name and the type it returns,
17727 but twisted together in a fashion that parallels the syntax of C.
17729 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
17730 DECLARATOR is really the DECL for the function we are about to
17731 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
17732 indicating that the function is an inline defined in-class.
17734 This function creates a binding context for the function body
17735 as well as setting up the FUNCTION_DECL in current_function_decl.
17737 For C++, we must first check whether that datum makes any sense.
17738 For example, "class A local_a(1,2);" means that variable local_a
17739 is an aggregate of type A, which should have a constructor
17740 applied to it with the argument list [1, 2].
17742 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
17743 or may be a BLOCK if the function has been defined previously
17744 in this translation unit. On exit, DECL_INITIAL (decl1) will be
17745 error_mark_node if the function has never been defined, or
17746 a BLOCK if the function has been defined somewhere. */
17748 bool
17750 {
17754 /* Sanity check. */
17761 else
17762 {
17767 }
17774 /* Handle gnu_inline attribute. */
17776 {
17781 }
17784 /* This is a constructor, we must ensure that any default args
17785 introduced by this definition are propagated to the clones
17786 now. The clones are used directly in overload resolution. */
17789 /* Sometimes we don't notice that a function is a static member, and
17790 build a METHOD_TYPE for it. Fix that up now. */
17794 /* Set up current_class_type, and enter the scope of the class, if
17795 appropriate. */
17799 /* Now that we have entered the scope of the class, we must restore
17800 the bindings for any template parameters surrounding DECL1, if it
17801 is an inline member template. (Order is important; consider the
17802 case where a template parameter has the same name as a field of
17803 the class.) It is not until after this point that
17804 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
17808 /* Effective C++ rule 15. */
17816 /* Make the init_value nonzero so pushdecl knows this is not tentative.
17817 error_mark_node is replaced below (in poplevel) with the BLOCK. */
17821 /* This function exists in static storage.
17822 (This does not mean `static' in the C sense!) */
17825 /* We must call push_template_decl after current_class_type is set
17826 up. (If we are processing inline definitions after exiting a
17827 class scope, current_class_type will be NULL_TREE until set above
17828 by push_nested_class.) */
17830 {
17833 {
17837 }
17839 }
17841 /* Make sure the parameter and return types are reasonable. When
17842 you declare a function, these types can be incomplete, but they
17843 must be complete when you define the function. */
17846 /* Build the return declaration for the function. */
17850 {
17851 /* In a template instantiation, copy the return type location. When
17852 parsing, the location will be set in grokdeclarator. */
17855 {
17859 }
17867 }
17869 /* Record the decl so that the function name is defined.
17870 If we already have a decl for this name, and it is a FUNCTION_DECL,
17871 use the old decl. */
17873 {
17874 /* A specialization is not used to guide overload resolution. */
17878 {
17882 /* If something went wrong when registering the declaration,
17883 use DECL1; we have to have a FUNCTION_DECL to use when
17884 parsing the body of the function. */
17885 ;
17886 else
17887 {
17888 /* Otherwise, OLDDECL is either a previous declaration
17889 of the same function or DECL1 itself. */
17896 {
17897 tree context;
17899 /* Check whether DECL1 is in an anonymous
17900 namespace. */
17902 context;
17904 {
17908 }
17912 OPT_Wmissing_declarations,
17914 }
17917 }
17918 }
17919 else
17920 {
17921 /* We need to set the DECL_CONTEXT. */
17924 }
17928 /* If #pragma weak applies, mark the decl appropriately now.
17929 The pragma only applies to global functions. Because
17930 determining whether or not the #pragma applies involves
17931 computing the mangled name for the declaration, we cannot
17932 apply the pragma until after we have merged this declaration
17933 with any previous declarations; if the original declaration
17934 has a linkage specification, that specification applies to
17935 the definition as well, and may affect the mangled name. */
17938 }
17940 /* We are now in the scope of the function being defined. */
17943 /* Save the parm names or decls from this function's declarator
17944 where store_parm_decls will find them. */
17947 /* Let the user know we're compiling this function. */
17952 /* This function may already have been parsed, in which case just
17953 return; our caller will skip over the body without parsing. */
17957 /* Initialize RTL machinery. We cannot do this until
17958 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
17959 even when processing a template; this is how we get
17960 CFUN set up, and our per-function variables initialized.
17961 FIXME factor out the non-RTL stuff. */
17965 /* Initialize the language data structures. Whenever we start
17966 a new function, we destroy temporaries in the usual way. */
17971 /* If we are (erroneously) defining a function that we have already
17972 defined before, wipe out what we knew before. */
17978 {
17981 }
17983 /* Start the statement-tree, start the tree now. */
17987 {
17988 /* We know that this was set up by `grokclassfn'. We do not
17989 wait until `store_parm_decls', since evil parse errors may
17990 never get us to that point. Here we keep the consistency
17991 between `current_class_type' and `current_class_ptr'. */
17997 cp_function_chain->x_current_class_ref
17999 /* Set this second to avoid shortcut in cp_build_indirect_ref. */
18002 /* Constructors and destructors need to know whether they're "in
18003 charge" of initializing virtual base classes. */
18006 {
18009 }
18011 {
18014 }
18015 }
18018 /* Implicitly-defined methods (like the
18019 destructor for a class in which no destructor
18020 is explicitly declared) must not be defined
18021 until their definition is needed. So, we
18022 ignore interface specifications for
18023 compiler-generated functions. */
18031 {
18038 /* This is a function in a local class in an extern inline
18039 or template function. */
18041 }
18042 /* If this function belongs to an interface, it is public.
18043 If it belongs to someone else's interface, it is also external.
18044 This only affects inlines and template instantiations. */
18046 {
18049 {
18053 && ! flag_implement_inlines
18056 /* For WIN32 we also want to put these in linkonce sections. */
18058 }
18059 else
18062 /* If this function is in an interface implemented in this file,
18063 make sure that the back end knows to emit this function
18064 here. */
18067 }
18070 {
18071 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
18072 interface, we will have both finfo->interface_unknown and
18073 finfo->interface_only set. In that case, we don't want to
18074 use the normal heuristics because someone will supply a
18075 #pragma implementation elsewhere, and deducing it here would
18076 produce a conflict. */
18081 }
18082 else
18083 {
18084 /* This is a definition, not a reference.
18085 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
18093 else
18095 }
18097 /* Determine the ELF visibility attribute for the function. We must not
18098 do this before calling "pushdecl", as we must allow "duplicate_decls"
18099 to merge any attributes appropriately. We also need to wait until
18100 linkage is set. */
18121 /* Clobbering an empty base is harmful if it overlays real data. */
18123 /* We can't clobber safely for an implicitly-defined default constructor
18124 because part of the initialization might happen before we enter the
18125 constructor, via AGGR_INIT_ZERO_FIRST (c++/68006). */
18140 }
18143 /* Like start_preparsed_function, except that instead of a
18144 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
18146 Returns true on success. If the DECLARATOR is not suitable
18147 for a function, we return false, which tells the parser to
18148 skip the entire function. */
18150 bool
18153 tree attrs)
18154 {
18155 tree decl1;
18163 /* main must return int. grokfndecl should have corrected it
18164 (and issued a diagnostic) if the user got it wrong. */
18166 integer_type_node));
18169 }
18170 \f
18171 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
18172 FN. */
18174 static bool
18176 {
18178 && !processing_template_decl
18179 /* We insert the EH_SPEC_BLOCK only in the original
18180 function; then, it is copied automatically to the
18181 clones. */
18183 /* Implicitly-generated constructors and destructors have
18184 exception specifications. However, those specifications
18185 are the union of the possible exceptions specified by the
18186 constructors/destructors for bases and members, so no
18187 unallowed exception will ever reach this function. By
18188 not creating the EH_SPEC_BLOCK we save a little memory,
18189 and we avoid spurious warnings about unreachable
18190 code. */
18193 }
18195 /* Helper function to push ARGS into the current lexical scope. DECL
18196 is the function declaration. NONPARMS is used to handle enum
18197 constants. */
18199 void
18201 {
18202 /* If we're doing semantic analysis, then we'll call pushdecl
18203 for each of these. We must do them in reverse order so that
18204 they end in the correct forward order. */
18207 tree next;
18209 {
18214 {
18215 /* If we find an enum constant or a type tag, put it aside for
18216 the moment. */
18219 }
18220 }
18222 /* Get the decls in their original chain order and record in the
18223 function. This is all and only the PARM_DECLs that were
18224 pushed into scope by the loop above. */
18226 }
18228 /* Store the parameter declarations into the current function declaration.
18229 This is called after parsing the parameter declarations, before
18230 digesting the body of the function.
18232 Also install to binding contour return value identifier, if any. */
18234 static void
18236 {
18239 /* This is a chain of any other decls that came in among the parm
18240 declarations. If a parm is declared with enum {foo, bar} x;
18241 then CONST_DECLs for foo and bar are put here. */
18245 {
18246 /* This case is when the function was defined with an ANSI prototype.
18247 The parms already have decls, so we need not do anything here
18248 except record them as in effect
18249 and complain if any redundant old-style parm decls were written. */
18253 /* Must clear this because it might contain TYPE_DECLs declared
18254 at class level. */
18258 }
18259 else
18262 /* Now store the final chain of decls for the arguments
18263 as the decl-chain of the current lexical scope.
18264 Put the enumerators in as well, at the front so that
18265 DECL_ARGUMENTS is not modified. */
18270 }
18272 \f
18273 /* Mark CDTOR's implicit THIS argument for returning, if required by
18274 the ABI.. Return the decl for THIS, if it is to be returned, and
18275 NULL otherwise. */
18277 tree
18279 {
18282 {
18285 }
18288 }
18290 /* Set the return value of the [cd]tor if the ABI wants that. */
18292 void
18294 {
18296 {
18297 /* Return the address of the object. */
18303 }
18304 }
18306 /* Do all the processing for the beginning of a destructor; set up the
18307 vtable pointers and cleanups for bases and members. */
18309 static void
18311 {
18312 tree compound_stmt;
18314 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
18315 issued an error message. We still want to try to process the
18316 body of the function, but initialize_vtbl_ptrs will crash if
18317 TYPE_BINFO is NULL. */
18319 {
18321 /* Make all virtual function table pointers in non-virtual base
18322 classes point to CURRENT_CLASS_TYPE's virtual function
18323 tables. */
18328 /* Clobbering an empty base is harmful if it overlays real data. */
18330 {
18334 {
18336 tree ref
18343 tf_warning_or_error);
18344 /* If the vptr is shared with some virtual nearly empty base,
18345 don't clear it if not in charge, the dtor of the virtual
18346 nearly empty base will do that later. */
18348 {
18351 {
18353 {
18355 tf_warning_or_error);
18358 }
18360 }
18361 }
18363 }
18364 else
18367 }
18369 /* And insert cleanups for our bases and members so that they
18370 will be properly destroyed if we throw. */
18372 }
18373 }
18375 /* Do the necessary processing for the beginning of a function body, which
18376 in this case includes member-initializers, but not the catch clauses of
18377 a function-try-block. Currently, this means opening a binding level
18378 for the member-initializers (in a ctor), member cleanups (in a dtor),
18379 and capture proxies (in a lambda operator()). */
18381 tree
18383 {
18389 else
18390 /* Always keep the BLOCK node associated with the outermost pair of
18391 curly braces of a function. These are needed for correct
18392 operation of dwarfout.c. */
18404 }
18406 /* Do the processing for the end of a function body. Currently, this means
18407 closing out the cleanups for fully-constructed bases and members, and in
18408 the case of the destructor, deleting the object if desired. Again, this
18409 is only meaningful for [cd]tors, since they are the only functions where
18410 there is a significant distinction between the main body and any
18411 function catch clauses. Handling, say, main() return semantics here
18412 would be wrong, as flowing off the end of a function catch clause for
18413 main() would also need to return 0. */
18415 void
18417 {
18421 /* Close the block. */
18429 }
18431 /* Given a function, returns the BLOCK corresponding to the outermost level
18432 of curly braces, skipping the artificial block created for constructor
18433 initializers. */
18435 tree
18437 {
18447 }
18449 /* If FNDECL is a class's key method, add the class to the list of
18450 keyed classes that should be emitted. */
18452 static void
18454 {
18458 {
18462 }
18463 }
18465 /* Attempt to add a fix-it hint to RICHLOC suggesting the insertion
18466 of "return *this;" immediately before its location, using FNDECL's
18467 first statement (if any) to give the indentation, if appropriate. */
18469 static void
18471 {
18478 indent);
18479 }
18481 /* This function carries out the subset of finish_function operations needed
18482 to emit the compiler-generated outlined helper functions used by the
18483 coroutines implementation. */
18485 static void
18487 {
18488 /* This is a partial set of the operations done by finish_function()
18489 plus emitting the result. */
18499 /* We must start each function with a clear fold cache. */
18504 /* This function has coroutine IFNs that we should handle in middle
18505 end lowering. */
18509 }
18511 /* Finish up a function declaration and compile that function
18512 all the way to assembler language output. The free the storage
18513 for the function definition. INLINE_P is TRUE if we just
18514 finished processing the body of an in-class inline function
18515 definition. (This processing will have taken place after the
18516 class definition is complete.) */
18518 tree
18520 {
18525 && !processing_template_decl
18529 /* When we get some parse errors, we can end up without a
18530 current_function_decl, so cope. */
18544 /* TREE_READONLY (fndecl) = 1;
18545 This caused &foo to be of type ptr-to-const-function
18546 which then got a warning when stored in a ptr-to-function variable. */
18549 /* The current function is being defined, so its DECL_INITIAL should
18550 be set, and unless there's a multiple definition, it should be
18551 error_mark_node. */
18555 {
18556 /* Only try to emit the coroutine outlined helper functions if the
18557 transforms succeeded. Otherwise, treat errors in the same way as
18558 a regular function. */
18561 /* We should handle coroutine IFNs in middle end lowering. */
18564 /* Do not try to process the ramp's EH unless outlining succeeded. */
18568 current_eh_spec_block);
18569 }
18570 else
18571 /* For a cloned function, we've already got all the code we need;
18572 there's no need to add any extra bits. */
18574 {
18575 /* Make it so that `main' always returns 0 by default. */
18583 current_eh_spec_block);
18584 }
18586 /* If we're saving up tree structure, tie off the function now. */
18591 /* This must come after expand_function_end because cleanups might
18592 have declarations (from inline functions) that need to go into
18593 this function's blocks. */
18595 /* If the current binding level isn't the outermost binding level
18596 for this function, either there is a bug, or we have experienced
18597 syntax errors and the statement tree is malformed. */
18599 {
18600 /* Make sure we have already experienced errors. */
18603 /* Throw away the broken statement tree and extra binding
18604 levels. */
18608 {
18611 else
18613 }
18614 }
18617 /* Statements should always be full-expressions at the outermost set
18618 of curly braces for a function. */
18621 /* If there are no return statements in a function with auto return type,
18622 the return type is void. But if the declared type is something like
18623 auto*, this is an error. */
18626 {
18628 && !current_function_returns_value
18630 {
18631 /* We haven't applied return type deduction because we haven't
18632 seen any return statements. Do that now. */
18636 adc_return_type);
18640 }
18643 {
18648 }
18649 }
18651 /* Remember that we were in class scope. */
18656 {
18660 }
18662 // If this is a concept, check that the definition is reasonable.
18671 /* Complain if there's just no return statement. */
18678 /* Don't complain if we abort or throw. */
18679 && !current_function_returns_abnormally
18680 /* Don't complain if there's an infinite loop. */
18681 && !current_function_infinite_loop
18682 /* Don't complain if we are declared noreturn. */
18686 /* Structor return values (if any) are set by the compiler. */
18690 {
18692 /* Potentially add a "return *this;" fix-it hint for
18693 assignment operators. */
18695 {
18698 && current_class_ref
18699 && same_type_ignoring_top_level_qualifiers_p
18703 }
18709 "no return statement in function returning "
18712 }
18714 /* Lambda closure members are implicitly constexpr if possible. */
18718 = ((processing_template_decl
18722 /* Save constexpr function body before it gets munged by
18723 the NRV transformation. */
18726 /* Invoke the pre-genericize plugin before we start munging things. */
18730 /* Perform delayed folding before NRV transformation. */
18736 /* Set up the named return value optimization, if we can. Candidate
18737 variables are selected in check_return_expr. */
18739 {
18743 }
18745 /* Must mark the RESULT_DECL as being in this function. */
18748 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
18749 to the FUNCTION_DECL node itself. */
18752 /* Store the end of the function, so that we get good line number
18753 info for the epilogue. */
18756 /* Complain about parameters that are only set, but never otherwise used. */
18758 && !processing_template_decl
18761 {
18762 tree decl;
18765 decl;
18779 OPT_Wunused_but_set_parameter,
18782 }
18784 /* Complain about locally defined typedefs that are not used in this
18785 function. */
18788 /* Possibly warn about unused parameters. */
18790 && !processing_template_decl
18794 /* Genericize before inlining. */
18800 /* If this function can't throw any exceptions, remember that. */
18803 && !flag_non_call_exceptions
18808 /* Emit the resumer and destroyer functions now, providing that we have
18809 not encountered some fatal error. */
18811 {
18814 }
18816 cleanup:
18817 /* We're leaving the context of this function, so zap cfun. It's still in
18818 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
18822 /* If this is an in-class inline definition, we may have to pop the
18823 bindings for the template parameters that we added in
18824 maybe_begin_member_template_processing when start_function was
18825 called. */
18829 /* Leave the scope of the class. */
18835 /* Clean up. */
18843 }
18844 \f
18845 /* Create the FUNCTION_DECL for a function definition.
18846 DECLSPECS and DECLARATOR are the parts of the declaration;
18847 they describe the return type and the name of the function,
18848 but twisted together in a fashion that parallels the syntax of C.
18850 This function creates a binding context for the function body
18851 as well as setting up the FUNCTION_DECL in current_function_decl.
18853 Returns a FUNCTION_DECL on success.
18855 If the DECLARATOR is not suitable for a function (it defines a datum
18856 instead), we return 0, which tells yyparse to report a parse error.
18858 May return void_type_node indicating that this method is actually
18859 a friend. See grokfield for more details.
18861 Came here with a `.pushlevel' .
18863 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
18864 CHANGES TO CODE IN `grokfield'. */
18866 tree
18869 {
18879 /* Pass friends other than inline friend functions back. */
18884 {
18889 }
18893 /* p1779 ABI-Isolation makes inline not a default for in-class
18894 definitions in named module purview. If the user explicitly
18895 made it inline, grokdeclarator will already have done the right
18896 things. */
18898 || flag_module_implicit_inline
18899 /* Lambda's operator function remains inline. */
18901 /* If the user explicitly asked for this to be inline, we don't
18902 need to do more, but more importantly we want to warn if we
18903 can't inline it. */
18905 {
18909 /* It's ok if we can't inline this. */
18911 }
18913 /* We process method specializations in finish_struct_1. */
18915 {
18916 /* Avoid calling decl_spec_seq... until we have to. */
18921 }
18924 {
18927 }
18933 }
18934 \f
18936 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
18937 we can lay it out later, when and if its type becomes complete.
18939 Also handle constexpr variables where the initializer involves
18940 an unlowered PTRMEM_CST because the class isn't complete yet. */
18942 void
18944 {
18947 /* Keep track of variables with incomplete types. */
18950 {
18958 /* RTTI TD entries are created while defining the type_info. */
18961 {
18964 }
18968 {
18969 /* When the outermost open class is complete we can resolve any
18970 pointers-to-members. */
18974 }
18975 }
18976 }
18978 /* Called when a class type (given by TYPE) is defined. If there are
18979 any existing VAR_DECLs whose type has been completed by this
18980 declaration, update them now. */
18982 void
18984 {
18989 {
18991 {
18998 {
18999 /* Complete the type of the variable. */
19004 }
19006 /* Remove this entry from the list. */
19008 }
19009 else
19010 ix++;
19011 }
19012 }
19014 /* If DECL is of a type which needs a cleanup, build and return an
19015 expression to perform that cleanup here. Return NULL_TREE if no
19016 cleanup need be done. DECL can also be a _REF when called from
19017 split_nonconstant_init_1. */
19019 tree
19021 {
19022 tree type;
19023 tree attr;
19024 tree cleanup;
19026 /* Assume no cleanup is required. */
19032 /* Handle "__attribute__((cleanup))". We run the cleanup function
19033 before the destructor since the destructor is what actually
19034 terminates the lifetime of the object. */
19037 else
19040 {
19041 tree id;
19042 tree fn;
19043 tree arg;
19045 /* Get the name specified by the user for the cleanup function. */
19047 /* Look up the name to find the cleanup function to call. It is
19048 important to use lookup_name here because that is what is
19049 used in c-common.cc:handle_cleanup_attribute when performing
19050 initial checks on the attribute. Note that those checks
19051 include ensuring that the function found is not an overloaded
19052 function, or an object with an overloaded call operator,
19053 etc.; we can rely on the fact that the function found is an
19054 ordinary FUNCTION_DECL. */
19062 }
19063 /* Handle ordinary C++ destructors. */
19066 {
19068 tree addr;
19069 tree call;
19073 else
19087 else
19089 }
19091 /* build_delete sets the location of the destructor call to the
19092 current location, even though the destructor is going to be
19093 called later, at the end of the current scope. This can lead to
19094 a "jumpy" behavior for users of debuggers when they step around
19095 the end of the block. So let's unset the location of the
19096 destructor call instead. */
19104 /* Treat objects with destructors as used; the destructor may do
19105 something substantive. */
19114 }
19116 \f
19117 /* Return the FUNCTION_TYPE that corresponds to MEMFNTYPE, which can be a
19118 FUNCTION_DECL, METHOD_TYPE, FUNCTION_TYPE, pointer or reference to
19119 METHOD_TYPE or FUNCTION_TYPE, or pointer to member function. */
19121 tree
19123 {
19124 tree fntype;
19125 tree args;
19138 fntype = (cp_build_type_attribute_variant
19142 }
19144 /* DECL was originally constructed as a non-static member function,
19145 but turned out to be static. Update it accordingly. */
19147 void
19149 {
19162 }
19164 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
19165 one of the language-independent trees. */
19167 enum cp_tree_node_structure_enum
19169 {
19171 {
19189 }
19190 }
19192 bool
19194 {
19195 /* A missing noreturn is ok for the `main' function. */
19197 }
19199 /* Return the decl used to identify the COMDAT group into which DECL should
19200 be placed. */
19202 tree
19204 {
19205 /* Virtual tables, construction virtual tables, and virtual table
19206 tables all go in a single COMDAT group, named after the primary
19207 virtual table. */
19210 /* For all other DECLs, the COMDAT group is the mangled name of the
19211 declaration itself. */
19212 else
19213 {
19215 {
19216 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
19217 into the same section as the target function. In that case
19218 we must return target's name. */
19224 else
19226 }
19227 }
19230 }
19232 /* Returns the return type for FN as written by the user, which may include
19233 a placeholder for a deduced return type. */
19235 tree
19237 {
19243 }
19245 /* Returns true iff DECL is a variable or function declared with an auto type
19246 that has not yet been deduced to a real type. */
19248 bool
19250 {
19257 }
19259 /* Complain if DECL has an undeduced return type. */
19261 bool
19263 {
19265 {
19269 {
19270 /* Set the return type of __builtin_source_location. */
19273 {
19276 }
19281 }
19289 }
19291 }
19293 /* Create a representation of the explicit-specifier with
19294 constant-expression of EXPR. COMPLAIN is as for tsubst. */
19296 tree
19298 {
19303 /* Wait for instantiation, tsubst_function_decl will handle it. */
19310 }