| blob | d19d09adde43b713b6c4149f0c3c4ed901f9d3d1 |
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 {
13395 gcc_rich_location bad_xobj_parm
13398 "only the first parameter of a member function "
13400 }
13404 }
13410 /* Say it's a definition only for the CALL_EXPR
13411 closest to the identifier. */
13414 /* Handle a late-specified return type. */
13417 {
13419 {
13426 {
13428 "%<auto%> type specifier without "
13431 "deduced return type only available "
13433 }
13435 {
13439 }
13440 }
13442 {
13444 "return type has %qT as its type rather "
13447 }
13449 {
13452 "%qs function with trailing return type "
13453 "has %<decltype(auto)%> as its type "
13455 else
13459 }
13465 {
13467 {
13468 auto_diagnostic_group g;
13475 }
13477 {
13479 "for %qT must have trailing return "
13484 }
13490 else
13494 }
13495 }
13498 {
13502 /* Not using maybe_warn_cpp0x because this should
13503 always be an error. */
13505 "trailing return type only available "
13507 else
13509 "return type not declared with %<auto%> "
13512 }
13514 {
13517 }
13523 {
13526 }
13529 {
13530 /* It's wrong, for instance, to issue a -Wignored-qualifiers
13531 warning for
13532 static_assert(!is_same_v<void(*)(), const void(*)()>);
13533 because there the qualifier matters. */
13537 /* [dcl.fct] "A volatile-qualified return type is
13538 deprecated." */
13541 "%<volatile%>-qualified return type is "
13544 /* We now know that the TYPE_QUALS don't apply to the
13545 decl, but to its return type. */
13547 }
13549 /* Error about some types functions can't return. */
13552 {
13556 }
13558 {
13562 }
13564 {
13566 "%<constinit%> on function return type is not "
13569 }
13576 && funcdecl_p
13582 {
13583 /* We are within a class's scope. If our declarator name
13584 is the same as the class name, and we are defining
13585 a function, then it is a constructor/destructor, and
13586 therefore returns a void type. */
13588 /* ISO C++ 12.4/2. A destructor may not be declared
13589 const or volatile. A destructor may not be static.
13590 A destructor may not be declared with ref-qualifier.
13592 ISO C++ 12.1. A constructor may not be declared
13593 const or volatile. A constructor may not be
13594 virtual. A constructor may not be static.
13595 A constructor may not be declared with ref-qualifier. */
13604 {
13609 }
13612 {
13618 }
13622 current_class_type,
13623 flags))
13627 {
13628 /* It's a constructor. */
13632 {
13636 }
13640 }
13643 }
13645 {
13647 {
13648 /* Cannot be both friend and virtual. */
13653 }
13658 {
13660 "cannot define friend function %qs in a local "
13663 }
13664 /* [class.friend]/6: A function can be defined in a friend
13665 declaration if the function name is unqualified. */
13667 {
13670 "friend function definition %qs cannot have "
13672 else
13674 "friend function definition %qs cannot have "
13676 in_namespace);
13677 }
13678 }
13680 {
13682 {
13685 }
13686 }
13688 {
13691 }
13694 {
13697 && (in_namespace
13700 "a non-member function cannot have "
13702 else
13703 {
13705 {
13706 auto_diagnostic_group d;
13708 "an explicit object member function cannot "
13713 }
13715 {
13716 auto_diagnostic_group d;
13718 "an explicit object member function cannot "
13722 }
13723 }
13724 }
13730 pushed_scope
13742 {
13748 }
13754 {
13756 /* transaction_safe applies to the type, but
13757 transaction_safe_dynamic applies to the function. */
13760 else
13762 }
13764 /* Actually apply the contract attributes to the declaration. */
13766 {
13769 {
13771 /* Intentionally reverse order of contracts so they're
13772 reversed back into their lexical order. */
13775 }
13776 else
13778 }
13781 /* [dcl.fct]/2:
13783 The optional attribute-specifier-seq appertains to
13784 the function type. */
13789 }
13795 /* Filter out pointers-to-references and references-to-references.
13796 We can get these if a TYPE_DECL is used. */
13799 {
13801 {
13804 }
13806 /* In C++0x, we allow reference to reference declarations
13807 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
13808 and template type arguments [14.3.1/4 temp.arg.type]. The
13809 check for direct reference to reference declarations, which
13810 are still forbidden, occurs below. Reasoning behind the change
13811 can be found in DR106, DR540, and the rvalue reference
13812 proposals. */
13814 {
13817 }
13818 }
13820 {
13825 }
13827 /* We now know that the TYPE_QUALS don't apply to the decl,
13828 but to the target of the pointer. */
13831 /* This code used to handle METHOD_TYPE, but I don't think it's
13832 possible to get it here anymore. */
13836 {
13840 memfn_quals,
13841 rqual);
13847 }
13855 type);
13857 /* When the pointed-to type involves components of variable size,
13858 care must be taken to ensure that the size evaluation code is
13859 emitted early enough to dominate all the possible later uses
13860 and late enough for the variables on which it depends to have
13861 been assigned.
13863 This is expected to happen automatically when the pointed-to
13864 type has a name/declaration of it's own, but special attention
13865 is required if the type is anonymous.
13867 We handle the NORMAL and FIELD contexts here by inserting a
13868 dummy statement that just evaluates the size at a safe point
13869 and ensures it is not deferred until e.g. within a deeper
13870 conditional context (c++/43555).
13872 We expect nothing to be needed here for PARM or TYPENAME.
13873 Evaluating the size at this point for TYPENAME would
13874 actually be incorrect, as we might be in the middle of an
13875 expression with side effects on the pointed-to type size
13876 "arguments" prior to the pointer declaration point and the
13877 size evaluation could end up prior to the side effects. */
13883 {
13887 }
13890 {
13891 /* In C++0x, the type we are creating a reference to might be
13892 a typedef which is itself a reference type. In that case,
13893 we follow the reference collapsing rules in
13894 [7.1.3/8 dcl.typedef] to create the final reference type:
13896 "If a typedef TD names a type that is a reference to a type
13897 T, an attempt to create the type 'lvalue reference to cv TD'
13898 creates the type 'lvalue reference to T,' while an attempt
13899 to create the type "rvalue reference to cv TD' creates the
13900 type TD."
13901 */
13905 {
13908 else
13910 }
13911 else
13912 type = cp_build_reference_type
13915 /* In C++0x, we need this check for direct reference to
13916 reference declarations, which are forbidden by
13917 [8.3.2/5 dcl.ref]. Reference to reference declarations
13918 are only allowed indirectly through typedefs and template
13919 type arguments. Example:
13921 void foo(int & &); // invalid ref-to-ref decl
13923 typedef int & int_ref;
13924 void foo(int_ref &); // valid ref-to-ref decl
13925 */
13929 }
13933 {
13937 /* We will already have complained. */
13939 else
13941 type);
13942 }
13943 else
13946 /* Process a list of type modifier keywords (such as
13947 const or volatile) that were given inside the `*' or `&'. */
13950 {
13951 type
13955 }
13957 /* Apply C++11 attributes to the pointer, and not to the
13958 type pointed to. This is unlike what is done for GNU
13959 attributes above. It is to comply with [dcl.ptr]/1:
13961 [the optional attribute-specifier-seq (7.6.1) appertains
13962 to the pointer and not to the object pointed to]. */
13975 }
13976 }
13981 /* Don't check this if it can be the artifical decltype(auto)
13982 we created when building a constraint in a compound-requirement:
13983 that the type-constraint is plain is going to be checked in
13984 cp_parser_compound_requirement. */
13989 /* A `constexpr' specifier used in an object declaration declares
13990 the object as `const'. */
13992 {
13993 /* DR1688 says that a `constexpr' specifier in combination with
13994 `volatile' is valid. */
13997 {
14000 }
14001 }
14006 {
14008 unqualified_id);
14010 }
14012 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
14013 qualified with a class-name, turn it into a METHOD_TYPE, unless
14014 we know that the function is static. We take advantage of this
14015 opportunity to do other processing that pertains to entities
14016 explicitly declared to be class members. Note that if DECLARATOR
14017 is non-NULL, we know it is a cdk_id declarator; otherwise, we
14018 would not have exited the loop above. */
14023 {
14029 {
14031 {
14033 "member functions are implicitly "
14036 }
14037 else
14040 }
14042 can skip the following checks. */
14045 qualifying type must certainly be complete. */
14046 funcdef_flag
14047 /* A friend declaration of "T::f" is OK, even if
14048 "T" is a template parameter. But, if this
14049 function is not a friend, the qualifying type
14050 must be a class. */
14052 /* For a declaration, the type need not be
14053 complete, if either it is dependent (since there
14054 is no meaningful definition of complete in that
14055 case) or the qualifying class is currently being
14056 defined. */
14059 /* Check that the qualifying type is complete. */
14063 {
14066 {
14074 }
14075 }
14077 {
14081 }
14082 }
14087 /* Now TYPE has the actual type. */
14090 {
14093 else
14095 }
14101 {
14102 /* [dcl.meaning]/1: The optional attribute-specifier-seq following
14103 a declarator-id appertains to the entity that is declared. */
14106 else
14107 /* We should have already diagnosed the issue (c++/78344). */
14109 }
14111 /* Handle parameter packs. */
14113 {
14115 /* Turn the type into a pack expansion.*/
14117 else
14119 }
14122 && !processing_template_decl
14124 {
14128 else
14132 }
14135 {
14136 /* [dcl.fct.spec] (C++11) The explicit specifier shall be used only
14137 in the declaration of a constructor or conversion function within
14138 a class definition. */
14145 else
14147 "only declarations of constructors and conversion operators "
14150 }
14153 {
14156 {
14158 name);
14160 }
14162 {
14165 name);
14167 }
14169 {
14171 name);
14173 }
14175 {
14177 name);
14179 }
14181 {
14183 name);
14185 }
14187 {
14189 name);
14191 }
14192 }
14194 /* If this is declaring a typedef name, return a TYPE_DECL. */
14196 {
14198 tree decl;
14201 {
14205 else
14209 }
14211 /* This declaration:
14213 typedef void f(int) const;
14215 declares a function type which is not a member of any
14216 particular class, but which is cv-qualified; for
14217 example "f S::*" declares a pointer to a const-qualified
14218 member function of S. We record the cv-qualification in the
14219 function type. */
14221 {
14224 /* We have now dealt with these qualifiers. */
14227 }
14230 {
14234 else
14238 }
14244 {
14247 }
14251 else
14255 {
14259 /* The TYPE_DECL is "abstract" because there will be
14260 clones of this constructor/destructor, and there will
14261 be copies of this TYPE_DECL generated in those
14262 clones. The decloning optimization (for space) may
14263 revert this subsequently if it determines that
14264 the clones should share a common implementation. */
14268 }
14273 unqualified_id);
14275 /* If the user declares "typedef struct {...} foo" then the
14276 struct will have an anonymous name. Fill that name in now.
14277 Nothing can refer to it, so nothing needs know about the name
14278 change. */
14280 && unqualified_id
14299 /* Acknowledge that this was written:
14300 `using analias = atype;'. */
14304 }
14306 /* Detect the case of an array type of unspecified size
14307 which came, as such, direct from a typedef name.
14308 We must copy the type, so that the array's domain can be
14309 individually set by the object's initializer. */
14316 /* Detect where we're using a typedef of function type to declare a
14317 function. PARMS will not be set, so we must create it now. */
14320 {
14322 tree args;
14327 {
14333 }
14338 {
14339 /* The qualifiers on the function type become the qualifiers on
14340 the non-static member function. */
14345 }
14346 }
14348 /* If this is a type name (such as, in a cast or sizeof),
14349 compute the type and return it now. */
14352 {
14353 /* Note that here we don't care about type_quals. */
14355 /* Special case: "friend class foo" looks like a TYPENAME context. */
14357 {
14359 {
14362 }
14365 {
14366 /* Don't allow friend declaration without a class-key. */
14373 else
14376 type);
14377 }
14379 /* Only try to do this stuff if we didn't already give up. */
14381 {
14382 /* A friendly class? */
14386 else
14388 type);
14391 }
14392 }
14394 {
14401 /* Core issue #547: need to allow this in template type args.
14402 Allow it in general in C++11 for alias-declarations. */
14406 else
14408 }
14414 }
14418 && ! bitfield
14420 {
14423 }
14426 {
14427 /* Only functions may be declared using an operator-function-id. */
14429 {
14432 }
14437 type);
14438 }
14440 /* We don't check parameter types here because we can emit a better
14441 error message later. */
14443 {
14447 }
14449 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
14450 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
14453 {
14459 {
14462 {
14467 {
14468 auto_diagnostic_group g;
14472 "missing template argument list after %qE; template "
14478 }
14482 else
14483 /* Do not issue an error while tentatively parsing a function
14484 parameter: for T t(auto(a), 42);, when we just saw the 1st
14485 parameter, we don't know yet that this construct won't be
14486 a function declaration. Defer the checking to
14487 cp_parser_parameter_declaration_clause. */
14489 }
14490 else
14494 }
14496 /* A parameter declared as an array of T is really a pointer to T.
14497 One declared as a function is really a pointer to a function.
14498 One declared as a member is really a pointer to member. */
14501 {
14502 /* Transfer const-ness of array into that of type pointed to. */
14506 }
14509 }
14512 /* Don't convert xobj member functions to METHOD_TYPE. */
14513 && !is_xobj_member_function
14514 && !(unqualified_id
14517 {
14523 }
14525 {
14529 {
14537 }
14539 {
14542 {
14548 else
14552 }
14554 /* The C99 flexible array extension. */
14557 {
14561 {
14564 }
14565 else
14566 {
14567 /* Array is a flexible member. */
14571 else
14575 /* Flexible array member has a null domain. */
14577 }
14578 }
14581 {
14582 /* Happens when declaring arrays of sizes which
14583 are error_mark_node, for example. */
14585 }
14587 {
14588 /* Something like struct S { int N::j; }; */
14591 }
14593 {
14595 tree function_context;
14598 {
14599 /* This should never happen in pure C++ (the check
14600 could be an assert). It could happen in
14601 Objective-C++ if someone writes invalid code that
14602 uses a function declaration for an instance
14603 variable or property (instance variables and
14604 properties are parsed as FIELD_DECLs, but they are
14605 part of an Objective-C class, not a C++ class).
14606 That code is invalid and is caught by this
14607 check. */
14609 {
14611 unqualified_id);
14613 }
14615 /* ``A union may [ ... ] not [ have ] virtual functions.''
14616 ARM 9.5 */
14618 {
14621 unqualified_id);
14623 }
14628 {
14630 "%qD cannot be declared %<virtual%>, since it "
14633 }
14634 }
14636 /* Check that the name used for a destructor makes sense. */
14638 {
14642 {
14647 }
14650 {
14654 }
14656 {
14660 }
14662 {
14664 "%<constexpr%> destructors only available"
14667 }
14669 {
14673 }
14674 }
14676 {
14681 }
14684 {
14688 }
14690 {
14694 }
14698 {
14702 }
14705 {
14708 {
14714 }
14715 }
14717 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
14718 function_context
14727 parms,
14728 unqualified_id,
14729 declspecs,
14730 reqs,
14743 #if 0
14744 /* This clobbers the attrs stored in `decl' from `attrlist'. */
14745 /* The decl and setting of decl_attr is also turned off. */
14747 #endif
14749 /* [class.conv.ctor]
14751 A constructor declared without the function-specifier
14752 explicit that can be called with a single parameter
14753 specifies a conversion from the type of its first
14754 parameter to the type of its class. Such a constructor
14755 is called a converting constructor. */
14761 }
14763 && ((current_class_type
14769 {
14772 {
14774 {
14778 }
14779 else
14784 }
14785 }
14787 staticp
14788 ? TCTX_STATIC_STORAGE
14790 {
14793 }
14794 else
14795 {
14797 {
14800 "%qE is neither function nor member function; "
14802 else
14806 }
14808 }
14811 {
14812 /* Packages tend to use GNU attributes on friends, so we only
14813 warn for standard attributes. */
14815 && !funcdef_flag
14818 {
14823 }
14824 /* Friends are treated specially. */
14828 {
14832 /* Kludge: We need funcdef_flag to be true in do_friend for
14833 in-class defaulted functions, but that breaks grokfndecl.
14834 So set it here. */
14844 }
14845 else
14847 }
14849 /* Structure field. It may not be a function, except for C++. */
14852 {
14854 {
14855 /* C++ allows static class members. All other work
14856 for this is done by grokfield. */
14861 {
14863 template_count,
14867 }
14874 {
14876 "%<constexpr%> static data member %qD must "
14879 }
14890 /* Even if there is an in-class initialization, DECL
14891 is considered undefined until an out-of-class
14892 definition is provided, unless this is an inline
14893 variable. */
14897 {
14903 }
14905 /* Set the constraints on the declaration. */
14909 {
14912 }
14913 }
14914 else
14915 {
14917 {
14923 }
14925 {
14930 }
14932 {
14937 }
14939 {
14944 }
14951 {
14954 }
14957 {
14958 /* An attempt is being made to initialize a non-static
14959 member. This is new in C++11. */
14962 /* If this has been parsed with static storage class, but
14963 errors forced staticp to be cleared, ensure NSDMI is
14964 not present. */
14967 }
14968 }
14975 }
14976 }
14978 {
14979 tree original_name;
14987 else
14989 // FIXME:gcc_assert (original_name == dname);
14997 name);
14999 {
15003 name);
15004 else
15006 "storage class %<thread_local%> invalid for "
15008 }
15016 /* Function declaration not at top level.
15017 Storage classes other than `extern' are not allowed
15018 and `extern' makes no difference. */
15023 {
15026 "%<static%> specifier invalid for function %qs "
15028 else
15030 "%<inline%> specifier invalid for function %qs "
15032 }
15035 {
15037 {
15040 }
15043 {
15048 }
15049 }
15053 {
15057 }
15059 /* Record whether the function is public. */
15064 declspecs,
15067 publicp,
15072 funcdef_flag,
15073 late_return_type_p,
15075 id_loc);
15082 {
15085 /* Don't allow a static member function in a class, and forbid
15086 declaring main to be static. */
15088 {
15092 }
15094 {
15095 /* 7.1.1: There can be no static function declarations within a
15096 block. */
15100 }
15103 {
15106 }
15107 }
15110 }
15111 else
15112 {
15113 /* It's a variable. */
15115 /* An uninitialized decl with `extern' is a reference. */
15117 declspecs,
15118 initialized,
15119 type_quals,
15120 inlinep,
15121 concept_p,
15122 template_count,
15124 id_loc);
15134 {
15137 {
15139 "%<static%> may not be used when defining "
15143 }
15145 {
15148 }
15150 {
15152 "cannot explicitly declare member %q#D to have "
15155 }
15156 }
15158 {
15160 "declaration of %<constexpr%> variable %qD "
15163 }
15165 {
15169 }
15174 {
15179 }
15180 }
15185 {
15189 }
15192 {
15194 {
15195 /* It's common practice (and completely valid) to have a const
15196 be initialized and declared extern. */
15200 }
15201 else
15202 {
15206 }
15207 }
15209 /* Record `register' declaration for warnings on &
15210 and in case doing stupid register allocation. */
15213 {
15215 /* Warn about register storage specifiers on PARM_DECLs. */
15217 {
15220 "ISO C++17 does not allow %<register%> storage "
15222 else
15225 }
15226 }
15233 {
15234 /* Set constexpr flag on vars (functions got it in grokfndecl). */
15237 /* And the constinit flag (which only applies to variables). */
15240 }
15242 {
15243 /* If we saw a return type, record its location. */
15248 {
15254 }
15257 }
15259 /* Record constancy and volatility on the DECL itself . There's
15260 no need to do this when processing a template; we'll do this
15261 for the instantiated declaration based on the type of DECL. */
15266 }
15267 }
15268 \f
15269 /* Subroutine of start_function. Ensure that each of the parameter
15270 types (as listed in PARMS) is complete, as is required for a
15271 function definition. */
15273 static void
15275 {
15277 {
15282 {
15289 }
15290 else
15291 /* grokparms or complete_type_or_else will have already issued
15292 an error. */
15294 }
15295 }
15297 /* Returns nonzero if T is a local variable. */
15299 int
15301 {
15310 }
15312 /* Like local_variable_p, but suitable for use as a tree-walking
15313 function. */
15315 static tree
15318 {
15320 {
15321 /* DR 2082 permits local variables in unevaluated contexts
15322 within a default argument. */
15325 }
15334 }
15336 /* Check that ARG, which is a default-argument expression for a
15337 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
15338 something goes wrong. DECL may also be a _TYPE node, rather than a
15339 DECL, if there is no DECL available. */
15341 tree
15343 {
15344 tree var;
15345 tree decl_type;
15348 /* We get a DEFERRED_PARSE when looking at an in-class declaration
15349 with a default argument. Ignore the argument for now; we'll
15350 deal with it after the class is complete. */
15354 {
15357 }
15358 else
15365 /* Something already went wrong. There's no need to check
15366 further. */
15369 /* [dcl.fct.default]
15371 A default argument expression is implicitly converted to the
15372 parameter type. */
15374 /* Avoid digest_init clobbering the initializer. */
15377 LOOKUP_IMPLICIT);
15380 /* Avoid redundant -Wzero-as-null-pointer-constant warnings at
15381 the call sites. */
15384 /* Don't lose side-effects as in PR90473. */
15388 /* [dcl.fct.default]
15390 Local variables shall not be used in default argument
15391 expressions.
15393 The keyword `this' shall not be used in a default argument of a
15394 member function. */
15397 {
15399 {
15403 else
15405 }
15407 }
15409 /* All is well. */
15411 }
15413 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
15415 static tree
15417 {
15422 {
15425 else
15426 {
15429 }
15430 }
15432 /* Do warn about using typedefs to a deprecated class. */
15444 return type_is_deprecated
15448 }
15450 /* Returns an unavailable type used within TYPE, or NULL_TREE if none. */
15452 static tree
15454 {
15459 {
15462 else
15463 {
15466 }
15467 }
15469 /* Do warn about using typedefs to a deprecated class. */
15481 return type_is_unavailable
15485 }
15487 /* Decode the list of parameter types for a function type.
15488 Given the list of things declared inside the parens,
15489 return a list of types.
15491 If this parameter does not end with an ellipsis, we append
15492 void_list_node.
15494 *PARMS is set to the chain of PARM_DECLs created. */
15496 tree
15498 {
15501 tree parm;
15505 {
15514 {
15517 }
15521 {
15523 && !init
15526 /* DR 577: A parameter list consisting of a single
15527 unnamed parameter of non-dependent type 'void'. */
15531 "invalid use of cv-qualified type %qT in "
15533 else
15535 "invalid use of type %<void%> in parameter "
15537 /* It's not a good idea to actually create parameters of
15538 type `void'; other parts of the compiler assume that a
15539 void type terminates the parameter list. */
15542 }
15545 {
15547 {
15551 }
15554 {
15558 }
15560 /* [dcl.fct] "A parameter with volatile-qualified type is
15561 deprecated." */
15564 "%<volatile%>-qualified parameter is "
15567 /* Top-level qualifiers on the parameters are
15568 ignored for function types. */
15571 {
15575 }
15577 {
15578 /* Before C++17 DR 393:
15579 [dcl.fct]/6, parameter types cannot contain pointers
15580 (references) to arrays of unknown bound. */
15585 {
15593 }
15596 ptr
15602 }
15606 }
15611 }
15621 /* We had parm errors, recover by giving the function (...) type. */
15625 }
15627 \f
15628 /* D is a constructor or overloaded `operator='.
15630 Let T be the class in which D is declared. Then, this function
15631 returns:
15633 -1 if D's is an ill-formed constructor or copy assignment operator
15634 whose first parameter is of type `T'.
15635 0 if D is not a copy constructor or copy assignment
15636 operator.
15637 1 if D is a copy constructor or copy assignment operator whose
15638 first parameter is a reference to non-const qualified T.
15639 2 if D is a copy constructor or copy assignment operator whose
15640 first parameter is a reference to const qualified T.
15642 This function can be used as a predicate. Positive values indicate
15643 a copy constructor and nonzero values indicate a copy assignment
15644 operator. */
15646 int
15648 {
15649 tree args;
15650 tree arg_type;
15658 /* Instantiations of template member functions are never copy
15659 functions. Note that member functions of templated classes are
15660 represented as template functions internally, and we must
15661 accept those as copy functions. */
15669 {
15673 /* Reject unrelated object parameters. */
15678 }
15679 else
15689 {
15690 /* Pass by value copy assignment operator. */
15692 }
15696 {
15699 }
15700 else
15706 /* There are more non-optional args. */
15710 }
15712 /* D is a constructor or overloaded `operator='.
15714 Let T be the class in which D is declared. Then, this function
15715 returns true when D is a move constructor or move assignment
15716 operator, false otherwise. */
15718 bool
15720 {
15722 /* There are no move constructors if we are in C++98 mode. */
15728 /* Instantiations of template member functions are never move
15729 functions. Note that member functions of templated classes are
15730 represented as template functions internally, and we must
15731 accept those as move functions. */
15735 }
15737 /* D is a constructor or overloaded `operator='.
15739 Then, this function returns true when D has the same signature as a move
15740 constructor or move assignment operator (because either it is such a
15741 ctor/op= or it is a template specialization with the same signature),
15742 false otherwise. */
15744 bool
15746 {
15747 tree args;
15748 tree arg_type;
15756 {
15760 /* Reject unrelated object parameters. */
15765 }
15766 else
15784 /* There are more non-optional args. */
15788 }
15790 /* Remember any special properties of member function DECL. */
15792 void
15794 {
15795 tree class_type;
15803 {
15810 {
15811 /* [class.copy]
15813 A non-template constructor for class X is a copy
15814 constructor if its first parameter is of type X&, const
15815 X&, volatile X& or const volatile X&, and either there
15816 are no other parameters or else all other parameters have
15817 default arguments. */
15821 }
15832 }
15834 {
15835 /* [class.copy]
15837 A non-template assignment operator for class X is a copy
15838 assignment operator if its parameter is of type X, X&, const
15839 X&, volatile X& or const volatile X&. */
15844 {
15848 }
15849 }
15853 /* Destructors are handled in check_methods. */
15854 }
15856 /* Check a constructor DECL has the correct form. Complains
15857 if the class has a constructor of the form X(X). */
15859 bool
15861 {
15865 {
15866 /* [class.copy]
15868 A declaration of a constructor for a class X is ill-formed if
15869 its first parameter is of type (optionally cv-qualified) X
15870 and either there are no other parameters or else all other
15871 parameters have default arguments.
15873 We *don't* complain about member template instantiations that
15874 have this form, though; they can occur as we try to decide
15875 what constructor to use during overload resolution. Since
15876 overload resolution will never prefer such a constructor to
15877 the non-template copy constructor (which is either explicitly
15878 or implicitly defined), there's no need to worry about their
15879 existence. Theoretically, they should never even be
15880 instantiated, but that's hard to forestall. */
15885 }
15888 }
15890 /* DECL is a declaration for an overloaded or conversion operator. If
15891 COMPLAIN is true, errors are issued for invalid declarations. */
15893 bool
15895 {
15905 tree_code operator_code;
15908 {
15909 /* Conversion operators are TYPE_EXPR for the purposes of this
15910 function. */
15913 }
15914 else
15915 {
15922 }
15925 {
15926 /* operator new and operator delete are quite special. */
15929 {
15948 }
15950 /* [basic.std.dynamic.allocation]/1:
15952 A program is ill-formed if an allocation function is declared
15953 in a namespace scope other than global scope or declared
15954 static in global scope.
15956 The same also holds true for deallocation functions. */
15958 {
15960 {
15962 decl);
15964 }
15967 {
15970 }
15971 }
15974 {
15977 }
15978 else
15979 {
15982 }
15985 }
15987 /* An operator function must either be a non-static member function
15988 or have at least one parameter of a class, a reference to a class,
15989 an enumeration, or a reference to an enumeration. 13.4.0.6 */
15991 {
15995 {
15998 }
16001 {
16003 {
16006 }
16008 /* For lambdas we diagnose static lambda specifier elsewhere. */
16010 /* For instantiations, we have diagnosed this already. */
16014 decl);
16016 /* static operator[] should have exactly one argument
16017 for C++20 and earlier, so that it isn't multidimensional. */
16019 }
16021 {
16025 }
16026 else
16028 {
16030 {
16035 }
16041 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
16042 because these checks are performed even on template
16043 functions. */
16047 }
16048 }
16051 /* There are no further restrictions on the arguments to an overloaded
16052 "operator ()". */
16055 /* C++23 allows an arbitrary number of parameters and default arguments for
16056 operator[], and none of the other checks below apply. */
16061 {
16062 /* 13.4.0.3 */
16065 }
16067 /* Count the number of arguments and check for ellipsis. */
16070 {
16072 {
16074 decl);
16076 }
16078 }
16079 /* FIXME: We need tests for these errors with xobj member functions. */
16080 /* Verify correct number of arguments. */
16082 {
16085 {
16086 /* We have a unary instance of an ambi-ary op. Remap to the
16087 unary one. */
16093 }
16095 {
16096 /* This was an ambiguous operator but is invalid. */
16098 methodp
16102 }
16105 && ! processing_template_decl
16106 /* x++ and x--'s second argument must be an int. */
16108 integer_type_node))
16109 {
16111 methodp
16114 decl);
16116 }
16121 {
16123 methodp
16127 }
16132 {
16134 methodp
16138 }
16143 }
16145 /* There can be no default arguments. */
16149 {
16153 }
16155 /* At this point the declaration is well-formed. It may not be
16156 sensible though. */
16158 /* Check member function warnings only on the in-class declaration.
16159 There's no point warning on an out-of-class definition. */
16163 /* Warn about conversion operators that will never be used. */
16167 {
16178 {
16181 ref
16186 class_type);
16187 /* Don't force t to be complete here. */
16192 ref
16198 }
16199 }
16204 /* Effective C++ rules below. */
16206 /* More Effective C++ rule 7. */
16213 /* More Effective C++ rule 6. */
16218 {
16227 {
16232 }
16233 else
16234 {
16238 }
16239 }
16241 /* Effective C++ rule 23. */
16252 }
16253 \f
16254 /* Return a string giving the keyword associate with CODE. */
16258 {
16260 {
16273 }
16274 }
16276 /* Name lookup in an elaborated-type-specifier (after the keyword
16277 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
16278 elaborated-type-specifier is invalid, issue a diagnostic and return
16279 error_mark_node; otherwise, return the *_TYPE to which it referred.
16280 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
16282 tree
16284 tree decl,
16286 {
16287 tree type;
16289 /* In the case of:
16291 struct S { struct S *p; };
16293 name lookup will find the TYPE_DECL for the implicit "S::S"
16294 typedef. Adjust for that here. */
16300 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
16301 is false for this case as well. */
16303 {
16307 }
16308 /* Accept template template parameters. */
16312 ;
16313 /* [dcl.type.elab]
16315 If the identifier resolves to a typedef-name or the
16316 simple-template-id resolves to an alias template
16317 specialization, the elaborated-type-specifier is ill-formed.
16319 In other words, the only legitimate declaration to use in the
16320 elaborated type specifier is the implicit typedef created when
16321 the type is declared. */
16325 {
16329 else
16334 }
16339 {
16343 }
16346 {
16350 }
16354 {
16355 /* If a class template appears as elaborated type specifier
16356 without a template header such as:
16358 template <class T> class C {};
16359 void f(class C); // No template header here
16361 then the required template argument is missing. */
16366 }
16369 }
16371 /* Lookup NAME of an elaborated type specifier according to SCOPE and
16372 issue diagnostics if necessary. Return *_TYPE node upon success,
16373 NULL_TREE when the NAME is not found, and ERROR_MARK_NODE for type
16374 error. */
16376 static tree
16379 {
16380 tree decl;
16382 {
16383 /* First try ordinary name lookup, ignoring hidden class name
16384 injected via friend declaration. */
16387 /* If that fails, the name will be placed in the smallest
16388 non-class, non-function-prototype scope according to 3.3.1/5.
16389 We may already have a hidden name declared as friend in this
16390 scope. So lookup again but not ignoring hidden names.
16391 If we find one, that name will be made visible rather than
16392 creating a new tag. */
16395 }
16396 else
16400 /* We found nothing. */
16404 {
16408 }
16411 && !template_header_p
16413 {
16418 }
16421 /* If scope is TAG_how::CURRENT_ONLY we're defining a class,
16422 so ignore a template template parameter. */
16427 /* Found not-a-type. */
16430 /* Look for invalid nested type:
16431 class C {
16432 class C {};
16433 }; */
16435 {
16439 }
16441 /* Two cases we need to consider when deciding if a class
16442 template is allowed as an elaborated type specifier:
16443 1. It is a self reference to its own class.
16444 2. It comes with a template header.
16446 For example:
16448 template <class T> class C {
16449 class C *c1; // DECL_SELF_REFERENCE_P is true
16450 class D;
16451 };
16452 template <class U> class C; // template_header_p is true
16453 template <class T> class C<T>::D {
16454 class C *c2; // DECL_SELF_REFERENCE_P is true
16455 }; */
16458 template_header_p
16463 {
16472 }
16475 }
16477 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
16478 Define the tag as a forward-reference if it is not defined.
16480 If a declaration is given, process it here, and report an error if
16481 multiple declarations are not identical.
16483 SCOPE is TS_CURRENT when this is also a definition. Only look in
16484 the current frame for the name (since C++ allows new names in any
16485 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
16486 declaration. Only look beginning from the current scope outward up
16487 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
16489 TEMPLATE_HEADER_P is true when this declaration is preceded by
16490 a set of template parameters. */
16492 tree
16495 {
16504 {
16517 }
16519 /* In case of anonymous name, xref_tag is only called to
16520 make type node and push name. Name lookup is not required. */
16531 {
16535 /* Since HOW is not TAG_how::CURRENT_ONLY, we are not looking at
16536 a definition of this tag. Since, in addition, we are
16537 currently processing a (member) template declaration of a
16538 template class, we must be very careful; consider:
16540 template <class X> struct S1
16542 template <class U> struct S2
16543 {
16544 template <class V> friend struct S1;
16545 };
16547 Here, the S2::S1 declaration should not be confused with the
16548 outer declaration. In particular, the inner version should
16549 have a template parameter of level 2, not level 1.
16551 On the other hand, when presented with:
16553 template <class T> struct S1
16554 {
16555 template <class U> struct S2 {};
16556 template <class U> friend struct S2;
16557 };
16559 the friend must find S1::S2 eventually. We accomplish this
16560 by making sure that the new type we create to represent this
16561 declaration has the right TYPE_CONTEXT. */
16564 }
16567 {
16568 /* If no such tag is yet defined, create a forward-reference node
16569 and record it as the "definition".
16570 When a real declaration of this type is found,
16571 the forward-reference will be altered into a real type. */
16573 {
16576 }
16581 /* Mark it as a lambda type right now. Our caller will
16582 correct the value. */
16585 }
16586 else
16587 {
16589 {
16590 /* Check that we aren't trying to overload a class with different
16591 constraints. */
16595 }
16599 {
16603 }
16607 {
16610 {
16611 auto_diagnostic_group d;
16615 }
16622 {
16623 auto_diagnostic_group d;
16627 }
16636 {
16637 /* Push it into this TU's symbol slot. */
16640 /* We're in the template parm binding level.
16641 Pushtag has logic to slide under that, but we're
16642 not pushing a *new* type. */
16648 }
16651 }
16652 }
16655 }
16657 /* Create the binfo hierarchy for REF with (possibly NULL) base list
16658 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
16659 access_* node, and the TREE_VALUE is the type of the base-class.
16660 Non-NULL TREE_TYPE indicates virtual inheritance. */
16662 void
16664 {
16671 tree default_access;
16677 /* The base of a derived class is private by default, all others are
16678 public. */
16683 /* First, make sure that any templates in base-classes are
16684 instantiated. This ensures that if we call ourselves recursively
16685 we do not get confused about which classes are marked and which
16686 are not. */
16689 {
16692 /* The dependent_type_p call below should really be dependent_scope_p
16693 so that we give a hard error about using an incomplete type as a
16694 base, but we allow it with a pedwarn for backward
16695 compatibility. */
16701 /* An incomplete type. Remove it from the list. */
16703 else
16704 {
16705 max_bases++;
16707 max_dvbases++;
16711 }
16712 }
16717 /* The binfo slot should be empty, unless this is an (ill-formed)
16718 redefinition. */
16729 /* Apply base-class info set up to the variants of this type. */
16733 {
16735 /* A C++98 POD cannot have base classes. */
16739 {
16742 }
16743 }
16750 {
16751 /* An aggregate can't have virtual base classes. */
16759 }
16762 {
16770 /* Before C++17, an aggregate cannot have base classes. In C++17, an
16771 aggregate can't have virtual, private, or protected base classes. */
16782 {
16784 basetype);
16786 }
16790 {
16792 /* The original basetype could have been a typedef'd type. */
16795 /* Inherit flags from the base. */
16806 }
16808 /* We must do this test after we've seen through a typedef
16809 type. */
16811 {
16814 else
16817 }
16820 /* Regenerate the pack expansion for the bases. */
16834 dropped_base:
16835 /* Update max_vbases to reflect the reality that we are dropping
16836 this base: if it reaches zero we want to undo the vec_alloc
16837 above to avoid inconsistencies during error-recovery: eg, in
16838 build_special_member_call, CLASSTYPE_VBASECLASSES non null
16839 and vtt null (c++/27952). */
16841 max_vbases--;
16843 max_vbases
16845 }
16852 /* If we didn't get max_vbases vbases, we must have shared at
16853 least one of them, and are therefore diamond shaped. */
16856 /* Unmark all the types. */
16861 /* Now see if we have a repeated base type. */
16863 {
16866 {
16868 {
16871 }
16873 }
16878 else
16880 }
16881 }
16883 \f
16884 /* Copies the enum-related properties from type SRC to type DST.
16885 Used with the underlying type of an enum and the enum itself. */
16886 static void
16888 {
16889 tree t;
16891 {
16901 else
16905 }
16906 }
16908 /* Begin compiling the definition of an enumeration type.
16909 NAME is its name,
16911 if ENUMTYPE is not NULL_TREE then the type has alredy been found.
16913 UNDERLYING_TYPE is the type that will be used as the storage for
16914 the enumeration type. This should be NULL_TREE if no storage type
16915 was specified.
16917 ATTRIBUTES are any attributes specified after the enum-key.
16919 SCOPED_ENUM_P is true if this is a scoped enumeration type.
16921 if IS_NEW is not NULL, gets TRUE iff a new type is created.
16923 Returns the type object, as yet incomplete.
16924 Also records info about it so that build_enumerator
16925 may be used to declare the individual values as they are read. */
16927 tree
16930 {
16936 /* [C++0x dcl.enum]p5:
16938 If not explicitly specified, the underlying type of a scoped
16939 enumeration type is int. */
16946 /* If this is the real definition for a previous forward reference,
16947 fill in the contents in the same object that used to be the
16948 forward reference. */
16954 /* In case of a template_decl, the only check that should be deferred
16955 to instantiation time is the comparison of underlying types. */
16957 {
16958 /* Attempt to set the declaring module. */
16960 {
16963 {
16964 auto_diagnostic_group d;
16968 }
16969 else
16971 }
16974 ;
16976 {
16977 auto_diagnostic_group d;
16983 }
16985 {
16986 auto_diagnostic_group d;
16992 }
16996 {
16997 auto_diagnostic_group d;
17003 }
17004 }
17008 {
17009 /* In case of error, make a dummy enum to allow parsing to
17010 continue. */
17012 {
17015 }
17017 /* enumtype may be an ENUMERAL_TYPE if this is a redefinition
17018 of an opaque enum, or an opaque enum of an already defined
17019 enumeration (C++11).
17020 In any other case, it'll be NULL_TREE. */
17022 {
17025 }
17028 /* Do not push the decl more than once. */
17031 {
17035 /* std::byte aliases anything. */
17040 }
17041 else
17047 /* The enum is considered opaque until the opening '{' of the
17048 enumerator list. */
17051 }
17058 {
17060 /* We already checked that it matches, don't change it to a different
17063 {
17066 }
17069 else
17070 {
17074 }
17075 }
17077 /* If into a template class, the returned enum is always the first
17078 declaration (opaque or not) seen. This way all the references to
17079 this type will be to the same declaration. The following ones are used
17080 only to check for definition errors. */
17083 else
17085 }
17087 /* After processing and defining all the values of an enumeration type,
17088 install their decls in the enumeration type.
17089 ENUMTYPE is the type object. */
17091 void
17093 {
17094 tree values;
17095 tree underlying_type;
17096 tree decl;
17097 tree value;
17099 tree t;
17101 bool fixed_underlying_type_p
17104 /* We built up the VALUES in reverse order. */
17107 /* For an enum defined in a template, just set the type of the values;
17108 all further processing is postponed until the template is
17109 instantiated. We need to set the type so that tsubst of a CONST_DECL
17110 works. */
17112 {
17114 values;
17118 }
17120 /* Determine the minimum and maximum values of the enumerators. */
17122 {
17126 values;
17128 {
17131 /* [dcl.enum]: Following the closing brace of an enum-specifier,
17132 each enumerator has the type of its enumeration. Prior to the
17133 closing brace, the type of each enumerator is the type of its
17134 initializing value. */
17137 /* Update the minimum and maximum values, if appropriate. */
17141 /* Figure out what the minimum and maximum values of the
17142 enumerators are. */
17149 }
17150 }
17151 else
17152 /* [dcl.enum]
17154 If the enumerator-list is empty, the underlying type is as if
17155 the enumeration had a single enumerator with value 0. */
17159 {
17160 /* Compute the number of bits require to represent all values of the
17161 enumeration. We must do this before the type of MINNODE and
17162 MAXNODE are transformed, since tree_int_cst_min_precision relies
17163 on the TREE_TYPE of the value it is passed. */
17171 /* Determine the underlying type of the enumeration.
17173 [dcl.enum]
17175 The underlying type of an enumeration is an integral type that
17176 can represent all the enumerator values defined in the
17177 enumeration. It is implementation-defined which integral type is
17178 used as the underlying type for an enumeration except that the
17179 underlying type shall not be larger than int unless the value of
17180 an enumerator cannot fit in an int or unsigned int.
17182 We use "int" or an "unsigned int" as the underlying type, even if
17183 a smaller integral type would work, unless the user has
17184 explicitly requested that we use the smallest possible type. The
17185 user can request that for all enumerations with a command line
17186 flag, or for just one enumeration with an attribute. */
17188 use_short_enum = flag_short_enums
17191 /* If the precision of the type was specified with an attribute and it
17192 was too small, give an error. Otherwise, use it. */
17194 {
17197 else
17198 {
17201 }
17202 }
17206 itk++)
17207 {
17213 }
17215 {
17216 /* DR 377
17218 IF no integral type can represent all the enumerator values, the
17219 enumeration is ill-formed. */
17224 }
17226 /* [dcl.enum]
17228 The value of sizeof() applied to an enumeration type, an object
17229 of an enumeration type, or an enumerator, is the value of sizeof()
17230 applied to the underlying type. */
17233 /* Compute the minimum and maximum values for the type.
17235 [dcl.enum]
17237 For an enumeration where emin is the smallest enumerator and emax
17238 is the largest, the values of the enumeration are the values of the
17239 underlying type in the range bmin to bmax, where bmin and bmax are,
17240 respectively, the smallest and largest values of the smallest bit-
17241 field that can store emin and emax. */
17243 /* The middle-end currently assumes that types with TYPE_PRECISION
17244 narrower than their underlying type are suitably zero or sign
17245 extended to fill their mode. Similarly, it assumes that the front
17246 end assures that a value of a particular type must be within
17247 TYPE_MIN_VALUE and TYPE_MAX_VALUE.
17249 We used to set these fields based on bmin and bmax, but that led
17250 to invalid assumptions like optimizing away bounds checking. So
17251 now we just set the TYPE_PRECISION, TYPE_MIN_VALUE, and
17252 TYPE_MAX_VALUE to the values for the mode above and only restrict
17253 the ENUM_UNDERLYING_TYPE for the benefit of diagnostics. */
17257 set_min_and_max_values_for_integral_type
17260 /* If -fstrict-enums, still constrain TYPE_MIN/MAX_VALUE. */
17265 {
17268 }
17269 }
17270 else
17273 /* If the enum is exported, mark the consts too. */
17278 /* Convert each of the enumerators to the type of the underlying
17279 type of the enumeration. */
17281 {
17285 /* If the enumeration type has a fixed underlying type, we
17286 already checked all of the enumerator values. */
17288 else
17291 tf_warning_or_error);
17292 /* Do not clobber shared ints. */
17294 {
17298 }
17302 }
17304 /* Fix up all variant types of this enum type. */
17311 {
17313 /* TYPE_FIELDS needs fixup. */
17315 }
17317 /* Finish debugging output for this type. */
17320 /* Each enumerator now has the type of its enumeration. Clear the cache
17321 so that this change in types doesn't confuse us later on. */
17323 }
17325 /* Finishes the enum type. This is called only the first time an
17326 enumeration is seen, be it opaque or odinary.
17327 ENUMTYPE is the type object. */
17329 void
17331 {
17333 {
17337 }
17339 /* If this is a forward declaration, there should not be any variants,
17340 though we can get a variant in the middle of an enum-specifier with
17341 wacky code like 'enum E { e = sizeof(const E*) };' */
17345 }
17347 /* Build and install a CONST_DECL for an enumeration constant of the
17348 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
17349 Apply ATTRIBUTES if available. LOC is the location of NAME.
17350 Assignment of sequential values by default is handled here. */
17352 tree
17354 location_t loc)
17355 {
17356 tree decl;
17357 tree context;
17358 tree type;
17360 /* scalar_constant_value will pull out this expression, so make sure
17361 it's folded as appropriate. */
17365 /* If the VALUE was erroneous, pretend it wasn't there; that will
17366 result in the enum being assigned the next value in sequence. */
17370 /* Remove no-op casts from the value. */
17375 {
17376 /* Validate and default VALUE. */
17378 {
17380 {
17385 }
17388 value = perform_implicit_conversion_flags
17396 {
17399 {
17401 "enumerator value for %qD must have integral or "
17404 }
17405 else
17406 {
17410 {
17414 }
17415 }
17416 }
17417 }
17419 /* Default based on previous value. */
17421 {
17423 {
17424 tree prev_value;
17426 /* C++03 7.2/4: If no initializer is specified for the first
17427 enumerator, the type is an unspecified integral
17428 type. Otherwise the type is the same as the type of the
17429 initializing value of the preceding enumerator unless the
17430 incremented value is not representable in that type, in
17431 which case the type is an unspecified integral type
17432 sufficient to contain the incremented value. */
17436 else
17437 {
17444 {
17447 {
17450 {
17456 }
17463 }
17466 else
17468 }
17471 {
17474 }
17475 }
17476 }
17477 else
17479 }
17481 /* Remove no-op casts from the value. */
17484 /* If the underlying type of the enum is fixed, check whether
17485 the enumerator values fits in the underlying type. If it
17486 does not fit, the program is ill-formed [C++0x dcl.enum]. */
17488 && value
17490 {
17495 /* Convert the value to the appropriate type. */
17497 }
17498 }
17500 /* C++ associates enums with global, function, or class declarations. */
17503 /* Build the actual enumeration constant. Note that the enumeration
17504 constants have the underlying type of the enum (if it is fixed)
17505 or the type of their initializer (if the underlying type of the
17506 enum is not fixed):
17508 [ C++0x dcl.enum ]
17510 If the underlying type is fixed, the type of each enumerator
17511 prior to the closing brace is the underlying type; if the
17512 initializing value of an enumerator cannot be represented by
17513 the underlying type, the program is ill-formed. If the
17514 underlying type is not fixed, the type of each enumerator is
17515 the type of its initializing value.
17517 If the underlying type is not fixed, it will be computed by
17518 finish_enum and we will reset the type of this enumerator. Of
17519 course, if we're processing a template, there may be no value. */
17533 {
17534 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
17535 on the TYPE_FIELDS list for `S'. (That's so that you can say
17536 things like `S::i' later.) */
17538 /* The enumerator may be getting declared outside of its enclosing
17539 class, like so:
17541 class S { public: enum E : int; }; enum S::E : int { i = 7; };
17543 For which case we need to make sure that the access of `S::i'
17544 matches the access of `S::E'. */
17548 }
17549 else
17552 /* Add this enumeration constant to the list for this type. */
17556 }
17558 /* Look for an enumerator with the given NAME within the enumeration
17559 type ENUMTYPE. This routine is used primarily for qualified name
17560 lookup into an enumerator in C++0x, e.g.,
17562 enum class Color { Red, Green, Blue };
17564 Color color = Color::Red;
17566 Returns the value corresponding to the enumerator, or
17567 NULL_TREE if no such enumerator was found. */
17568 tree
17570 {
17571 tree e;
17576 }
17578 /* Implement LANG_HOOKS_SIMULATE_ENUM_DECL. */
17580 tree
17583 {
17590 {
17595 }
17609 }
17611 /* Implement LANG_HOOKS_SIMULATE_RECORD_DECL. */
17613 tree
17616 {
17623 {
17626 }
17645 }
17646 \f
17647 /* We're defining DECL. Make sure that its type is OK. */
17649 static void
17651 {
17655 /* In a function definition, arg types must be complete. */
17662 {
17667 /* Make it return void instead. */
17670 void_type_node,
17672 else
17674 fntype = (cp_build_type_attribute_variant
17678 }
17679 else
17680 {
17684 }
17685 }
17687 /* True iff FN is an implicitly-defined default constructor. */
17689 static bool
17691 {
17695 }
17697 /* Clobber the contents of *this to let the back end know that the object
17698 storage is dead when we enter the constructor or leave the destructor. */
17700 static tree
17702 {
17703 /* Clobbering an empty base is pointless, and harmful if its one byte
17704 TYPE_SIZE overlays real data. */
17708 /* If we have virtual bases, clobber the whole object, but only if we're in
17709 charge. If we don't have virtual bases, clobber the as-base type so we
17710 don't mess with tail padding. */
17721 {
17724 }
17731 }
17733 /* Create the FUNCTION_DECL for a function definition.
17734 DECLSPECS and DECLARATOR are the parts of the declaration;
17735 they describe the function's name and the type it returns,
17736 but twisted together in a fashion that parallels the syntax of C.
17738 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
17739 DECLARATOR is really the DECL for the function we are about to
17740 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
17741 indicating that the function is an inline defined in-class.
17743 This function creates a binding context for the function body
17744 as well as setting up the FUNCTION_DECL in current_function_decl.
17746 For C++, we must first check whether that datum makes any sense.
17747 For example, "class A local_a(1,2);" means that variable local_a
17748 is an aggregate of type A, which should have a constructor
17749 applied to it with the argument list [1, 2].
17751 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
17752 or may be a BLOCK if the function has been defined previously
17753 in this translation unit. On exit, DECL_INITIAL (decl1) will be
17754 error_mark_node if the function has never been defined, or
17755 a BLOCK if the function has been defined somewhere. */
17757 bool
17759 {
17763 /* Sanity check. */
17770 else
17771 {
17776 }
17783 /* Handle gnu_inline attribute. */
17785 {
17790 }
17793 /* This is a constructor, we must ensure that any default args
17794 introduced by this definition are propagated to the clones
17795 now. The clones are used directly in overload resolution. */
17798 /* Sometimes we don't notice that a function is a static member, and
17799 build a METHOD_TYPE for it. Fix that up now. */
17803 /* Set up current_class_type, and enter the scope of the class, if
17804 appropriate. */
17808 /* Now that we have entered the scope of the class, we must restore
17809 the bindings for any template parameters surrounding DECL1, if it
17810 is an inline member template. (Order is important; consider the
17811 case where a template parameter has the same name as a field of
17812 the class.) It is not until after this point that
17813 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
17817 /* Effective C++ rule 15. */
17825 /* Make the init_value nonzero so pushdecl knows this is not tentative.
17826 error_mark_node is replaced below (in poplevel) with the BLOCK. */
17830 /* This function exists in static storage.
17831 (This does not mean `static' in the C sense!) */
17834 /* We must call push_template_decl after current_class_type is set
17835 up. (If we are processing inline definitions after exiting a
17836 class scope, current_class_type will be NULL_TREE until set above
17837 by push_nested_class.) */
17839 {
17842 {
17846 }
17848 }
17850 /* Make sure the parameter and return types are reasonable. When
17851 you declare a function, these types can be incomplete, but they
17852 must be complete when you define the function. */
17855 /* Build the return declaration for the function. */
17859 {
17860 /* In a template instantiation, copy the return type location. When
17861 parsing, the location will be set in grokdeclarator. */
17864 {
17868 }
17876 }
17878 /* Record the decl so that the function name is defined.
17879 If we already have a decl for this name, and it is a FUNCTION_DECL,
17880 use the old decl. */
17882 {
17883 /* A specialization is not used to guide overload resolution. */
17887 {
17891 /* If something went wrong when registering the declaration,
17892 use DECL1; we have to have a FUNCTION_DECL to use when
17893 parsing the body of the function. */
17894 ;
17895 else
17896 {
17897 /* Otherwise, OLDDECL is either a previous declaration
17898 of the same function or DECL1 itself. */
17905 {
17906 tree context;
17908 /* Check whether DECL1 is in an anonymous
17909 namespace. */
17911 context;
17913 {
17917 }
17921 OPT_Wmissing_declarations,
17923 }
17926 }
17927 }
17928 else
17929 {
17930 /* We need to set the DECL_CONTEXT. */
17933 }
17937 /* If #pragma weak applies, mark the decl appropriately now.
17938 The pragma only applies to global functions. Because
17939 determining whether or not the #pragma applies involves
17940 computing the mangled name for the declaration, we cannot
17941 apply the pragma until after we have merged this declaration
17942 with any previous declarations; if the original declaration
17943 has a linkage specification, that specification applies to
17944 the definition as well, and may affect the mangled name. */
17947 }
17949 /* We are now in the scope of the function being defined. */
17952 /* Save the parm names or decls from this function's declarator
17953 where store_parm_decls will find them. */
17956 /* Let the user know we're compiling this function. */
17961 /* This function may already have been parsed, in which case just
17962 return; our caller will skip over the body without parsing. */
17966 /* Initialize RTL machinery. We cannot do this until
17967 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
17968 even when processing a template; this is how we get
17969 CFUN set up, and our per-function variables initialized.
17970 FIXME factor out the non-RTL stuff. */
17974 /* Initialize the language data structures. Whenever we start
17975 a new function, we destroy temporaries in the usual way. */
17980 /* If we are (erroneously) defining a function that we have already
17981 defined before, wipe out what we knew before. */
17987 {
17990 }
17992 /* Start the statement-tree, start the tree now. */
17996 {
17997 /* We know that this was set up by `grokclassfn'. We do not
17998 wait until `store_parm_decls', since evil parse errors may
17999 never get us to that point. Here we keep the consistency
18000 between `current_class_type' and `current_class_ptr'. */
18006 cp_function_chain->x_current_class_ref
18008 /* Set this second to avoid shortcut in cp_build_indirect_ref. */
18011 /* Constructors and destructors need to know whether they're "in
18012 charge" of initializing virtual base classes. */
18015 {
18018 }
18020 {
18023 }
18024 }
18027 /* Implicitly-defined methods (like the
18028 destructor for a class in which no destructor
18029 is explicitly declared) must not be defined
18030 until their definition is needed. So, we
18031 ignore interface specifications for
18032 compiler-generated functions. */
18040 {
18047 /* This is a function in a local class in an extern inline
18048 or template function. */
18050 }
18051 /* If this function belongs to an interface, it is public.
18052 If it belongs to someone else's interface, it is also external.
18053 This only affects inlines and template instantiations. */
18055 {
18058 {
18062 && ! flag_implement_inlines
18065 /* For WIN32 we also want to put these in linkonce sections. */
18067 }
18068 else
18071 /* If this function is in an interface implemented in this file,
18072 make sure that the back end knows to emit this function
18073 here. */
18076 }
18079 {
18080 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
18081 interface, we will have both finfo->interface_unknown and
18082 finfo->interface_only set. In that case, we don't want to
18083 use the normal heuristics because someone will supply a
18084 #pragma implementation elsewhere, and deducing it here would
18085 produce a conflict. */
18090 }
18091 else
18092 {
18093 /* This is a definition, not a reference.
18094 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
18102 else
18104 }
18106 /* Determine the ELF visibility attribute for the function. We must not
18107 do this before calling "pushdecl", as we must allow "duplicate_decls"
18108 to merge any attributes appropriately. We also need to wait until
18109 linkage is set. */
18130 /* Clobbering an empty base is harmful if it overlays real data. */
18132 /* We can't clobber safely for an implicitly-defined default constructor
18133 because part of the initialization might happen before we enter the
18134 constructor, via AGGR_INIT_ZERO_FIRST (c++/68006). */
18149 }
18152 /* Like start_preparsed_function, except that instead of a
18153 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
18155 Returns true on success. If the DECLARATOR is not suitable
18156 for a function, we return false, which tells the parser to
18157 skip the entire function. */
18159 bool
18162 tree attrs)
18163 {
18164 tree decl1;
18172 /* main must return int. grokfndecl should have corrected it
18173 (and issued a diagnostic) if the user got it wrong. */
18175 integer_type_node));
18178 }
18179 \f
18180 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
18181 FN. */
18183 static bool
18185 {
18187 && !processing_template_decl
18188 /* We insert the EH_SPEC_BLOCK only in the original
18189 function; then, it is copied automatically to the
18190 clones. */
18192 /* Implicitly-generated constructors and destructors have
18193 exception specifications. However, those specifications
18194 are the union of the possible exceptions specified by the
18195 constructors/destructors for bases and members, so no
18196 unallowed exception will ever reach this function. By
18197 not creating the EH_SPEC_BLOCK we save a little memory,
18198 and we avoid spurious warnings about unreachable
18199 code. */
18202 }
18204 /* Helper function to push ARGS into the current lexical scope. DECL
18205 is the function declaration. NONPARMS is used to handle enum
18206 constants. */
18208 void
18210 {
18211 /* If we're doing semantic analysis, then we'll call pushdecl
18212 for each of these. We must do them in reverse order so that
18213 they end in the correct forward order. */
18216 tree next;
18218 {
18223 {
18224 /* If we find an enum constant or a type tag, put it aside for
18225 the moment. */
18228 }
18229 }
18231 /* Get the decls in their original chain order and record in the
18232 function. This is all and only the PARM_DECLs that were
18233 pushed into scope by the loop above. */
18235 }
18237 /* Store the parameter declarations into the current function declaration.
18238 This is called after parsing the parameter declarations, before
18239 digesting the body of the function.
18241 Also install to binding contour return value identifier, if any. */
18243 static void
18245 {
18248 /* This is a chain of any other decls that came in among the parm
18249 declarations. If a parm is declared with enum {foo, bar} x;
18250 then CONST_DECLs for foo and bar are put here. */
18254 {
18255 /* This case is when the function was defined with an ANSI prototype.
18256 The parms already have decls, so we need not do anything here
18257 except record them as in effect
18258 and complain if any redundant old-style parm decls were written. */
18262 /* Must clear this because it might contain TYPE_DECLs declared
18263 at class level. */
18267 }
18268 else
18271 /* Now store the final chain of decls for the arguments
18272 as the decl-chain of the current lexical scope.
18273 Put the enumerators in as well, at the front so that
18274 DECL_ARGUMENTS is not modified. */
18279 }
18281 \f
18282 /* Mark CDTOR's implicit THIS argument for returning, if required by
18283 the ABI.. Return the decl for THIS, if it is to be returned, and
18284 NULL otherwise. */
18286 tree
18288 {
18291 {
18294 }
18297 }
18299 /* Set the return value of the [cd]tor if the ABI wants that. */
18301 void
18303 {
18305 {
18306 /* Return the address of the object. */
18312 }
18313 }
18315 /* Do all the processing for the beginning of a destructor; set up the
18316 vtable pointers and cleanups for bases and members. */
18318 static void
18320 {
18321 tree compound_stmt;
18323 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
18324 issued an error message. We still want to try to process the
18325 body of the function, but initialize_vtbl_ptrs will crash if
18326 TYPE_BINFO is NULL. */
18328 {
18330 /* Make all virtual function table pointers in non-virtual base
18331 classes point to CURRENT_CLASS_TYPE's virtual function
18332 tables. */
18337 /* Clobbering an empty base is harmful if it overlays real data. */
18339 {
18343 {
18345 tree ref
18352 tf_warning_or_error);
18353 /* If the vptr is shared with some virtual nearly empty base,
18354 don't clear it if not in charge, the dtor of the virtual
18355 nearly empty base will do that later. */
18357 {
18360 {
18362 {
18364 tf_warning_or_error);
18367 }
18369 }
18370 }
18372 }
18373 else
18376 }
18378 /* And insert cleanups for our bases and members so that they
18379 will be properly destroyed if we throw. */
18381 }
18382 }
18384 /* Do the necessary processing for the beginning of a function body, which
18385 in this case includes member-initializers, but not the catch clauses of
18386 a function-try-block. Currently, this means opening a binding level
18387 for the member-initializers (in a ctor), member cleanups (in a dtor),
18388 and capture proxies (in a lambda operator()). */
18390 tree
18392 {
18398 else
18399 /* Always keep the BLOCK node associated with the outermost pair of
18400 curly braces of a function. These are needed for correct
18401 operation of dwarfout.c. */
18413 }
18415 /* Do the processing for the end of a function body. Currently, this means
18416 closing out the cleanups for fully-constructed bases and members, and in
18417 the case of the destructor, deleting the object if desired. Again, this
18418 is only meaningful for [cd]tors, since they are the only functions where
18419 there is a significant distinction between the main body and any
18420 function catch clauses. Handling, say, main() return semantics here
18421 would be wrong, as flowing off the end of a function catch clause for
18422 main() would also need to return 0. */
18424 void
18426 {
18430 /* Close the block. */
18438 }
18440 /* Given a function, returns the BLOCK corresponding to the outermost level
18441 of curly braces, skipping the artificial block created for constructor
18442 initializers. */
18444 tree
18446 {
18456 }
18458 /* If FNDECL is a class's key method, add the class to the list of
18459 keyed classes that should be emitted. */
18461 static void
18463 {
18467 {
18471 }
18472 }
18474 /* Attempt to add a fix-it hint to RICHLOC suggesting the insertion
18475 of "return *this;" immediately before its location, using FNDECL's
18476 first statement (if any) to give the indentation, if appropriate. */
18478 static void
18480 {
18487 indent);
18488 }
18490 /* This function carries out the subset of finish_function operations needed
18491 to emit the compiler-generated outlined helper functions used by the
18492 coroutines implementation. */
18494 static void
18496 {
18497 /* This is a partial set of the operations done by finish_function()
18498 plus emitting the result. */
18508 /* We must start each function with a clear fold cache. */
18513 /* This function has coroutine IFNs that we should handle in middle
18514 end lowering. */
18518 }
18520 /* Finish up a function declaration and compile that function
18521 all the way to assembler language output. The free the storage
18522 for the function definition. INLINE_P is TRUE if we just
18523 finished processing the body of an in-class inline function
18524 definition. (This processing will have taken place after the
18525 class definition is complete.) */
18527 tree
18529 {
18534 && !processing_template_decl
18538 /* When we get some parse errors, we can end up without a
18539 current_function_decl, so cope. */
18553 /* TREE_READONLY (fndecl) = 1;
18554 This caused &foo to be of type ptr-to-const-function
18555 which then got a warning when stored in a ptr-to-function variable. */
18558 /* The current function is being defined, so its DECL_INITIAL should
18559 be set, and unless there's a multiple definition, it should be
18560 error_mark_node. */
18564 {
18565 /* Only try to emit the coroutine outlined helper functions if the
18566 transforms succeeded. Otherwise, treat errors in the same way as
18567 a regular function. */
18570 /* We should handle coroutine IFNs in middle end lowering. */
18573 /* Do not try to process the ramp's EH unless outlining succeeded. */
18577 current_eh_spec_block);
18578 }
18579 else
18580 /* For a cloned function, we've already got all the code we need;
18581 there's no need to add any extra bits. */
18583 {
18584 /* Make it so that `main' always returns 0 by default. */
18592 current_eh_spec_block);
18593 }
18595 /* If we're saving up tree structure, tie off the function now. */
18600 /* This must come after expand_function_end because cleanups might
18601 have declarations (from inline functions) that need to go into
18602 this function's blocks. */
18604 /* If the current binding level isn't the outermost binding level
18605 for this function, either there is a bug, or we have experienced
18606 syntax errors and the statement tree is malformed. */
18608 {
18609 /* Make sure we have already experienced errors. */
18612 /* Throw away the broken statement tree and extra binding
18613 levels. */
18617 {
18620 else
18622 }
18623 }
18626 /* Statements should always be full-expressions at the outermost set
18627 of curly braces for a function. */
18630 /* If there are no return statements in a function with auto return type,
18631 the return type is void. But if the declared type is something like
18632 auto*, this is an error. */
18635 {
18637 && !current_function_returns_value
18639 {
18640 /* We haven't applied return type deduction because we haven't
18641 seen any return statements. Do that now. */
18645 adc_return_type);
18649 }
18652 {
18657 }
18658 }
18660 /* Remember that we were in class scope. */
18665 {
18669 }
18671 // If this is a concept, check that the definition is reasonable.
18680 /* Complain if there's just no return statement. */
18687 /* Don't complain if we abort or throw. */
18688 && !current_function_returns_abnormally
18689 /* Don't complain if there's an infinite loop. */
18690 && !current_function_infinite_loop
18691 /* Don't complain if we are declared noreturn. */
18695 /* Structor return values (if any) are set by the compiler. */
18699 {
18701 /* Potentially add a "return *this;" fix-it hint for
18702 assignment operators. */
18704 {
18707 && current_class_ref
18708 && same_type_ignoring_top_level_qualifiers_p
18712 }
18718 "no return statement in function returning "
18721 }
18723 /* Lambda closure members are implicitly constexpr if possible. */
18727 = ((processing_template_decl
18731 /* Save constexpr function body before it gets munged by
18732 the NRV transformation. */
18735 /* Invoke the pre-genericize plugin before we start munging things. */
18739 /* Perform delayed folding before NRV transformation. */
18745 /* Set up the named return value optimization, if we can. Candidate
18746 variables are selected in check_return_expr. */
18748 {
18752 }
18754 /* Must mark the RESULT_DECL as being in this function. */
18757 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
18758 to the FUNCTION_DECL node itself. */
18761 /* Store the end of the function, so that we get good line number
18762 info for the epilogue. */
18765 /* Complain about parameters that are only set, but never otherwise used. */
18767 && !processing_template_decl
18770 {
18771 tree decl;
18774 decl;
18788 OPT_Wunused_but_set_parameter,
18791 }
18793 /* Complain about locally defined typedefs that are not used in this
18794 function. */
18797 /* Possibly warn about unused parameters. */
18799 && !processing_template_decl
18803 /* Genericize before inlining. */
18809 /* If this function can't throw any exceptions, remember that. */
18812 && !flag_non_call_exceptions
18817 /* Emit the resumer and destroyer functions now, providing that we have
18818 not encountered some fatal error. */
18820 {
18823 }
18825 cleanup:
18826 /* We're leaving the context of this function, so zap cfun. It's still in
18827 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
18831 /* If this is an in-class inline definition, we may have to pop the
18832 bindings for the template parameters that we added in
18833 maybe_begin_member_template_processing when start_function was
18834 called. */
18838 /* Leave the scope of the class. */
18844 /* Clean up. */
18852 }
18853 \f
18854 /* Create the FUNCTION_DECL for a function definition.
18855 DECLSPECS and DECLARATOR are the parts of the declaration;
18856 they describe the return type and the name of the function,
18857 but twisted together in a fashion that parallels the syntax of C.
18859 This function creates a binding context for the function body
18860 as well as setting up the FUNCTION_DECL in current_function_decl.
18862 Returns a FUNCTION_DECL on success.
18864 If the DECLARATOR is not suitable for a function (it defines a datum
18865 instead), we return 0, which tells yyparse to report a parse error.
18867 May return void_type_node indicating that this method is actually
18868 a friend. See grokfield for more details.
18870 Came here with a `.pushlevel' .
18872 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
18873 CHANGES TO CODE IN `grokfield'. */
18875 tree
18878 {
18888 /* Pass friends other than inline friend functions back. */
18893 {
18898 }
18902 /* p1779 ABI-Isolation makes inline not a default for in-class
18903 definitions in named module purview. If the user explicitly
18904 made it inline, grokdeclarator will already have done the right
18905 things. */
18907 || flag_module_implicit_inline
18908 /* Lambda's operator function remains inline. */
18910 /* If the user explicitly asked for this to be inline, we don't
18911 need to do more, but more importantly we want to warn if we
18912 can't inline it. */
18914 {
18918 /* It's ok if we can't inline this. */
18920 }
18922 /* We process method specializations in finish_struct_1. */
18924 {
18925 /* Avoid calling decl_spec_seq... until we have to. */
18930 }
18933 {
18936 }
18942 }
18943 \f
18945 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
18946 we can lay it out later, when and if its type becomes complete.
18948 Also handle constexpr variables where the initializer involves
18949 an unlowered PTRMEM_CST because the class isn't complete yet. */
18951 void
18953 {
18956 /* Keep track of variables with incomplete types. */
18959 {
18967 /* RTTI TD entries are created while defining the type_info. */
18970 {
18973 }
18977 {
18978 /* When the outermost open class is complete we can resolve any
18979 pointers-to-members. */
18983 }
18984 }
18985 }
18987 /* Called when a class type (given by TYPE) is defined. If there are
18988 any existing VAR_DECLs whose type has been completed by this
18989 declaration, update them now. */
18991 void
18993 {
18998 {
19000 {
19007 {
19008 /* Complete the type of the variable. */
19013 }
19015 /* Remove this entry from the list. */
19017 }
19018 else
19019 ix++;
19020 }
19021 }
19023 /* If DECL is of a type which needs a cleanup, build and return an
19024 expression to perform that cleanup here. Return NULL_TREE if no
19025 cleanup need be done. DECL can also be a _REF when called from
19026 split_nonconstant_init_1. */
19028 tree
19030 {
19031 tree type;
19032 tree attr;
19033 tree cleanup;
19035 /* Assume no cleanup is required. */
19041 /* Handle "__attribute__((cleanup))". We run the cleanup function
19042 before the destructor since the destructor is what actually
19043 terminates the lifetime of the object. */
19046 else
19049 {
19050 tree id;
19051 tree fn;
19052 tree arg;
19054 /* Get the name specified by the user for the cleanup function. */
19056 /* Look up the name to find the cleanup function to call. It is
19057 important to use lookup_name here because that is what is
19058 used in c-common.cc:handle_cleanup_attribute when performing
19059 initial checks on the attribute. Note that those checks
19060 include ensuring that the function found is not an overloaded
19061 function, or an object with an overloaded call operator,
19062 etc.; we can rely on the fact that the function found is an
19063 ordinary FUNCTION_DECL. */
19071 }
19072 /* Handle ordinary C++ destructors. */
19075 {
19077 tree addr;
19078 tree call;
19082 else
19096 else
19098 }
19100 /* build_delete sets the location of the destructor call to the
19101 current location, even though the destructor is going to be
19102 called later, at the end of the current scope. This can lead to
19103 a "jumpy" behavior for users of debuggers when they step around
19104 the end of the block. So let's unset the location of the
19105 destructor call instead. */
19113 /* Treat objects with destructors as used; the destructor may do
19114 something substantive. */
19123 }
19125 \f
19126 /* Return the FUNCTION_TYPE that corresponds to MEMFNTYPE, which can be a
19127 FUNCTION_DECL, METHOD_TYPE, FUNCTION_TYPE, pointer or reference to
19128 METHOD_TYPE or FUNCTION_TYPE, or pointer to member function. */
19130 tree
19132 {
19133 tree fntype;
19134 tree args;
19147 fntype = (cp_build_type_attribute_variant
19151 }
19153 /* DECL was originally constructed as a non-static member function,
19154 but turned out to be static. Update it accordingly. */
19156 void
19158 {
19171 }
19173 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
19174 one of the language-independent trees. */
19176 enum cp_tree_node_structure_enum
19178 {
19180 {
19198 }
19199 }
19201 bool
19203 {
19204 /* A missing noreturn is ok for the `main' function. */
19206 }
19208 /* Return the decl used to identify the COMDAT group into which DECL should
19209 be placed. */
19211 tree
19213 {
19214 /* Virtual tables, construction virtual tables, and virtual table
19215 tables all go in a single COMDAT group, named after the primary
19216 virtual table. */
19219 /* For all other DECLs, the COMDAT group is the mangled name of the
19220 declaration itself. */
19221 else
19222 {
19224 {
19225 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
19226 into the same section as the target function. In that case
19227 we must return target's name. */
19233 else
19235 }
19236 }
19239 }
19241 /* Returns the return type for FN as written by the user, which may include
19242 a placeholder for a deduced return type. */
19244 tree
19246 {
19252 }
19254 /* Returns true iff DECL is a variable or function declared with an auto type
19255 that has not yet been deduced to a real type. */
19257 bool
19259 {
19266 }
19268 /* Complain if DECL has an undeduced return type. */
19270 bool
19272 {
19274 {
19278 {
19279 /* Set the return type of __builtin_source_location. */
19282 {
19285 }
19290 }
19298 }
19300 }
19302 /* Create a representation of the explicit-specifier with
19303 constant-expression of EXPR. COMPLAIN is as for tsubst. */
19305 tree
19307 {
19312 /* Wait for instantiation, tsubst_function_decl will handle it. */
19319 }