| blob | 82eb0c2f22a91aed062eb7e730e25f5fc7d02071 |
1 /* Process declarations and variables for -*- C++ -*- compiler.
2 Copyright (C) 1988-2022 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. */
62 /* Possible cases of bad specifiers type used by bad_specifiers. */
67 BSP_FIELD /* field */
68 };
98 static tree check_special_function_return_type
107 /* The following symbols are subsumed in the cp_global_trees array, and
108 listed here individually for documentation purposes.
110 C++ extensions
111 tree wchar_decl_node;
113 tree vtable_entry_type;
114 tree delta_type_node;
115 tree __t_desc_type_node;
117 tree class_type_node;
118 tree unknown_type_node;
120 Array type `vtable_entry_type[]'
122 tree vtbl_type_node;
123 tree vtbl_ptr_type_node;
125 Namespaces,
127 tree std_node;
128 tree abi_node;
130 A FUNCTION_DECL which can call `abort'. Not necessarily the
131 one that the user will declare, but sufficient to be called
132 by routines that want to abort the program.
134 tree abort_fndecl;
136 Used by RTTI
137 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
138 tree tinfo_var_id; */
142 /* A list of objects which have constructors or destructors
143 which reside in namespace scope. The decl is stored in
144 the TREE_VALUE slot and the initializer is stored
145 in the TREE_PURPOSE slot. */
146 tree static_aggregates;
148 /* Like static_aggregates, but for thread_local variables. */
149 tree tls_aggregates;
151 /* A hash-map mapping from variable decls to the dynamic initializer for
152 the decl. This is currently only used by OpenMP. */
155 /* -- end of C++ */
157 /* A node for the integer constant 2. */
159 tree integer_two_node;
161 /* vector of static decls. */
164 /* vector of keyed classes. */
167 /* Used only for jumps to as-yet undefined labels, since jumps to
168 defined labels can have their validity checked immediately. */
172 /* The binding level to which this entry is *currently* attached.
173 This is initially the binding level in which the goto appeared,
174 but is modified as scopes are closed. */
176 /* The head of the names list that was current when the goto appeared,
177 or the inner scope popped. These are the decls that will *not* be
178 skipped when jumping to the label. */
179 tree names_in_scope;
180 /* The location of the goto, for error reporting. */
181 location_t o_goto_locus;
182 /* True if an OpenMP structured block scope has been closed since
183 the goto appeared. This means that the branch from the label will
184 illegally exit an OpenMP scope. */
186 };
188 /* A list of all LABEL_DECLs in the function that have names. Here so
189 we can clear out their names' definitions at the end of the
190 function, and so we can check the validity of jumps to these labels. */
200 /* The binding level to which the label is *currently* attached.
201 This is initially set to the binding level in which the label
202 is defined, but is modified as scopes are closed. */
205 /* The head of the names list that was current when the label was
206 defined, or the inner scope popped. These are the decls that will
207 be skipped when jumping to the label. */
208 tree names_in_scope;
210 /* A vector of all decls from all binding levels that would be
211 crossed by a backward branch to the label. */
214 /* A list of uses of the label, before the label is defined. */
217 /* The following bits are set after the label is defined, and are
218 updated as scopes are popped. They indicate that a jump to the
219 label will illegally enter a scope of the given flavor. */
227 };
229 #define named_labels cp_function_chain->x_named_labels
230 \f
231 /* The number of function bodies which we are currently processing.
232 (Zero if we are at namespace scope, one inside the body of a
233 function, two inside the body of a function in a local class, etc.) */
236 /* Whether the exception-specifier is part of a function type (i.e. C++17). */
239 /* States indicating how grokdeclarator() should handle declspecs marked
240 with __attribute__((deprecated)). An object declared as
241 __attribute__((deprecated)) suppresses warnings of uses of other
242 deprecated items. */
245 \f
246 /* A list of VAR_DECLs whose type was incomplete at the time the
247 variable was declared. */
250 tree decl;
251 tree incomplete_type;
252 };
256 \f
257 /* Returns the kind of template specialization we are currently
258 processing, given that it's declaration contained N_CLASS_SCOPES
259 explicit scope qualifications. */
261 tmpl_spec_kind
263 {
269 /* Scan through the template parameter scopes. */
273 {
274 /* If we see a specialization scope inside a parameter scope,
275 then something is wrong. That corresponds to a declaration
276 like:
278 template <class T> template <> ...
280 which is always invalid since [temp.expl.spec] forbids the
281 specialization of a class member template if the enclosing
282 class templates are not explicitly specialized as well. */
284 {
287 else
289 }
294 }
296 /* Handle explicit instantiations. */
298 {
300 /* We've seen a template parameter list during an explicit
301 instantiation. For example:
303 template <class T> template void f(int);
305 This is erroneous. */
307 else
309 }
312 /* We've not seen enough template headers to match all the
313 specialized classes present. For example:
315 template <class T> void R<T>::S<T>::f(int);
317 This is invalid; there needs to be one set of template
318 parameters for each class. */
321 /* We're processing a non-template declaration (even though it may
322 be a member of a template class.) For example:
324 template <class T> void S<T>::f(int);
326 The `class T' matches the `S<T>', leaving no template headers
327 corresponding to the `f'. */
330 /* We've got too many template headers. For example:
332 template <> template <class T> void f (T);
334 There need to be more enclosing classes. */
336 else
337 /* This must be a template. It's of the form:
339 template <class T> template <class U> void S<T>::f(U);
341 This is a specialization if the innermost level was a
342 specialization; otherwise it's just a definition of the
343 template. */
345 }
347 /* Exit the current scope. */
349 void
351 {
353 }
355 /* When a label goes out of scope, check to see if that label was used
356 in a valid manner, and issue any appropriate warnings or errors. */
358 static void
360 {
362 {
364 {
365 location_t location;
369 /* FIXME want (LOCATION_FILE (input_location), (line)0) */
370 /* Avoid crashing later. */
372 }
373 else
375 }
376 }
378 /* Helper function to sort named label entries in a vector by DECL_UID. */
380 static int
382 {
386 /* DECL_UIDs can never be equal. */
388 }
390 /* At the end of a function, all labels declared within the function
391 go out of scope. BLOCK is the top-level block for the
392 function. */
394 static void
396 {
400 /* We need to add the labels to the block chain, so debug
401 information is emitted. But, we want the order to be stable so
402 need to sort them first. Otherwise the debug output could be
403 randomly ordered. I guess it's mostly stable, unless the hash
404 table implementation changes. */
409 {
416 }
421 {
428 }
429 }
431 /* At the end of a block with local labels, restore the outer definition. */
433 static void
435 {
443 else
444 {
447 }
449 }
451 /* The following two routines are used to interface to Objective-C++.
452 The binding level is purposely treated as an opaque type. */
456 {
458 }
460 /* The following routine is used by the NeXT-style SJLJ exceptions;
461 variables get marked 'volatile' so as to not be clobbered by
462 _setjmp()/_longjmp() calls. All variables in the current scope,
463 as well as parent scopes up to (but not including) ENCLOSING_BLK
464 shall be thusly marked. */
466 void
468 {
474 {
475 tree decl;
480 /* Do not climb up past the current function. */
483 }
484 }
486 /* True if B is the level for the condition of a constexpr if. */
488 static bool
490 {
494 }
496 /* True if B is the level for the condition of a consteval if. */
498 static bool
500 {
504 }
506 /* Update data for defined and undefined labels when leaving a scope. */
508 int
510 {
515 {
516 tree decl;
518 /* ENT->NAMES_IN_SCOPE may contain a mixture of DECLs and
519 TREE_LISTs representing OVERLOADs, so be careful. */
529 {
553 }
554 }
556 {
561 {
566 }
567 }
570 }
572 /* Saved errorcount to avoid -Wunused-but-set-{parameter,variable} warnings
573 when errors were reported, except for -Werror-unused-but-set-*. */
576 /* Exit a binding level.
577 Pop the level off, and restore the state of the identifier-decl mappings
578 that were in effect when this level was entered.
580 If KEEP == 1, this level had explicit declarations, so
581 and create a "block" (a BLOCK node) for the level
582 to record its declarations and subblocks for symbol table output.
584 If FUNCTIONBODY is nonzero, this level is the body of a function,
585 so create a block as if KEEP were set and also clear out all
586 label names.
588 If REVERSE is nonzero, reverse the order of decls before putting
589 them into the BLOCK. */
591 tree
593 {
594 tree link;
595 /* The chain of decls was accumulated in reverse order.
596 Put it into forward order, just for cleanliness. */
597 tree decls;
598 tree subblocks;
599 tree block;
600 tree decl;
601 scope_kind kind;
604 restart:
617 /* We used to use KEEP == 2 to indicate that the new block should go
618 at the beginning of the list of blocks at this binding level,
619 rather than the end. This hack is no longer used. */
625 /* Any uses of undefined labels, and any defined labels, now operate
626 under constraints of next binding contour. */
631 /* Get the decls in the order they were written.
632 Usually current_binding_level->names is in reverse order.
633 But parameter decls were previously put in forward order. */
637 {
640 }
642 /* If there were any declarations or structure tags in that level,
643 or if this level is a function body,
644 create a BLOCK to record them for the life of this function. */
646 /* Avoid function body block if possible. */
652 {
655 }
657 /* In each subblock, record that this is its superior. */
662 /* Before we remove the declarations first check for unused variables. */
667 {
668 /* There are cases where D itself is a TREE_LIST. See in
669 push_local_binding where the list of decls returned by
670 getdecls is built. */
677 /* For structured bindings, consider only real variables, not
678 subobjects. */
686 {
688 {
691 OPT_Wunused_variable,
693 else
696 }
698 // For -Wunused-but-set-variable leave references alone.
701 {
706 else
708 OPT_Wunused_but_set_variable,
711 }
712 }
713 }
715 /* Remove declarations for all the DECLs in this level. */
717 {
718 tree name;
720 {
724 }
725 else
726 {
729 }
731 /* Remove the binding. */
734 else
736 }
738 /* Restore the IDENTIFIER_TYPE_VALUEs. */
743 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
744 list if a `using' declaration put them there. The debugging
745 back ends won't understand OVERLOAD, so we remove them here.
746 Because the BLOCK_VARS are (temporarily) shared with
747 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
748 popped all the bindings. Also remove undeduced 'auto' decls,
749 which LTO doesn't understand, and can't have been used by anything. */
751 {
755 {
757 || (!processing_template_decl
760 else
762 }
763 }
765 /* If the level being exited is the top level of a function,
766 check over all the labels. */
768 {
770 {
771 /* Since this is the top level block of a function, the vars are
772 the function's parameters. Don't leave them in the BLOCK
773 because they are found in the FUNCTION_DECL instead. */
776 }
777 else
779 }
783 {
784 tree stmt;
786 /* If this is a temporary binding created for a cleanup, then we'll
787 have pushed a statement list level. Pop that, create a new
788 BIND_EXPR for the block, and insert it into the stream. */
792 }
796 {
797 /* The current function is being defined, so its DECL_INITIAL
798 should be error_mark_node. */
802 {
804 {
807 }
808 else
810 }
811 }
813 current_binding_level->blocks
816 /* If we did not make a block for the level just exited,
817 any blocks made for inner levels
818 (since they cannot be recorded as subblocks in that level)
819 must be carried forward so they will later become subblocks
820 of something else. */
822 current_binding_level->blocks
825 /* Each and every BLOCK node created here in `poplevel' is important
826 (e.g. for proper debugging information) so if we created one
827 earlier, mark it as "used". */
831 /* All temporary bindings created for cleanups are popped silently. */
836 }
838 /* Call wrapup_globals_declarations for the globals in NAMESPACE. */
839 /* Diagnose odr-used extern inline variables without definitions
840 in the current TU. */
842 int
844 {
846 {
848 {
858 OPT_Wunused_function,
867 }
869 /* Clear out the list, so we don't rescan next time. */
872 /* Write out any globals that need to be output. */
875 }
877 }
878 \f
879 /* In C++, you don't have to write `struct S' to refer to `S'; you
880 can just use `S'. We accomplish this by creating a TYPE_DECL as
881 if the user had written `typedef struct S S'. Create and return
882 the TYPE_DECL for TYPE. */
884 tree
886 {
887 tree decl;
891 /* There are other implicit type declarations, like the one *within*
892 a class that allows you to write `S::S'. We must distinguish
893 amongst these. */
899 }
901 /* Function-scope local entities that need discriminators. Each entry
902 is a {decl,name} pair. VAR_DECLs for anon unions get their name
903 smashed, so we cannot rely on DECL_NAME. */
907 /* Determine the mangling discriminator of local DECL. There are
908 generally very few of these in any particular function. */
910 void
912 {
921 {
929 {
935 /* Replace the saved decl. */
939 }
940 }
943 {
947 }
948 }
950 \f
952 /* Returns true if functions FN1 and FN2 have equivalent trailing
953 requires clauses. */
955 static bool
957 {
958 /* In the concepts TS, the combined constraints are compared. */
962 {
968 }
970 /* Compare only trailing requirements. */
976 /* Substitution is needed when friends are involved. */
981 }
983 /* Subroutine of duplicate_decls: return truthvalue of whether
984 or not types of these decls match.
986 For C++, we must compare the parameter list so that `int' can match
987 `int&' in a parameter position, but `int&' is not confused with
988 `const int&'. */
990 int
992 {
999 /* If the two DECLs are not even the same kind of thing, we're not
1000 interested in their types. */
1006 {
1007 /* Specializations of different templates are different functions
1008 even if they have the same type. */
1023 /* A new declaration doesn't match a built-in one unless it
1024 is also extern "C". */
1034 /* A declaration with deduced return type should use its pre-deduction
1035 type for declaration matching. */
1043 {
1046 {
1050 }
1051 else
1052 types_match =
1058 }
1059 else
1062 /* Two function declarations match if either has a requires-clause
1063 then both have a requires-clause and their constraints-expressions
1064 are equivalent. */
1068 /* The decls dont match if they correspond to two different versions
1069 of the same function. Disallow extern "C" functions to be
1070 versions for now. */
1075 {
1081 }
1082 }
1084 {
1094 /* Two template types match if they are the same. Otherwise, compare
1095 the underlying declarations. */
1098 else
1100 }
1101 else
1102 {
1103 /* Need to check scope for variable declaration (VAR_DECL).
1104 For typedef (TYPE_DECL), scope is ignored. */
1107 /* [dcl.link]
1108 Two declarations for an object with C language linkage
1109 with the same name (ignoring the namespace that qualify
1110 it) that appear in different namespace scopes refer to
1111 the same object. */
1121 else
1124 COMPARE_REDECLARATION);
1125 }
1128 }
1130 /* Mark DECL as versioned if it isn't already. */
1132 static void
1134 {
1136 {
1138 /* If DECL_ASSEMBLER_NAME has already been set, re-mangle
1139 to include the version marker. */
1142 }
1143 }
1145 /* NEWDECL and OLDDECL have identical signatures. If they are
1146 different versions adjust them and return true.
1147 If RECORD is set to true, record function versions. */
1149 bool
1151 {
1157 {
1160 }
1164 {
1165 /* Unfortunately, we can get here before pushdecl naturally calls
1166 push_local_extern_decl_alias, so we need to call it directly. */
1171 }
1177 }
1179 /* If NEWDECL is `static' and an `extern' was seen previously,
1180 warn about it. OLDDECL is the previous declaration.
1182 Note that this does not apply to the C++ case of declaring
1183 a variable `extern const' and then later `const'.
1185 Don't complain about built-in functions, since they are beyond
1186 the user's control. */
1188 void
1190 {
1197 /* Don't get confused by static member functions; that's a different
1198 use of `static'. */
1203 /* If the old declaration was `static', or the new one isn't, then
1204 everything is OK. */
1208 /* It's OK to declare a builtin function as `static'. */
1213 auto_diagnostic_group d;
1218 }
1220 /* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1221 function templates. If their exception specifications do not
1222 match, issue a diagnostic. */
1224 static void
1226 tree old_decl)
1227 {
1231 /* Two default specs are equivalent, don't force evaluation. */
1237 {
1240 }
1244 /* [except.spec]
1246 If any declaration of a function has an exception-specification,
1247 all declarations, including the definition and an explicit
1248 specialization, of that function shall have an
1249 exception-specification with the same set of type-ids. */
1253 {
1258 auto_diagnostic_group d;
1262 /* We used to silently permit mismatched eh specs with
1263 -fno-exceptions, so make them a pedwarn now. */
1265 else
1270 }
1271 }
1273 /* Return true if OLD_DECL and NEW_DECL agree on constexprness.
1274 Otherwise issue diagnostics. */
1276 static bool
1278 {
1286 {
1292 }
1294 {
1295 /* With -fimplicit-constexpr, ignore changes in the constexpr
1296 keyword. */
1302 {
1303 /* Hide a built-in declaration. */
1309 }
1310 /* 7.1.5 [dcl.constexpr]
1311 Note: An explicit specialization can differ from the template
1312 declaration with respect to the constexpr specifier. */
1322 "redeclaration %qD differs in %qs "
1324 kind);
1328 }
1330 }
1332 // If OLDDECL and NEWDECL are concept declarations with the same type
1333 // (i.e., and template parameters), but different requirements,
1334 // emit diagnostics and return true. Otherwise, return false.
1337 {
1349 {
1354 {
1357 }
1358 }
1360 }
1362 /* DECL is a redeclaration of a function or function template. If
1363 it does have default arguments issue a diagnostic. Note: this
1364 function is used to enforce the requirements in C++11 8.3.6 about
1365 no default arguments in redeclarations. */
1367 static void
1369 {
1375 {
1377 "redeclaration of %q#D may not have default "
1380 }
1381 }
1383 /* NEWDECL is a redeclaration of a function or function template OLDDECL,
1384 in any case represented as FUNCTION_DECLs (the DECL_TEMPLATE_RESULTs of
1385 the TEMPLATE_DECLs in case of function templates). This function is used
1386 to enforce the final part of C++17 11.3.6/4, about a single declaration:
1387 "If a friend declaration specifies a default argument expression, that
1388 declaration shall be a definition and shall be the only declaration of
1389 the function or function template in the translation unit." */
1391 static void
1393 {
1403 {
1404 auto_diagnostic_group d;
1406 "friend declaration of %q#D specifies default "
1411 }
1412 }
1414 /* Merge tree bits that correspond to attributes noreturn, nothrow,
1415 const, malloc, and pure from NEWDECL with those of OLDDECL. */
1417 static void
1419 {
1432 }
1434 #define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn) \
1436 DECL_ATTRIBUTES (fn)))
1438 /* A subroutine of duplicate_decls. Emits a diagnostic when newdecl
1439 ambiguates olddecl. Returns true if an error occurs. */
1441 static bool
1443 {
1447 /* Function template declarations can be differentiated by parameter
1448 and return type. */
1453 {
1454 /* ... and also by their template-heads and requires-clauses. */
1457 {
1462 }
1464 /* FIXME: The types are the same but the are differences
1465 in either the template heads or function requirements.
1466 We should be able to diagnose a set of common errors
1467 stemming from these declarations. For example:
1469 template<typename T> requires C void f(...);
1470 template<typename T> void f(...) requires C;
1472 These are functionally equivalent but not equivalent. */
1473 }
1476 }
1478 /* OLD_PARMS is the innermost set of template parameters for some template
1479 declaration, and NEW_PARMS is the corresponding set of template parameters
1480 for a redeclaration of that template. Merge the default arguments within
1481 these two sets of parameters. CLASS_P is true iff the template in
1482 question is a class template. */
1484 bool
1486 {
1490 {
1496 {
1497 auto_diagnostic_group d;
1502 }
1504 /* Update the previous template parameters (which are the ones
1505 that will really count) with the new default value. */
1508 /* Update the new parameters, too; they'll be used as the
1509 parameters for any members. */
1511 }
1513 }
1515 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1516 If the redeclaration is invalid, a diagnostic is issued, and the
1517 error_mark_node is returned. Otherwise, OLDDECL is returned.
1519 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1520 returned.
1522 HIDING is true if the new decl is being hidden. WAS_HIDDEN is true
1523 if the old decl was hidden.
1525 Hidden decls can be anticipated builtins, injected friends, or
1526 (coming soon) injected from a local-extern decl. */
1528 tree
1530 {
1534 tree new_template_info;
1543 /* If either the type of the new decl or the type of the old decl is an
1544 error_mark_node, then that implies that we have already issued an
1545 error (earlier) for some bogus type specification, and in that case,
1546 it is rather pointless to harass the user with yet more error message
1547 about the same declaration, so just pretend the types match here. */
1552 /* Check for redeclaration and other discrepancies. */
1555 {
1557 {
1558 /* Avoid warnings redeclaring built-ins which have not been
1559 explicitly declared. */
1561 {
1565 OPT_Wbuiltin_declaration_mismatch,
1567 newdecl);
1569 }
1571 /* If you declare a built-in or predefined function name as static,
1572 the old definition is overridden, but optionally warn this was a
1573 bad choice of name. */
1575 {
1577 OPT_Wshadow,
1581 /* Discard the old built-in function. */
1583 }
1584 /* If the built-in is not ansi, then programs can override
1585 it even globally without an error. */
1590 else
1592 "declaration of %q#D conflicts with built-in "
1595 }
1597 {
1598 /* Avoid warnings redeclaring built-ins which have not been
1599 explicitly declared. */
1601 {
1604 /* A new declaration doesn't match a built-in one unless it
1605 is also extern "C". */
1615 {
1618 /* FILE, tm types are not known at the time
1619 we create the builtins. */
1625 {
1632 {
1642 }
1644 }
1648 next_arg:;
1649 }
1652 OPT_Wbuiltin_declaration_mismatch,
1653 "declaration of %q#D conflicts with built-in "
1655 }
1660 {
1661 /* Don't really override olddecl for __* prefixed builtins
1662 except for __[^b]*_chk, the compiler might be using those
1663 explicitly. */
1665 {
1676 {
1678 {
1680 "definition of %q#D ambiguates built-in "
1683 }
1684 auto_diagnostic_group d;
1686 "new declaration %q#D ambiguates built-in"
1692 }
1693 }
1695 /* A near match; override the builtin. */
1699 OPT_Wbuiltin_declaration_mismatch,
1700 "new declaration %q#D ambiguates built-in "
1702 else
1707 }
1708 else
1709 /* Discard the old built-in function. */
1712 /* Replace the old RTL to avoid problems with inlining. */
1714 }
1715 else
1716 {
1717 /* Even if the types match, prefer the new declarations type
1718 for built-ins which have not been explicitly declared,
1719 for exception lists, etc... */
1726 }
1728 /* If a function is explicitly declared "throw ()", propagate that to
1729 the corresponding builtin. */
1731 && was_hidden
1734 {
1739 }
1741 /* Whether or not the builtin can throw exceptions has no
1742 bearing on this declarator. */
1746 {
1747 /* If a builtin function is redeclared as `static', merge
1748 the declarations, but make the original one static. */
1752 /* Make the old declaration consistent with the new one so
1753 that all remnants of the builtin-ness of this function
1754 will be banished. */
1757 }
1758 }
1760 {
1761 /* C++ Standard, 3.3, clause 4:
1762 "[Note: a namespace name or a class template name must be unique
1763 in its declarative region (7.3.2, clause 14). ]" */
1784 {
1785 /* One is a function and the other is a template
1786 function. */
1790 /* There can only be one! */
1794 "literal operator %q#D conflicts with"
1798 "raw literal operator %q#D conflicts with"
1800 else
1805 }
1811 /* One is an implicit typedef, that's ok. */
1818 }
1820 {
1822 /* These are certainly not duplicate declarations; they're
1823 from different scopes. */
1827 {
1831 /* The name of a class template may not be declared to refer to
1832 any other template, class, function, object, namespace, value,
1833 or type in the same scope. */
1836 {
1842 }
1846 {
1850 }
1854 }
1856 {
1858 {
1861 newdecl);
1865 }
1866 /* For function versions, params and types match, but they
1867 are not ambiguous. */
1870 // The functions have the same parameter types.
1873 // And the same constraints.
1875 {
1881 }
1882 else
1884 }
1885 else
1886 {
1891 }
1892 }
1895 {
1896 /* OMP UDRs are never duplicates. */
1903 }
1913 /* It's OK to have a template specialization and a non-template
1914 with the same type, or to have specializations of two
1915 different templates with the same type. Note that if one is a
1916 specialization, and the other is an instantiation of the same
1917 template, that we do not exit at this point. That situation
1918 can occur if we instantiate a template class, and then
1919 specialize one of its methods. This situation is valid, but
1920 the declarations must be merged in the usual way. */
1927 /* One of the declarations is a template instantiation, and the
1928 other is not a template at all. That's OK. */
1931 {
1932 /* In [namespace.alias] we have:
1934 In a declarative region, a namespace-alias-definition can be
1935 used to redefine a namespace-alias declared in that declarative
1936 region to refer only to the namespace to which it already
1937 refers.
1939 Therefore, if we encounter a second alias directive for the same
1940 alias, we can just ignore the second directive. */
1946 /* Leave it to update_binding to merge or report error. */
1948 }
1949 else
1950 {
1953 {
1954 auto_diagnostic_group d;
1962 }
1967 {
1968 /* Prototype decl follows defn w/o prototype. */
1969 auto_diagnostic_group d;
1974 }
1977 {
1978 /* [dcl.link]
1979 If two declarations of the same function or object
1980 specify different linkage-specifications ..., the program
1981 is ill-formed.... Except for functions with C++ linkage,
1982 a function declaration without a linkage specification
1983 shall not precede the first linkage specification for
1984 that function. A function can be declared without a
1985 linkage specification after an explicit linkage
1986 specification has been seen; the linkage explicitly
1987 specified in the earlier declaration is not affected by
1988 such a function declaration.
1990 DR 563 raises the question why the restrictions on
1991 functions should not also apply to objects. Older
1992 versions of G++ silently ignore the linkage-specification
1993 for this example:
1995 namespace N {
1996 extern int i;
1997 extern "C" int i;
1998 }
2000 which is clearly wrong. Therefore, we now treat objects
2001 like functions. */
2003 {
2004 /* There is no explicit linkage-specification, so we use
2005 the linkage from the previous declaration. */
2008 }
2009 else
2010 {
2011 auto_diagnostic_group d;
2018 }
2019 }
2022 ;
2024 {
2025 /* Note: free functions, as TEMPLATE_DECLs, are handled below. */
2028 as FUNCTION_DECLs. */
2030 /* C++11 8.3.6/6.
2031 Default arguments for a member function of a class
2032 template shall be specified on the initial declaration
2033 of the member function within the class template. */
2035 {
2040 {
2044 tree old_parms
2048 }
2049 }
2050 else
2051 {
2059 {
2062 {
2063 auto_diagnostic_group d;
2065 "default argument given for parameter "
2069 olddecl);
2070 }
2071 else
2072 {
2073 auto_diagnostic_group d;
2075 "default argument given for parameter %d "
2079 olddecl);
2080 }
2081 }
2083 /* C++17 11.3.6/4: "If a friend declaration specifies a default
2084 argument expression, that declaration... shall be the only
2085 declaration of the function or function template in the
2086 translation unit." */
2088 }
2089 }
2090 }
2092 /* Do not merge an implicit typedef with an explicit one. In:
2094 class A;
2095 ...
2096 typedef class A A __attribute__ ((foo));
2098 the attribute should apply only to the typedef. */
2114 {
2116 {
2119 else
2120 {
2123 }
2126 }
2130 {
2133 {
2136 }
2137 }
2140 }
2142 /* We have committed to returning OLDDECL at this point. */
2144 /* If new decl is `static' and an `extern' was seen previously,
2145 warn about it. */
2148 /* True to merge attributes between the declarations, false to
2149 set OLDDECL's attributes to those of NEWDECL (for template
2150 explicit specializations that specify their own attributes
2151 independent of those specified for the primary template). */
2157 {
2159 {
2165 /* [dcl.attr.noreturn]: The first declaration of a function shall
2166 specify the noreturn attribute if any declaration of that function
2167 specifies the noreturn attribute. */
2168 tree a;
2171 /* This applies to [[noreturn]] only, not its GNU variants. */
2175 {
2179 }
2180 }
2182 /* Now that functions must hold information normally held
2183 by field decls, there is extra work to do so that
2184 declaration information does not get destroyed during
2185 definition. */
2205 /* Optionally warn about more than one declaration for the same
2206 name, but don't warn about a function declaration followed by a
2207 definition. */
2210 /* Don't warn about extern decl followed by definition. */
2212 /* Don't warn if at least one is/was hidden. */
2214 /* Don't warn about declaration followed by specialization. */
2217 {
2218 auto_diagnostic_group d;
2220 OPT_Wredundant_decls,
2222 newdecl))
2225 }
2227 /* [dcl.fct.def.delete] A deleted definition of a function shall be the
2228 first declaration of the function or, for an explicit specialization
2229 of a function template, the first declaration of that
2230 specialization. */
2233 {
2235 {
2236 auto_diagnostic_group d;
2241 }
2243 }
2244 }
2246 /* Deal with C++: must preserve virtual function table size. */
2248 {
2258 }
2260 /* Copy all the DECL_... slots specified in the new decl except for
2261 any that we copy here from the old type. */
2265 else
2269 {
2274 /* The new decl should not already have gathered any
2275 specializations. */
2282 {
2285 {
2286 /* Per C++11 8.3.6/4, default arguments cannot be added in
2287 later declarations of a function template. */
2289 /* C++17 11.3.6/4: "If a friend declaration specifies a default
2290 argument expression, that declaration... shall be the only
2291 declaration of the function or function template in the
2292 translation unit." */
2293 check_no_redeclaration_friend_default_args
2300 }
2308 {
2311 else
2323 }
2324 else
2325 {
2333 }
2334 }
2336 /* If the new declaration is a definition, update the file and
2337 line information on the declaration, and also make
2338 the old declaration the same definition. */
2340 {
2346 {
2347 tree parm;
2356 }
2357 }
2360 }
2363 {
2367 /* Automatically handles default parameters. */
2369 tree newtype;
2371 /* For typedefs use the old type, as the new type's DECL_NAME points
2372 at newdecl, which will be ggc_freed. */
2374 {
2375 /* But NEWTYPE might have an attribute, honor that. */
2380 {
2384 }
2386 /* And remove the new type from the variants list. */
2388 {
2391 {
2393 /* If remove is the main variant, no need to remove that
2394 from the list. One of the DECL_ORIGINAL_TYPE
2395 variants, e.g. created for aligned attribute, might still
2396 refer to the newdecl TYPE_DECL though, so remove that one
2397 in that case. */
2403 {
2407 }
2408 }
2409 else
2413 {
2416 }
2417 }
2418 }
2421 else
2425 {
2427 /* For already initialized vars, TREE_READONLY could have been
2428 cleared in cp_finish_decl, because the var needs runtime
2429 initialization or destruction. Make sure not to set
2430 TREE_READONLY on it again. */
2447 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
2450 {
2451 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
2454 }
2455 }
2457 /* An explicit specialization of a function template or of a member
2458 function of a class template can be declared transaction_safe
2459 independently of whether the corresponding template entity is declared
2460 transaction_safe. */
2473 /* Lay the type out, unless already done. */
2487 /* Merge deprecatedness. */
2491 /* Merge unavailability. */
2495 /* Preserve function specific target and optimization options */
2497 {
2510 }
2511 else
2512 {
2513 /* Merge the const type qualifier. */
2516 /* Merge the volatile type qualifier. */
2519 }
2521 /* Merge the initialization information. */
2524 {
2528 {
2531 }
2532 }
2535 {
2548 else
2549 {
2550 /* Merge the noreturn bit. */
2556 }
2557 /* Keep the old RTL. */
2559 }
2562 {
2563 /* Keep the old RTL. We cannot keep the old RTL if the old
2564 declaration was for an incomplete object and the new
2565 declaration is not since many attributes of the RTL will
2566 change. */
2568 }
2569 }
2570 /* If cannot merge, then use the new type and qualifiers,
2571 and don't preserve the old rtl. */
2572 else
2573 {
2574 /* Clean out any memory we had of the old declaration. */
2584 }
2586 /* Merge the storage class information. */
2598 {
2600 /* This can happen if olddecl was brought in from the
2601 enclosing namespace via a using-decl. The new decl is
2602 then not a block-scope extern at all. */
2604 else
2605 {
2613 }
2614 }
2618 {
2630 {
2634 }
2637 {
2642 /* If the OLDDECL is an instantiation and/or specialization,
2643 then the NEWDECL must be too. But, it may not yet be marked
2644 as such if the caller has created NEWDECL, but has not yet
2645 figured out that it is a redeclaration. */
2652 }
2654 /* Don't really know how much of the language-specific
2655 values we should copy from old to new. */
2659 {
2662 {
2666 /* Remember the presence of explicit specialization args. */
2669 }
2671 /* We don't want to copy template info from a non-templated friend
2672 (PR105761), but these shouldn't have DECL_TEMPLATE_INFO now. */
2676 }
2679 {
2680 /* Only functions have these fields. */
2685 /* DECL_THUNKS is only valid for virtual functions,
2686 otherwise it is a DECL_FRIEND_CONTEXT. */
2691 }
2693 {
2694 /* Only variables have this field. */
2697 }
2698 }
2701 {
2702 tree parm;
2704 /* Merge parameter attributes. */
2709 {
2713 }
2717 {
2718 /* If newdecl is not a specialization, then it is not a
2719 template-related function at all. And that means that we
2720 should have exited above, returning 0. */
2724 /* From [temp.expl.spec]:
2726 If a template, a member template or the member of a class
2727 template is explicitly specialized then that
2728 specialization shall be declared before the first use of
2729 that specialization that would cause an implicit
2730 instantiation to take place, in every translation unit in
2731 which such a use occurs. */
2733 olddecl);
2739 /* Don't propagate visibility from the template to the
2740 specialization here. We'll do that in determine_visibility if
2741 appropriate. */
2744 /* [temp.expl.spec/14] We don't inline explicit specialization
2745 just because the primary template says so. */
2755 }
2757 {
2758 /* Never inline re-defined extern inline functions.
2759 FIXME: this could be better handled by keeping both
2760 function as separate declarations. */
2762 }
2763 else
2764 {
2766 {
2770 }
2772 ;
2786 }
2788 /* Preserve abstractness on cloned [cd]tors. */
2791 /* Update newdecl's parms to point at olddecl. */
2797 {
2801 }
2803 {
2804 /* These need to be copied so that the names are available.
2805 Note that if the types do match, we'll preserve inline
2806 info and other bits, but if not, we won't. */
2809 }
2810 /* If redeclaring a builtin function, it stays built in
2811 if newdecl is a gnu_inline definition, or if newdecl is just
2812 a declaration. */
2815 {
2817 /* If we're keeping the built-in definition, keep the rtl,
2818 regardless of declaration matches. */
2821 {
2824 {
2825 /* A compatible prototype of these builtin functions
2826 is seen, assume the runtime implements it with
2827 the expected semantics. */
2829 {
2836 }
2837 }
2840 }
2841 }
2843 /* If defining a function declared with other language
2844 linkage, use the previously declared language linkage. */
2847 {
2849 /* Don't clear out the arguments if we're just redeclaring a
2850 function. */
2853 }
2854 }
2858 /* Now preserve various other info from the definition. */
2864 /* Warn about conflicting visibility specifications. */
2868 {
2869 auto_diagnostic_group d;
2871 "%qD: visibility attribute ignored because it "
2875 }
2876 /* Choose the declaration which specified visibility. */
2878 {
2881 }
2882 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
2883 so keep this behavior. */
2885 {
2888 }
2889 /* Likewise for DECL_ALIGN, DECL_USER_ALIGN and DECL_PACKED. */
2891 {
2894 }
2907 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
2908 with that from NEWDECL below. */
2910 {
2914 }
2916 /* Merge the USED information. */
2923 {
2928 }
2935 /* Merge the DECL_FUNCTION_VERSIONED information. newdecl will be copied
2936 to olddecl and deleted. */
2939 {
2940 /* Set the flag for newdecl so that it gets copied to olddecl. */
2942 /* newdecl will be purged after copying to olddecl and is no longer
2943 a version. */
2945 }
2948 {
2962 /* Preserve symtab node mapping. */
2966 /* If newdecl is a template instantiation, it is possible that
2967 the following sequence of events has occurred:
2969 o A friend function was declared in a class template. The
2970 class template was instantiated.
2972 o The instantiation of the friend declaration was
2973 recorded on the instantiation list, and is newdecl.
2975 o Later, however, instantiate_class_template called pushdecl
2976 on the newdecl to perform name injection. But, pushdecl in
2977 turn called duplicate_decls when it discovered that another
2978 declaration of a global function with the same name already
2979 existed.
2981 o Here, in duplicate_decls, we decided to clobber newdecl.
2983 If we're going to do that, we'd better make sure that
2984 olddecl, and not newdecl, is on the list of
2985 instantiations so that if we try to do the instantiation
2986 again we won't get the clobbered declaration. */
2988 new_template_info,
2989 olddecl);
2990 }
2991 else
2992 {
3000 {
3008 {
3021 }
3029 }
3030 }
3033 {
3037 {
3038 /* Merge the section attribute.
3039 We want to issue an error if the sections conflict but that must be
3040 done later in decl_attributes since we are called before attributes
3041 are assigned. */
3046 {
3050 else
3054 }
3055 }
3059 {
3063 }
3064 }
3068 /* NEWDECL contains the merged attribute lists.
3069 Update OLDDECL to be the same. */
3072 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
3073 so that encode_section_info has a chance to look at the new decl
3074 flags and attributes. */
3081 /* The NEWDECL will no longer be needed. Because every out-of-class
3082 declaration of a member results in a call to duplicate_decls,
3083 freeing these nodes represents in a significant savings.
3085 Before releasing the node, be sore to remove function from symbol
3086 table that might have been inserted there to record comdat group.
3087 Be sure to however do not free DECL_STRUCT_FUNCTION because this
3088 structure is shared in between newdecl and oldecl. */
3092 {
3096 }
3099 {
3100 tree clone;
3102 {
3105 }
3106 }
3108 /* Remove the associated constraints for newdecl, if any, before
3109 reclaiming memory. */
3116 }
3117 \f
3118 /* Return zero if the declaration NEWDECL is valid
3119 when the declaration OLDDECL (assumed to be for the same name)
3120 has already been seen.
3121 Otherwise return an error message format string with a %s
3122 where the identifier should go. */
3126 {
3128 {
3129 /* Because C++ can put things into name space for free,
3130 constructs like "typedef struct foo { ... } foo"
3131 would look like an erroneous redeclaration. */
3134 else
3136 }
3138 {
3139 /* If this is a pure function, its olddecl will actually be
3140 the original initialization to `0' (which we force to call
3141 abort()). Don't complain about redefinition in this case. */
3146 /* If both functions come from different namespaces, this is not
3147 a redeclaration - this is a conflict with a used function. */
3153 /* We'll complain about linkage mismatches in
3154 warn_extern_redeclared_static. */
3156 /* Defining the same name twice is no good. */
3159 {
3165 }
3168 {
3173 {
3177 else
3180 }
3181 }
3187 /* [class.compare.default]: A definition of a comparison operator as
3188 defaulted that appears in a class shall be the first declaration of
3189 that function. */
3195 check_abi_tag_redeclaration
3200 }
3202 {
3226 {
3231 {
3235 else
3238 }
3239 }
3245 /* Core issue #226 (C++11):
3247 If a friend function template declaration specifies a
3248 default template-argument, that declaration shall be a
3249 definition and shall be the only declaration of the
3250 function template in the translation unit. */
3261 }
3268 {
3269 /* Only variables can be thread-local, and all declarations must
3270 agree on this property. */
3274 else
3277 }
3279 {
3280 /* The objects have been declared at namespace scope. If either
3281 is a member of an anonymous union, then this is an invalid
3282 redeclaration. For example:
3284 int i;
3285 union { int i; };
3287 is invalid. */
3291 /* If at least one declaration is a reference, there is no
3292 conflict. For example:
3294 int i = 3;
3295 extern int i;
3297 is valid. */
3301 /* Static data member declared outside a class definition
3302 if the variable is defined within the class with constexpr
3303 specifier is declaration rather than definition (and
3304 deprecated). */
3310 {
3312 /* For now, only warn with explicit -Wdeprecated. */
3314 {
3315 auto_diagnostic_group d;
3317 "redundant redeclaration of %<constexpr%> "
3321 }
3323 }
3325 /* Reject two definitions. */
3327 }
3328 else
3329 {
3330 /* Objects declared with block scope: */
3331 /* Reject two definitions, and reject a definition
3332 together with an external reference. */
3336 }
3337 }
3338 \f
3340 /* Hash and equality functions for the named_label table. */
3342 hashval_t
3344 {
3346 }
3348 bool
3350 {
3352 }
3354 /* Look for a label named ID in the current function. If one cannot
3355 be found, create one. Return the named_label_entry, or NULL on
3356 failure. */
3360 {
3363 /* You can't use labels at global scope. */
3365 {
3368 }
3374 named_label_entry **slot
3379 {
3384 {
3388 }
3389 }
3391 /* We are making a new decl, create or reuse the named_label_entry */
3395 else
3396 {
3401 }
3403 /* Now create the LABEL_DECL. */
3409 {
3413 }
3418 }
3420 /* Wrapper for lookup_label_1. */
3422 tree
3424 {
3427 }
3429 tree
3431 {
3434 }
3436 /* Returns nonzero if it is ill-formed to jump past the declaration of
3437 DECL. Returns 2 if it's also a real problem. */
3439 static int
3441 {
3442 /* [stmt.dcl]/3: A program that jumps from a point where a local variable
3443 with automatic storage duration is not in scope to a point where it is
3444 in scope is ill-formed unless the variable has scalar type, class type
3445 with a trivial default constructor and a trivial destructor, a
3446 cv-qualified version of one of these types, or an array of one of the
3447 preceding types and is declared without an initializer (8.5). */
3462 }
3464 /* A subroutine of check_previous_goto_1 and check_goto to identify a branch
3465 to the user. */
3467 static bool
3469 diagnostic_t diag_kind)
3470 {
3471 bool complained
3478 }
3480 /* Check that a single previously seen jump to a newly defined label
3481 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
3482 the jump context; NAMES are the names in scope in LEVEL at the jump
3483 context; LOCUS is the source position of the jump or 0. Returns
3484 true if all is well. */
3486 static bool
3489 {
3497 {
3503 }
3506 {
3512 {
3518 {
3523 }
3525 {
3529 else
3531 " enters scope of %q#D, which has "
3533 }
3534 }
3542 {
3575 {
3579 }
3581 {
3585 }
3590 }
3593 {
3599 }
3600 }
3603 }
3605 static void
3607 {
3611 }
3613 static bool
3615 {
3617 }
3619 /* Check that a new jump to a label DECL is OK. Called by
3620 finish_goto_stmt. */
3622 void
3624 {
3625 /* We can't know where a computed goto is jumping.
3626 So we assume that it's OK. */
3631 named_label_entry **slot
3635 /* If the label hasn't been defined yet, defer checking. */
3637 {
3638 /* Don't bother creating another use if the last goto had the
3639 same data, and will therefore create the same set of errors. */
3644 named_label_use_entry *new_use
3654 }
3658 tree bad;
3665 {
3674 }
3677 {
3681 {
3682 /* Can't skip init of __exception_info. */
3684 {
3688 }
3692 }
3694 {
3698 else
3700 " enters scope of %q#D which has "
3702 }
3703 }
3706 {
3719 }
3722 {
3725 }
3728 {
3732 {
3734 {
3739 }
3743 }
3744 }
3745 }
3747 /* Check that a return is ok wrt OpenMP structured blocks.
3748 Called by finish_return_stmt. Returns true if all is well. */
3750 bool
3752 {
3755 {
3758 }
3762 }
3764 /* Define a label, specifying the location in the source file.
3765 Return the LABEL_DECL node for the label. */
3767 tree
3769 {
3772 /* After labels, make any new cleanups in the function go into their
3773 own new (temporary) binding contour. */
3783 {
3786 }
3787 else
3788 {
3789 /* Mark label as having been defined. */
3791 /* Say where in the source. */
3800 }
3803 }
3805 struct cp_switch
3806 {
3809 /* The SWITCH_STMT being built. */
3810 tree switch_stmt;
3811 /* A splay-tree mapping the low element of a case range to the high
3812 element, or NULL_TREE if there is no high element. Used to
3813 determine whether or not a new case label duplicates an old case
3814 label. We need a tree, rather than simply a hash table, because
3815 of the GNU case range extension. */
3816 splay_tree cases;
3817 /* Remember whether a default: case label has been seen. */
3819 /* Remember whether a BREAK_STMT has been seen in this SWITCH_STMT. */
3821 /* Set if inside of {FOR,DO,WHILE}_BODY nested inside of a switch,
3822 where BREAK_STMT doesn't belong to the SWITCH_STMT. */
3824 };
3826 /* A stack of the currently active switch statements. The innermost
3827 switch statement is on the top of the stack. There is no need to
3828 mark the stack for garbage collection because it is only active
3829 during the processing of the body of a function, and we never
3830 collect at that point. */
3834 /* Called right after a switch-statement condition is parsed.
3835 SWITCH_STMT is the switch statement being parsed. */
3837 void
3839 {
3849 }
3851 void
3853 {
3856 /* Emit warnings as needed. */
3859 const bool bool_cond_p
3865 bool_cond_p);
3867 /* For the benefit of block_may_fallthru remember if the switch body
3868 case labels cover all possible values and if there are break; stmts. */
3870 || (!processing_template_decl
3876 /* Now that we're done with the switch warnings, set the switch type
3877 to the type of the condition if the index type was of scoped enum type.
3878 (Such types don't participate in the integer promotions.) We do this
3879 because of bit-fields whose declared type is a scoped enum type:
3880 gimplification will use the lowered index type, but convert the
3881 case values to SWITCH_STMT_TYPE, which would have been the declared type
3882 and verify_gimple_switch doesn't accept that. */
3889 }
3891 /* Note that a BREAK_STMT is about to be added. If it is inside of
3892 a SWITCH_STMT and not inside of a loop body inside of it, note
3893 in switch_stack we've seen a BREAK_STMT. */
3895 void
3897 {
3900 }
3902 /* Note the start of processing of an iteration statement's body.
3903 The note_break_stmt function will do nothing while processing it.
3904 Return a flag that should be passed to note_iteration_stmt_body_end. */
3906 bool
3908 {
3914 }
3916 /* Note the end of processing of an iteration statement's body. */
3918 void
3920 {
3923 }
3925 /* Convert a case constant VALUE in a switch to the type TYPE of the switch
3926 condition. Note that if TYPE and VALUE are already integral we don't
3927 really do the conversion because the language-independent
3928 warning/optimization code will work better that way. */
3930 static tree
3932 {
3942 /* The constant-expression VALUE shall be a converted constant expression
3943 of the adjusted type of the switch condition, which doesn't allow
3944 narrowing conversions. */
3951 else
3952 /* The already integral case. */
3956 }
3958 /* Note that we've seen a definition of a case label, and complain if this
3959 is a bad place for one. */
3961 tree
3963 {
3966 tree type;
3972 {
3973 tree label;
3975 /* For templates, just add the case label; we'll do semantic
3976 analysis at instantiation-time. */
3979 }
3981 /* Find the condition on which this switch statement depends. */
3998 /* After labels, make any new cleanups in the function go into their
3999 own new (temporary) binding contour. */
4006 }
4007 \f
4009 tree scope;
4010 tree name;
4011 tree template_id;
4014 };
4017 {
4020 /* Hash a TYPENAME_TYPE. */
4022 static hashval_t
4024 {
4029 }
4031 static hashval_t
4033 {
4035 }
4037 static hashval_t
4039 {
4041 }
4043 /* Compare two TYPENAME_TYPEs. */
4045 static bool
4047 {
4053 }
4054 };
4056 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
4057 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
4059 Returns the new TYPENAME_TYPE. */
4063 tree
4066 {
4067 typename_info ti;
4081 /* See if we already have this type. */
4086 else
4087 {
4088 /* Build the TYPENAME_TYPE. */
4095 /* Build the corresponding TYPE_DECL. */
4102 /* Store it in the hash table. */
4105 /* TYPENAME_TYPEs must always be compared structurally, because
4106 they may or may not resolve down to another type depending on
4107 the currently open classes. */
4109 }
4112 }
4114 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
4115 provided to name the type. Returns an appropriate type, unless an
4116 error occurs, in which case error_mark_node is returned. If we
4117 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
4118 return that, rather than the _TYPE it corresponds to, in other
4119 cases we look through the type decl. If TF_ERROR is set, complain
4120 about errors, otherwise be quiet. */
4122 tree
4124 tsubst_flags_t complain)
4125 {
4126 tree fullname;
4127 tree t;
4136 {
4141 else
4142 /* Create a TEMPLATE_ID_EXPR for the type. */
4146 }
4153 {
4158 {
4162 }
4163 }
4165 {
4169 }
4171 {
4175 }
4182 {
4186 }
4188 /* When the CONTEXT is a dependent type, NAME could refer to a
4189 dependent base class of CONTEXT. But look inside it anyway
4190 if CONTEXT is a currently open scope, in case it refers to a
4191 member of the current instantiation or a non-dependent base;
4192 lookup will stop when we hit a dependent base. */
4194 /* We should only set WANT_TYPE when we're a nested typename type.
4195 Then we can give better diagnostics if we find a non-type. */
4197 else
4206 {
4208 {
4211 else
4214 }
4216 }
4218 /* Pull out the template from an injected-class-name (or multiple). */
4223 {
4225 {
4228 }
4230 }
4233 {
4238 }
4240 {
4243 /* The caller permits this typename-specifier to name a template
4245 else
4246 {
4251 }
4252 }
4262 {
4270 }
4278 }
4280 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
4281 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
4282 in which case error_mark_node is returned.
4284 If PARM_LIST is non-NULL, also make sure that the template parameter
4285 list of TEMPLATE_DECL matches.
4287 If COMPLAIN zero, don't complain about any errors that occur. */
4289 tree
4291 tsubst_flags_t complain)
4292 {
4301 {
4311 {
4315 }
4319 {
4321 {
4325 }
4327 }
4330 complain))
4334 }
4337 }
4339 /* Build an UNBOUND_CLASS_TEMPLATE. */
4341 tree
4343 {
4344 /* Build the UNBOUND_CLASS_TEMPLATE. */
4350 /* Build the corresponding TEMPLATE_DECL. */
4359 }
4361 \f
4363 /* Push the declarations of builtin types into the global namespace.
4364 RID_INDEX is the index of the builtin type in the array
4365 RID_POINTERS. NAME is the name used when looking up the builtin
4366 type. TYPE is the _TYPE node for the builtin type.
4368 The calls to set_global_binding below should be
4369 eliminated. Built-in types should not be looked up name; their
4370 names are keywords that the parser can recognize. However, there
4371 is code in c-common.cc that uses identifier_global_value to look up
4372 built-in types by name. */
4374 void
4377 tree type)
4378 {
4382 {
4388 }
4393 {
4399 }
4402 {
4406 }
4407 }
4409 /* Push a type into the namespace so that the back ends ignore it. */
4411 static void
4413 {
4416 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
4423 }
4425 /* Create all the predefined identifiers. */
4427 static void
4429 {
4430 struct predefined_identifier
4431 {
4435 };
4437 /* A table of identifiers to create at startup. */
4441 /* Some of these names have a trailing space so that it is
4442 impossible for them to conflict with names written by users. */
4459 /* The demangler expects anonymous namespaces to be called
4460 something starting with '_GLOBAL__N_'. It no longer needs
4461 to be unique to the TU. */
4491 };
4495 {
4497 /* Some of these identifiers already have a special kind. */
4500 }
4501 }
4503 /* Create the predefined scalar types of C,
4504 and some nodes representing standard constants (0, 1, (void *)0).
4505 Initialize the global binding level.
4506 Make definitions for built-in primitive functions. */
4508 void
4510 {
4511 tree void_ftype;
4512 tree void_ftype_ptr;
4514 /* Create all the identifiers we need. */
4517 /* Create the global variables. */
4522 /* Enter the global namespace. */
4525 void_type_node);
4530 /* Remember whether we want the empty class passing ABI change warning
4531 in this TU. */
4534 debug_hooks->register_main_translation_unit
4542 /* Initially, C. */
4545 /* Create the `std' namespace. */
4555 tree decl
4568 NULL_TREE);
4569 decl
4571 bool_vaftype,
4572 CP_BUILT_IN_IS_CORRESPONDING_MEMBER,
4576 decl
4578 bool_vaftype,
4579 CP_BUILT_IN_IS_POINTER_INTERCONVERTIBLE_WITH_CLASS,
4585 /* Guess at the initial static decls size. */
4588 /* ... and keyed classes. */
4600 NULL_TREE);
4602 #if 0
4604 #endif
4613 void_ftype_ptr
4616 /* Create the conversion operator marker. This operator's DECL_NAME
4617 is in the identifier table, so we can use identifier equality to
4618 find it. */
4620 void_ftype);
4622 /* C++ extensions */
4627 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
4630 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
4631 result. */
4638 /* Used when parsing to distinguish parameter-lists () and (void). */
4641 {
4642 /* Make sure we get a unique function type, so we can give
4643 its pointer type a name. (This wins for gdb.) */
4650 }
4653 vtbl_type_node
4669 /* Now, C++. */
4674 {
4676 aligned_new_threshold);
4678 }
4684 {
4687 tree ptr_ftype_sizetype;
4688 tree new_eh_spec;
4690 ptr_ftype_sizetype
4693 {
4694 tree bad_alloc_id;
4695 tree bad_alloc_type_node;
4696 tree bad_alloc_decl;
4702 bad_alloc_decl
4707 new_eh_spec
4709 }
4710 else
4713 /* Ensure attribs.cc is initialized. */
4717 NULL_TREE);
4720 extvisattr);
4740 {
4741 /* Also push the sized deallocation variants:
4742 void operator delete(void*, std::size_t) throw();
4743 void operator delete[](void*, std::size_t) throw(); */
4744 tree void_ftype_ptr_size
4748 extvisattr);
4756 }
4759 {
4766 /* operator new (size_t, align_val_t); */
4780 /* operator delete (void *, align_val_t); */
4793 {
4794 /* operator delete (void *, size_t, align_val_t); */
4797 NULL_TREE);
4806 }
4807 }
4809 /* C++-specific nullptr initialization. */
4813 }
4818 abort_fndecl
4822 /* If no definition is available, resolve references to NULL. */
4825 /* Perform other language dependent initializations. */
4839 /* Show we use EH for cleanups. */
4843 /* Check that the hardware interference sizes are at least
4844 alignof(max_align_t), as required by the standard. */
4847 {
4853 "%<--param destructive-interference-size=%d%> "
4856 }
4861 /* else leave it unset. */
4864 {
4871 "%<--param constructive-interference-size=%d%> "
4874 }
4879 }
4881 /* Enter an abi node in global-module context. returns a cookie to
4882 give to pop_abi_namespace. */
4884 unsigned
4886 {
4892 }
4894 /* Pop an abi namespace, FLAGS is the cookie push_abi_namespace gave
4895 you. */
4897 void
4899 {
4903 }
4905 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give
4906 the decl, LOC is the location to give the decl, NAME is the
4907 initialization string and TYPE_DEP indicates whether NAME depended
4908 on the type of the function. We make use of that to detect
4909 __PRETTY_FUNCTION__ inside a template fn. This is being done lazily
4910 at the point of first use, so we mustn't push the decl now. */
4912 static tree
4914 {
4919 {
4926 {
4927 /* __FUNCTION__ */
4930 }
4931 else
4932 {
4933 /* __PRETTY_FUNCTION__ */
4936 }
4943 }
4950 else
4964 /* For decl_constant_var_p. */
4968 {
4973 }
4974 else
4975 {
4978 }
4981 }
4983 /* Install DECL as a builtin function at current global scope. Return
4984 the new decl (if we found an existing version). Also installs it
4985 into ::std, if it's not '_*'. */
4987 tree
4989 {
4994 /* Runtime library routines are, by definition, available in an
4995 external shared object. */
5003 /* In the user's namespace, it must be declared before use. */
5009 /* Treat __*_chk fortification functions as anticipated as well,
5010 unless they are __builtin_*_chk. */
5013 /* All builtins that don't begin with an '_' should additionally
5014 go in the 'std' namespace. */
5016 {
5023 }
5029 }
5031 /* Like cxx_builtin_function, but guarantee the function is added to the global
5032 scope. This is to allow function specific options to add new machine
5033 dependent builtins when the target ISA changes via attribute((target(...)))
5034 which saves space on program startup if the program does not use non-generic
5035 ISAs. */
5037 tree
5039 {
5045 }
5047 /* Implement LANG_HOOKS_SIMULATE_BUILTIN_FUNCTION_DECL. */
5049 tree
5051 {
5058 }
5060 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
5061 function. Not called directly. */
5063 static tree
5066 {
5074 /* Runtime library routines are, by definition, available in an
5075 external shared object. */
5080 }
5082 /* Returns the _DECL for a library function with C++ linkage. */
5084 static tree
5087 {
5092 }
5094 /* Like build_library_fn, but takes a C string instead of an
5095 IDENTIFIER_NODE. */
5097 tree
5099 {
5101 }
5103 /* Like build_cp_library_fn, but takes a C string instead of an
5104 IDENTIFIER_NODE. */
5106 tree
5108 {
5110 ecf_flags);
5111 }
5113 /* Like build_library_fn, but also pushes the function so that we will
5114 be able to find it via get_global_binding. Also, the function
5115 may throw exceptions listed in RAISES. */
5117 tree
5119 {
5125 }
5127 /* Like build_cp_library_fn, but also pushes the function so that it
5128 will be found by normal lookup. */
5130 static tree
5133 {
5140 }
5142 /* Like push_library_fn, but also note that this function throws
5143 and does not return. Used for __throw_foo and the like. */
5145 tree
5147 {
5150 }
5151 \f
5152 /* When we call finish_struct for an anonymous union, we create
5153 default copy constructors and such. But, an anonymous union
5154 shouldn't have such things; this function undoes the damage to the
5155 anonymous union type T.
5157 (The reason that we create the synthesized methods is that we don't
5158 distinguish `union { int i; }' from `typedef union { int i; } U'.
5159 The first is an anonymous union; the second is just an ordinary
5160 union type.) */
5162 void
5164 {
5165 /* Wipe out memory of synthesized methods. */
5173 /* Splice the implicitly generated functions out of TYPE_FIELDS and diagnose
5174 invalid members. */
5176 {
5179 else
5189 {
5190 /* We already complained about static data members in
5191 finish_static_data_member_decl. */
5193 {
5194 auto_diagnostic_group d;
5198 "only have public non-static data members"
5201 {
5204 {
5207 "this flexibility is deprecated and will be "
5209 }
5210 }
5211 }
5212 }
5213 }
5215 /* Splice all functions out of CLASSTYPE_MEMBER_VEC. */
5223 /* Wipe RTTI info. */
5226 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
5227 assignment operators (because they cannot have these methods themselves).
5228 For anonymous unions this is already checked because they are not allowed
5229 in any union, otherwise we have to check it. */
5231 {
5235 {
5237 /* Avoid ICE after error on anon-struct9.C. */
5239 }
5243 {
5246 {
5256 }
5257 }
5258 }
5259 }
5261 /* Warn for an attribute located at LOCATION that appertains to the
5262 class type CLASS_TYPE that has not been properly placed after its
5263 class-key, in it class-specifier. */
5265 void
5267 tree class_type)
5268 {
5271 auto_diagnostic_group d;
5273 "attribute ignored in declaration "
5278 }
5280 /* Returns the cv-qualifiers that apply to the type specified
5281 by the DECLSPECS. */
5283 static int
5285 {
5296 }
5298 /* Make sure that a declaration with no declarator is well-formed, i.e.
5299 just declares a tagged type or anonymous union.
5301 Returns the type declared; or NULL_TREE if none. */
5303 tree
5306 {
5309 /* If a class, struct, or enum type is declared by the DECLSPECS
5310 (i.e, if a class-specifier, enum-specifier, or non-typename
5311 elaborated-type-specifier appears in the DECLSPECS),
5312 DECLARED_TYPE is set to the corresponding type. */
5320 {
5326 }
5338 {
5340 "%<auto%> can only be specified for variables "
5343 }
5350 /* Check for an anonymous union. */
5353 {
5354 /* 7/3 In a simple-declaration, the optional init-declarator-list
5355 can be omitted only when declaring a class (clause 9) or
5356 enumeration (7.2), that is, when the decl-specifier-seq contains
5357 either a class-specifier, an elaborated-type-specifier with
5358 a class-key (9.1), or an enum-specifier. In these cases and
5359 whenever a class-specifier or enum-specifier is present in the
5360 decl-specifier-seq, the identifiers in these specifiers are among
5361 the names being declared by the declaration (as class-name,
5362 enum-names, or enumerators, depending on the syntax). In such
5363 cases, and except for the declaration of an unnamed bit-field (9.6),
5364 the decl-specifier-seq shall introduce one or more names into the
5365 program, or shall redeclare a name introduced by a previous
5366 declaration. [Example:
5367 enum { }; // ill-formed
5368 typedef class { }; // ill-formed
5369 --end example] */
5371 {
5375 }
5382 }
5384 else
5385 {
5393 && (!current_class_type
5402 "a storage class can only be specified for objects "
5406 "%<const%> can only be specified for objects and "
5410 "%<volatile%> can only be specified for objects and "
5414 "%<__restrict%> can only be specified for objects and "
5418 "%<__thread%> can only be specified for objects "
5432 }
5435 {
5436 location_t loc;
5439 /* For a non-template class, use the name location. */
5441 else
5442 /* For a template class (an explicit instantiation), use the
5443 current location. */
5447 /* [dcl.attr.grammar]/4:
5449 No attribute-specifier-seq shall appertain to an explicit
5450 instantiation. */
5451 {
5454 declared_type))
5456 "no attribute can be applied to "
5458 }
5459 else
5461 }
5464 }
5466 /* Called when a declaration is seen that contains no names to declare.
5467 If its type is a reference to a structure, union or enum inherited
5468 from a containing scope, shadow that tag name for the current scope
5469 with a forward reference.
5470 If its type defines a new named structure or union
5471 or defines an enum, it is valid but we need not do anything here.
5472 Otherwise, it is an error.
5474 C++: may have to grok the declspecs to learn about static,
5475 complain for anonymous unions.
5477 Returns the TYPE declared -- or NULL_TREE if none. */
5479 tree
5481 {
5492 /* This is where the variables in an anonymous union are
5493 declared. An anonymous union declaration looks like:
5494 union { ... } ;
5495 because there is no declarator after the union, the parser
5496 sends that declaration here. */
5498 {
5502 {
5506 }
5507 }
5510 }
5511 \f
5512 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
5514 tree
5518 {
5519 tree attrs;
5520 tree type;
5521 enum decl_context context
5527 {
5532 /* A template type parameter or other dependent type. */
5535 else
5537 }
5539 }
5541 /* Process a DECLARATOR for a function-scope or namespace-scope
5542 variable or function declaration.
5543 (Function definitions go through start_function; class member
5544 declarations appearing in the body of the class go through
5545 grokfield.) The DECL corresponding to the DECLARATOR is returned.
5546 If an error occurs, the error_mark_node is returned instead.
5548 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED is
5549 SD_INITIALIZED if an explicit initializer is present, or SD_DEFAULTED
5550 for an explicitly defaulted function, or SD_DELETED for an explicitly
5551 deleted function, but 0 (SD_UNINITIALIZED) if this is a variable
5552 implicitly initialized via a default constructor. It can also be
5553 SD_DECOMPOSITION which behaves much like SD_INITIALIZED, but we also
5554 mark the new decl as DECL_DECOMPOSITION_P.
5556 ATTRIBUTES and PREFIX_ATTRIBUTES are GNU attributes associated with this
5557 declaration.
5559 The scope represented by the context of the returned DECL is pushed
5560 (if it is not the global namespace) and is assigned to
5561 *PUSHED_SCOPE_P. The caller is then responsible for calling
5562 pop_scope on *PUSHED_SCOPE_P if it is set. */
5564 tree
5568 tree attributes,
5569 tree prefix_attributes,
5571 {
5572 tree decl;
5573 tree context;
5577 tree initial;
5597 {
5602 }
5604 /* Save the DECL_INITIAL value in case it gets clobbered to assist
5605 with attribute validation. */
5609 {
5613 decl);
5617 /* Tell 'cplus_decl_attributes' this is an initialized decl,
5618 even though we might not yet have the initializer expression. */
5621 }
5627 /* If this is a typedef that names the class for linkage purposes
5628 (7.1.3p8), apply any attributes directly to the type. */
5633 else
5636 /* Set attributes here so if duplicate decl, will have proper attributes. */
5639 /* Restore the original DECL_INITIAL that we may have clobbered earlier to
5640 assist with attribute validation. */
5643 /* Dllimported symbols cannot be defined. Static data members (which
5644 can be initialized in-class and dllimported) go through grokfield,
5645 not here, so we don't need to exclude those decls when checking for
5646 a definition. */
5648 {
5652 }
5654 /* If #pragma weak was used, mark the decl weak now. */
5666 {
5670 {
5680 {
5686 }
5687 else
5688 {
5693 {
5700 }
5701 /* Static data member are tricky; an in-class initialization
5702 still doesn't provide a definition, so the in-class
5703 declaration will have DECL_EXTERNAL set, but will have an
5704 initialization. Thus, duplicate_decls won't warn
5705 about this situation, and so we check here. */
5713 }
5714 }
5715 else
5716 {
5718 this_tmpl
5719 ? current_template_parms
5724 }
5726 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
5728 /* Do not mark DECL as an explicit specialization if it was not
5729 already marked as an instantiation; a declaration should
5730 never be marked as a specialization unless we know what
5731 template is being specialized. */
5733 {
5738 else
5741 /* [temp.expl.spec] An explicit specialization of a static data
5742 member of a template is a definition if the declaration
5743 includes an initializer; otherwise, it is a declaration.
5745 We check for processing_specialization so this only applies
5746 to the new specialization syntax. */
5749 }
5752 /* Aliases are definitions. */
5756 decl);
5757 }
5759 /* Create a DECL_LANG_SPECIFIC so that DECL_DECOMPOSITION_P works. */
5767 {
5768 /* A function-scope decl of some namespace-scope decl. */
5772 "block-scope extern declaration %q#D not permitted"
5774 }
5776 /* Enter this declaration into the symbol table. Don't push the plain
5777 VAR_DECL for a variable template. */
5791 /* But not templated variables. */
5793 {
5794 /* This is a const variable with implicit 'static'. Set
5795 DECL_THIS_STATIC so we can tell it from variables that are
5796 !TREE_PUBLIC because of the anonymous namespace. */
5799 }
5804 {
5808 "%qD defined %<thread_local%> in %qs function only "
5814 "%qD defined %<static%> in %qs function only available "
5818 else
5822 }
5828 }
5830 /* Process the declaration of a variable DECL. INITIALIZED is true
5831 iff DECL is explicitly initialized. (INITIALIZED is false if the
5832 variable is initialized via an implicitly-called constructor.)
5833 This function must be called for ordinary variables (including, for
5834 example, implicit instantiations of templates), but must not be
5835 called for template declarations. */
5837 void
5839 {
5849 bool aggregate_definition_p
5852 /* If an explicit initializer is present, or if this is a definition
5853 of an aggregate, then we need a complete type at this point.
5854 (Scalars are always complete types, so there is nothing to
5855 check.) This code just sets COMPLETE_P; errors (if necessary)
5856 are issued below. */
5858 && !complete_p
5860 {
5862 /* We will not yet have set TREE_READONLY on DECL if the type
5863 was "const", but incomplete, before this point. But, now, we
5864 have a complete type, so we can try again. */
5866 }
5869 /* Is it valid for this decl to have an initializer at all? */
5870 {
5871 /* Don't allow initializations for incomplete types except for
5872 arrays which might be completed by the initialization. */
5878 {
5881 }
5883 {
5886 /* else we already gave an error in start_decl. */
5887 }
5888 }
5890 {
5893 else
5894 {
5896 decl);
5897 /* Change the type so that assemble_variable will give
5898 DECL an rtl we can live with: (mem (const_int 0)). */
5900 }
5901 }
5903 /* Create a new scope to hold this declaration if necessary.
5904 Whether or not a new scope is necessary cannot be determined
5905 until after the type has been completed; if the type is a
5906 specialization of a class template it is not until after
5907 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
5908 will be set correctly. */
5910 }
5912 /* Given a parenthesized list of values INIT, create a CONSTRUCTOR to handle
5913 C++20 P0960. TYPE is the type of the object we're initializing. */
5915 tree
5917 {
5921 {
5922 /* If the list has a single element and it's a string literal,
5923 then it's the initializer for the array as a whole. */
5929 /* Handle non-standard extensions like compound literals. This also
5930 prevents triggering aggregate parenthesized-initialization in
5931 compiler-generated code for =default. */
5935 }
5941 }
5943 /* Handle initialization of references. DECL, TYPE, and INIT have the
5944 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
5945 but will be set to a new CLEANUP_STMT if a temporary is created
5946 that must be destroyed subsequently.
5948 Returns an initializer expression to use to initialize DECL, or
5949 NULL if the initialization can be performed statically.
5951 Quotes on semantics can be found in ARM 8.4.3. */
5953 static tree
5955 {
5957 {
5964 }
5968 {
5969 /* This handles (C++20 only) code like
5971 const A& r(1, 2, 3);
5973 where we treat the parenthesized list as a CONSTRUCTOR. */
5978 {
5979 /* We don't know yet if we should treat const A& r(1) as
5980 const A& r{1}. */
5982 {
5985 tf_warning_or_error);
5986 }
5987 /* If the list had more than one element, the code is ill-formed
5988 pre-C++20, so we can build a constructor right away. */
5989 else
5991 }
5992 else
5994 tf_warning_or_error);
5995 }
5999 /* Note: default conversion is only called in very special cases. */
6002 /* check_initializer handles this for non-reference variables, but for
6003 references we need to do it here or the initializer will get the
6004 incomplete array type and confuse later calls to
6005 cp_complete_array_type. */
6010 {
6014 }
6016 /* Convert INIT to the reference type TYPE. This may involve the
6017 creation of a temporary, whose lifetime must be the same as that
6018 of the reference. If so, a DECL_EXPR for the temporary will be
6019 added just after the DECL_EXPR for DECL. That's why we don't set
6020 DECL_INITIAL for local references (instead assigning to them
6021 explicitly); we need to allow the temporary to be initialized
6022 first. */
6024 tf_warning_or_error);
6025 }
6027 /* Designated initializers in arrays are not supported in GNU C++.
6028 The parser cannot detect this error since it does not know whether
6029 a given brace-enclosed initializer is for a class type or for an
6030 array. This function checks that CE does not use a designated
6031 initializer. If it does, an error is issued. Returns true if CE
6032 is valid, i.e., does not have a designated initializer. */
6034 bool
6037 {
6038 /* Designated initializers for array elements are not supported. */
6040 {
6041 /* The parser only allows identifiers as designated
6042 initializers. */
6044 {
6048 }
6050 {
6054 }
6062 {
6063 /* A C99 designator is OK if it matches the current index. */
6065 {
6068 }
6069 else
6071 }
6072 else
6078 }
6081 }
6083 /* When parsing `int a[] = {1, 2};' we don't know the size of the
6084 array until we finish parsing the initializer. If that's the
6085 situation we're in, update DECL accordingly. */
6087 static void
6089 {
6095 {
6096 /* do_default is really a C-ism to deal with tentative definitions.
6097 But let's leave it here to ease the eventual merge. */
6102 /* Check that there are no designated initializers in INIT, as
6103 those are not supported in GNU C++, and as the middle-end
6104 will crash if presented with a non-numeric designated
6105 initializer. */
6107 {
6110 HOST_WIDE_INT i;
6112 {
6117 /* If an un-designated initializer is type-dependent, we can't
6118 check brace elision yet. */
6122 }
6123 }
6127 else
6128 {
6130 do_default);
6132 {
6136 }
6138 {
6140 {
6143 }
6144 /* If a `static' var's size isn't known, make it extern as
6145 well as static, so it does not get allocated. If it's not
6146 `static', then don't mark it extern; finish_incomplete_decl
6147 will give it a default size and it will get allocated. */
6150 }
6152 {
6155 }
6156 }
6161 }
6162 }
6164 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
6165 any appropriate error messages regarding the layout. */
6167 static void
6169 {
6170 tree type;
6176 /* If we haven't already laid out this declaration, do so now.
6177 Note that we must not call complete type for an external object
6178 because it's type might involve templates that we are not
6179 supposed to instantiate yet. (And it's perfectly valid to say
6180 `extern X x' for some incomplete type `X'.) */
6189 {
6190 /* An automatic variable with an incomplete type: that is an error.
6191 Don't talk about array types here, since we took care of that
6192 message in grokdeclarator. */
6196 }
6197 #if 0
6198 /* Keep this code around in case we later want to control debug info
6199 based on whether a type is "used". (jason 1999-11-11) */
6202 /* Let debugger know it should output info for this type. */
6207 #endif
6212 {
6216 else
6217 {
6222 }
6223 }
6225 /* If the final element initializes a flexible array field, add the size of
6226 that initializer to DECL's size. */
6236 {
6239 {
6246 {
6252 }
6253 }
6254 }
6255 }
6257 /* If a local static variable is declared in an inline function, or if
6258 we have a weak definition, we must endeavor to create only one
6259 instance of the variable at link-time. */
6261 void
6263 {
6264 /* Don't mess with __FUNCTION__ and similar. */
6268 /* Static data in a function with comdat linkage also has comdat
6269 linkage. */
6274 {
6276 {
6277 /* With weak symbols, we simply make the variable COMDAT;
6278 that will cause copies in multiple translations units to
6279 be merged. */
6281 }
6282 else
6283 {
6286 {
6287 /* Without weak symbols, we can use COMMON to merge
6288 uninitialized variables. */
6291 }
6292 else
6293 {
6294 /* While for initialized variables, we must use internal
6295 linkage -- which means that multiple copies will not
6296 be merged. */
6303 "%q#D are wrong (you%'ll wind up with "
6305 else
6307 "static data %q#D are wrong (you%'ll wind "
6313 }
6314 }
6315 }
6316 }
6318 /* Issue an error message if DECL is an uninitialized const variable.
6319 CONSTEXPR_CONTEXT_P is true when the function is called in a constexpr
6320 context from potential_constant_expression. Returns true if all is well,
6321 false otherwise. */
6323 bool
6325 tsubst_flags_t complain)
6326 {
6329 /* ``Unless explicitly declared extern, a const object does not have
6330 external linkage and must be initialized. ($8.4; $12.1)'' ARM
6331 7.1.6 */
6335 /* C++20 permits trivial default initialization in constexpr
6336 context (P1331R2). */
6338 && (constexpr_context_p
6341 {
6349 {
6351 {
6355 }
6356 else
6357 {
6361 "uninitialized variable %qD in %<constexpr%> "
6363 else
6366 }
6367 }
6371 decl);
6374 {
6375 tree defaulted_ctor;
6382 "constructor is not user-provided because it is "
6385 "and the implicitly-defined constructor does not "
6387 }
6390 }
6393 }
6394 \f
6395 /* Structure holding the current initializer being processed by reshape_init.
6396 CUR is a pointer to the current element being processed, END is a pointer
6397 after the last element present in the initializer. */
6398 struct reshape_iter
6399 {
6402 };
6406 /* FIELD is an element of TYPE_FIELDS or NULL. In the former case, the value
6407 returned is the next FIELD_DECL (possibly FIELD itself) that can be
6408 initialized as if for an aggregate class. If there are no more such fields,
6409 the return value will be NULL. */
6411 tree
6413 {
6418 /* In C++17, aggregates can have bases. */
6423 }
6425 /* FIELD is an element of TYPE_FIELDS or NULL. In the former case, the value
6426 returned is the next FIELD_DECL (possibly FIELD itself) that corresponds
6427 to a subobject. If there are no more such fields, the return value will be
6428 NULL. */
6430 tree
6432 {
6442 }
6444 /* Return true for [dcl.init.list] direct-list-initialization from
6445 single element of enumeration with a fixed underlying type. */
6447 bool
6449 {
6456 /* DR 2374: The single element needs to be implicitly
6457 convertible to the underlying type of the enum. */
6464 }
6466 /* Subroutine of reshape_init_array and reshape_init_vector, which does
6467 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
6468 INTEGER_CST representing the size of the array minus one (the maximum index),
6469 or NULL_TREE if the array was declared without specifying the size. D is
6470 the iterator within the constructor. */
6472 static tree
6475 {
6476 tree new_init;
6481 /* The initializer for an array is always a CONSTRUCTOR. If this is the
6482 outermost CONSTRUCTOR and the element type is non-aggregate, we don't need
6483 to build a new one. But don't reuse if not complaining; if this is
6484 tentative, we might also reshape to another type (95319). */
6491 else
6495 {
6496 /* Minus 1 is used for zero sized arrays. */
6502 /* sizetype is sign extended, not zero extended. */
6503 else
6505 }
6507 /* Loop until there are no more initializers. */
6511 {
6512 tree elt_init;
6520 complain);
6525 {
6528 }
6529 else
6535 /* This can happen with an invalid initializer (c++/54501). */
6538 }
6541 }
6543 /* Subroutine of reshape_init_r, processes the initializers for arrays.
6544 Parameters are the same of reshape_init_r. */
6546 static tree
6548 tsubst_flags_t complain)
6549 {
6559 }
6561 /* Subroutine of reshape_init_r, processes the initializers for vectors.
6562 Parameters are the same of reshape_init_r. */
6564 static tree
6566 {
6572 {
6575 {
6580 }
6583 }
6585 /* For a vector, we initialize it as an array of the appropriate size. */
6591 }
6593 /* Subroutine of reshape_init*: We're initializing an element with TYPE from
6594 INIT, in isolation from any designator or other initializers. */
6596 static tree
6598 {
6599 /* We could also implement this by wrapping init in a new CONSTRUCTOR and
6600 calling reshape_init, but this way can just live on the stack. */
6605 complain);
6606 }
6608 /* Subroutine of reshape_init_r, processes the initializers for classes
6609 or union. Parameters are the same of reshape_init_r. */
6611 static tree
6613 tsubst_flags_t complain)
6614 {
6615 tree field;
6616 tree new_init;
6620 /* The initializer for a class is always a CONSTRUCTOR. */
6627 {
6628 /* We get here from maybe_aggr_guide for C++20 class template argument
6629 deduction. In this case we need to look through the binfo because a
6630 template doesn't have base fields. */
6633 }
6636 else
6640 {
6641 /* [dcl.init.aggr]
6643 An initializer for an aggregate member that is an
6644 empty class shall have the form of an empty
6645 initializer-list {}. */
6647 {
6651 }
6653 }
6655 /* For C++20 CTAD, handle pack expansions in the base list. */
6658 /* Loop through the initializable fields, gathering initializers. */
6660 {
6661 tree field_init;
6665 /* Handle C++20 designated initializers. */
6667 {
6672 {
6673 /* We already reshaped this; we should have returned early from
6674 reshape_init. */
6677 {
6682 }
6683 }
6685 {
6689 }
6690 else
6691 {
6696 }
6699 /* Apparently the designator isn't for a member of this anonymous
6700 struct, so head back to the enclosing class. */
6704 {
6709 }
6711 /* If the element is an anonymous union object and the initializer
6712 list is a designated-initializer-list, the anonymous union object
6713 is initialized by the designated-initializer-list { D }, where D
6714 is the designated-initializer-clause naming a member of the
6715 anonymous union object. */
6718 {
6719 /* Find the anon aggr that is a direct member of TYPE. */
6721 {
6726 }
6728 /* Not found, e.g. FIELD is a member of a base class. */
6733 found:
6734 /* Now find the TYPE member with that anon aggr type. */
6742 }
6743 }
6745 /* If we processed all the member of the class, we are done. */
6752 /* Each non-trailing aggregate element that is a pack expansion is
6753 assumed to correspond to no elements of the initializer list. */
6757 {
6758 /* The designated field F is initialized from this one element.
6760 Note that we don't want to do this if we found the designator
6761 inside an anon aggr above; we use the normal code to implement:
6763 "If the element is an anonymous union member and the initializer
6764 list is a brace-enclosed designated- initializer-list, the element
6765 is initialized by the designated-initializer-list { D }, where D
6766 is the designated- initializer-clause naming a member of the
6767 anonymous union member." */
6771 }
6772 else
6775 complain);
6781 {
6782 /* This can happen with an invalid initializer for a flexible
6783 array member (c++/54441). */
6787 }
6791 /* [dcl.init.aggr]
6793 When a union is initialized with a brace-enclosed
6794 initializer, the braces shall only contain an
6795 initializer for the first member of the union. */
6799 continue_:
6801 {
6804 else
6806 }
6807 else
6809 }
6811 /* A trailing aggregate element that is a pack expansion is assumed to
6812 correspond to all remaining elements of the initializer list (if any). */
6814 {
6819 }
6822 }
6824 /* Subroutine of reshape_init_r. We're in a context where C99 initializer
6825 designators are not valid; either complain or return true to indicate
6826 that reshape_init_r should return error_mark_node. */
6828 static bool
6830 {
6832 {
6837 else
6839 }
6841 }
6843 /* Subroutine of reshape_init, which processes a single initializer (part of
6844 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
6845 iterator within the CONSTRUCTOR which points to the initializer to process.
6846 If this is the first initializer of the outermost CONSTRUCTOR node,
6847 FIRST_INITIALIZER_P is that CONSTRUCTOR; otherwise, it is NULL_TREE. */
6849 static tree
6851 tsubst_flags_t complain)
6852 {
6865 {
6866 /* A complex type can be initialized from one or two initializers,
6867 but braces are not elided. */
6870 {
6872 {
6875 else
6877 }
6878 }
6880 {
6888 }
6890 }
6892 /* A non-aggregate type is always initialized with a single
6893 initializer. */
6895 /* As is an array with dependent bound, which we can see
6896 during C++20 aggregate CTAD. */
6900 {
6901 /* It is invalid to initialize a non-aggregate type with a
6902 brace-enclosed initializer before C++0x.
6903 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
6904 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
6905 a CONSTRUCTOR (with a record type). */
6907 /* Don't complain about a capture-init. */
6910 {
6912 {
6914 {
6917 type);
6919 }
6922 && (BRACE_ENCLOSED_INITIALIZER_P
6924 {
6929 }
6930 }
6931 else
6933 }
6937 }
6939 /* "If T is a class type and the initializer list has a single element of
6940 type cv U, where U is T or a class derived from T, the object is
6941 initialized from that element." Even if T is an aggregate. */
6943 && first_initializer_p
6944 /* But not if it's a designated init. */
6948 {
6951 }
6953 /* [dcl.init.aggr]
6955 All implicit type conversions (clause _conv_) are considered when
6956 initializing the aggregate member with an initializer from an
6957 initializer-list. If the initializer can initialize a member,
6958 the member is initialized. Otherwise, if the member is itself a
6959 non-empty subaggregate, brace elision is assumed and the
6960 initializer is considered for the initialization of the first
6961 member of the subaggregate. */
6963 /* But don't try this for the first initializer, since that would be
6964 looking through the outermost braces; A a2 = { a1 }; is not a
6965 valid aggregate initialization. */
6966 && !first_initializer_p
6969 complain)))
6970 {
6973 }
6975 /* [dcl.init.string]
6977 A char array (whether plain char, signed char, or unsigned char)
6978 can be initialized by a string-literal (optionally enclosed in
6979 braces); a wchar_t array can be initialized by a wide
6980 string-literal (optionally enclosed in braces). */
6983 {
6986 reshape_iter stripd = {};
6988 /* Strip one level of braces if and only if they enclose a single
6989 element (as allowed by [dcl.init.string]). */
6993 {
6997 }
6999 /* If it's a string literal, then it's the initializer for the array
7000 as a whole. Otherwise, continue with normal initialization for
7001 array types (one value per array element). */
7003 {
7009 }
7010 }
7012 /* The following cases are about aggregates. If we are not within a full
7013 initializer already, and there is not a CONSTRUCTOR, it means that there
7014 is a missing set of braces (that is, we are processing the case for
7015 which reshape_init exists). */
7018 {
7020 {
7023 /* There is no need to call reshape_init for pointer-to-member
7024 function initializers, as they are always constructed correctly
7025 by the front end. Here we have e.g. {.__pfn=0B, .__delta=0},
7026 which is missing outermost braces. We should warn below, and
7028 /* For a nested compound literal, proceed to specialized routines,
7029 to handle initialization of arrays and similar. */
7032 /* If we have an unresolved designator, we need to find the member it
7033 designates within TYPE, so proceed to the routines below. For
7034 FIELD_DECL or INTEGER_CST designators, we're already initializing
7035 the designated element. */
7038 /* Brace elision with designators is only permitted for anonymous
7039 aggregates. */
7041 /* A CONSTRUCTOR of the target's type is a previously
7042 digested initializer. */
7044 {
7047 }
7048 else
7049 {
7050 /* Something that hasn't been reshaped yet. */
7054 }
7055 }
7060 type);
7062 }
7064 /* Dispatch to specialized routines. */
7065 tree new_init;
7072 else
7080 }
7082 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
7083 brace-enclosed aggregate initializer.
7085 INIT is the CONSTRUCTOR containing the list of initializers describing
7086 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
7087 It may not presently match the shape of the TYPE; for example:
7089 struct S { int a; int b; };
7090 struct S a[] = { 1, 2, 3, 4 };
7092 Here INIT will hold a vector of four elements, rather than a
7093 vector of two elements, each itself a vector of two elements. This
7094 routine transforms INIT from the former form into the latter. The
7095 revised CONSTRUCTOR node is returned. */
7097 tree
7099 {
7101 reshape_iter d;
7102 tree new_init;
7108 /* An empty constructor does not need reshaping, and it is always a valid
7109 initializer. */
7114 /* Already reshaped. */
7117 /* Brace elision is not performed for a CONSTRUCTOR representing
7118 parenthesized aggregate initialization. */
7120 {
7122 /* If we're initializing a char array from a string-literal that is
7123 enclosed in braces, unwrap it here. */
7130 }
7132 /* Handle [dcl.init.list] direct-list-initialization from
7133 single element of enumeration with a fixed underlying type. */
7135 {
7139 {
7143 tf_warning_or_error);
7144 }
7145 else
7147 }
7149 /* Recurse on this CONSTRUCTOR. */
7157 /* Make sure all the element of the constructor were used. Otherwise,
7158 issue an error about exceeding initializers. */
7160 {
7164 }
7175 }
7177 /* Verify array initializer. Returns true if errors have been reported. */
7179 bool
7181 {
7184 /* Structured binding when initialized with an array type needs
7185 to have complete type. */
7190 {
7195 }
7197 /* The array type itself need not be complete, because the
7198 initializer may tell us how many elements are in the array.
7199 But, the elements of the array must be complete. */
7201 {
7205 else
7208 }
7214 /* A compound literal can't have variable size. */
7218 {
7221 }
7223 }
7225 /* Subroutine of check_initializer; args are passed down from that function.
7226 Set stmts_are_full_exprs_p to 1 across a call to build_aggr_init. */
7228 static tree
7230 {
7235 }
7237 /* Verify INIT (the initializer for DECL), and record the
7238 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
7239 grok_reference_init.
7241 If the return value is non-NULL, it is an expression that must be
7242 evaluated dynamically to initialize DECL. */
7244 static tree
7246 {
7247 tree type;
7249 tree core_type;
7251 /* Things that are going to be initialized need to have complete
7252 type. */
7256 {
7257 /* A variable with DECL_HAS_VALUE_EXPR_P set is just a placeholder,
7258 it doesn't have storage to be initialized. */
7261 }
7264 /* We will have already complained. */
7268 {
7271 }
7273 {
7278 }
7279 else
7280 /* There is no way to make a variable-sized class type in GNU C++. */
7284 {
7287 {
7289 {
7292 }
7294 {
7296 "scalar object %qD requires one element in "
7300 }
7301 }
7302 }
7305 {
7312 }
7314 ;
7317 {
7319 {
7322 }
7325 tf_warning_or_error);
7326 /* Do not reshape constructors of vectors (they don't need to be
7327 reshaped. */
7329 {
7331 {
7333 tf_warning_or_error);
7335 }
7337 {
7338 /* Don't reshape if the class has constructors. */
7341 "in C++98 %qD must be initialized by "
7343 decl);
7344 }
7346 {
7349 }
7350 else
7351 {
7354 }
7355 }
7356 /* [dcl.init] "Otherwise, if the destination type is an array, the object
7357 is initialized as follows..." So handle things like
7359 int a[](1, 2, 3);
7361 which is permitted in C++20 by P0960. */
7371 {
7374 /* We get here with code like `int a (2);' */
7376 tf_warning_or_error);
7377 }
7379 /* If DECL has an array type without a specific bound, deduce the
7380 array size from the initializer. */
7391 /* The call to build_aggr_init below could end up
7392 calling build_vec_init, which may break when we
7393 are processing a template. */
7394 || processing_template_decl
7398 {
7401 /* A constructor call is a non-trivial initializer even if
7402 it isn't explicitly written. */
7406 /* If this is a constexpr initializer, expand_default_init will
7407 have returned an INIT_EXPR rather than a CALL_EXPR. In that
7408 case, pull the initializer back out and pass it down into
7409 store_init_value. */
7411 {
7418 else
7420 }
7422 {
7423 /* In C++20, the call to build_aggr_init could have created
7424 an INIT_EXPR with a CONSTRUCTOR as the RHS to handle
7425 A(1, 2). */
7428 /* Avoid leaking TARGET_EXPR into template trees. */
7433 /* Don't call digest_init; it's unnecessary and will complain
7434 about aggregate initialization of non-aggregate classes. */
7436 }
7439 {
7440 /* Declared constexpr or constinit, but no suitable initializer;
7441 massage init appropriately so we can pass it into
7442 store_init_value for the error. */
7452 {
7457 }
7459 }
7460 else
7462 }
7465 {
7471 {
7476 }
7488 }
7489 }
7490 else
7491 {
7499 tf_warning_or_error);
7500 }
7510 {
7511 /* We might have set these in cp_finish_decl. */
7514 }
7519 {
7527 else
7531 {
7535 }
7537 }
7540 }
7542 /* If DECL is not a local variable, give it RTL. */
7544 static void
7546 {
7550 /* Set the DECL_ASSEMBLER_NAME for the object. */
7552 {
7553 /* The `register' keyword, when used together with an
7554 asm-specification, indicates that the variable should be
7555 placed in a particular register. */
7557 {
7560 }
7561 else
7562 {
7569 /* We have to propagate the name to the ns-alias.
7570 This is horrible, as we're affecting a
7571 possibly-shared decl. Again, a one-true-decl
7572 model breaks down. */
7575 }
7576 }
7578 /* Handle non-variables up front. */
7580 {
7583 }
7585 /* If we see a class member here, it should be a static data
7586 member. */
7588 {
7590 /* An in-class declaration of a static data member should be
7591 external; it is only a declaration, and not a definition. */
7595 }
7597 /* We don't create any RTL for local variables. */
7601 /* We defer emission of local statics until the corresponding
7602 DECL_EXPR is expanded. But with constexpr its function might never
7603 be expanded, so go ahead and tell cgraph about the variable now. */
7608 /* Defer template instantiations. */
7613 /* If we're not deferring, go ahead and assemble the variable. */
7616 }
7618 /* walk_tree helper for wrap_temporary_cleanups, below. */
7620 static tree
7622 {
7623 /* Stop at types or full-expression boundaries. */
7626 {
7629 }
7632 {
7638 {
7640 /* Tell honor_protect_cleanup_actions to handle this as a separate
7641 cleanup. */
7644 }
7645 }
7648 }
7650 /* We're initializing a local variable which has a cleanup GUARD. If there
7651 are any temporaries used in the initializer INIT of this variable, we
7652 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
7653 variable will be cleaned up properly if one of them throws.
7655 Unfortunately, there's no way to express this properly in terms of
7656 nesting, as the regions for the temporaries overlap the region for the
7657 variable itself; if there are two temporaries, the variable needs to be
7658 the first thing destroyed if either of them throws. However, we only
7659 want to run the variable's cleanup if it actually got constructed. So
7660 we need to guard the temporary cleanups with the variable's cleanup if
7661 they are run on the normal path, but not if they are run on the
7662 exceptional path. We implement this by telling
7663 honor_protect_cleanup_actions to strip the variable cleanup from the
7664 exceptional path.
7666 Another approach could be to make the variable cleanup region enclose
7667 initialization, but depend on a flag to indicate that the variable is
7668 initialized; that's effectively what we do for arrays. But the current
7669 approach works fine for non-arrays, and has no code overhead in the usual
7670 case where the temporary destructors are noexcept. */
7672 static void
7674 {
7676 {
7677 /* An array cleanup region already encloses any temporary cleanups,
7678 don't wrap it around them again. */
7681 }
7683 }
7685 /* Generate code to initialize DECL (a local variable). */
7687 static void
7689 {
7691 tree cleanup;
7699 {
7700 /* If we used it already as memory, it must stay in memory. */
7704 }
7709 /* Compute and store the initial value. */
7714 /* Generate a cleanup, if necessary. */
7717 /* Perform the initialization. */
7719 {
7724 {
7725 /* Stick simple initializers in DECL_INITIAL so that
7726 -Wno-init-self works (c++/34772). */
7730 {
7734 OPT_Winit_self,
7736 }
7737 }
7738 else
7739 {
7742 /* If we're only initializing a single object, guard the
7743 destructors of any temporaries used in its initializer with
7744 its destructor. */
7753 saved_stmts_are_full_exprs_p;
7754 }
7755 }
7757 /* Set this to 0 so we can tell whether an aggregate which was
7758 initialized was ever used. Don't do this if it has a
7759 destructor, so we don't complain about the 'resource
7760 allocation is initialization' idiom. Now set
7761 attribute((unused)) on types so decls of that type will be
7762 marked used. (see TREE_USED, above.) */
7764 && ! already_used
7773 }
7775 /* DECL is a VAR_DECL for a compiler-generated variable with static
7776 storage duration (like a virtual table) whose initializer is a
7777 compile-time constant. Initialize the variable and provide it to the
7778 back end. */
7780 void
7782 {
7783 tree init;
7789 /* Mark the decl as constexpr so that we can access its content
7790 at compile time. */
7797 }
7799 /* INIT is the initializer for a variable, as represented by the
7800 parser. Returns true iff INIT is value-dependent. */
7802 static bool
7804 {
7806 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
7809 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
7810 {
7823 }
7824 else
7825 /* It must be a simple expression, e.g., int i = 3; */
7829 }
7831 // Returns true if a DECL is VAR_DECL with the concept specifier.
7834 {
7836 // Not all variables have DECL_LANG_SPECIFIC.
7839 }
7841 /* A helper function to be called via walk_tree. If any label exists
7842 under *TP, it is (going to be) forced. Set has_forced_label_in_static. */
7844 static tree
7846 {
7852 }
7854 /* Return true if DECL has either a trivial destructor, or for C++20
7855 is constexpr and has a constexpr destructor. */
7857 static bool
7859 {
7865 }
7869 /* Helper function of omp_declare_variant_finalize. Finalize one
7870 "omp declare variant base" attribute. Return true if it should be
7871 removed. */
7873 static bool
7875 {
7877 {
7882 }
7887 {
7891 /* FIXME, adjusting simd args unimplemented. */
7893 }
7896 location_t varid_loc
7905 releasing_vec args;
7914 else
7919 {
7921 /* In C++20, we may need to perform ADL for a template
7922 name. */
7925 {
7927 {
7931 tf_warning_or_error);
7932 }
7933 else
7935 }
7937 {
7943 {
7947 tf_warning_or_error);
7948 }
7949 }
7950 }
7955 else
7965 {
7968 {
7972 }
7977 {
7980 }
7981 else
7982 {
7988 }
7989 }
7991 {
7994 }
7997 }
7999 /* Helper function, finish up "omp declare variant base" attribute
8000 now that there is a DECL. ATTR is the first "omp declare variant base"
8001 attribute. */
8003 void
8005 {
8015 {
8018 }
8020 {
8023 }
8025 {
8028 }
8030 {
8033 }
8035 {
8038 }
8039 /* This loop is like private_lookup_attribute, except that it works
8040 with tree * rather than tree, as we might want to remove the
8041 attributes that are diagnosed as errorneous. */
8043 {
8048 {
8050 {
8053 }
8054 }
8056 }
8057 }
8059 /* Finish processing of a declaration;
8060 install its line number and initial value.
8061 If the length of an array type is not known before,
8062 it must be determined now, from the initial value, or it is an error.
8064 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
8065 true, then INIT is an integral constant expression.
8067 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
8068 if the (init) syntax was used. */
8070 void
8073 {
8074 tree type;
8079 tree auto_node;
8084 {
8088 }
8091 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
8101 /* Warn about register storage specifiers except when in GNU global
8102 or local register variable extension. */
8104 {
8107 "ISO C++17 does not allow %<register%> storage "
8109 else
8112 }
8114 /* If a name was specified, get the string. */
8120 bool in_class_decl
8121 = (current_class_type
8132 {
8133 tree d_init;
8135 {
8139 {
8140 /* init is null because we're deferring instantiating the
8141 initializer until we need it. Well, we need it now. */
8144 }
8147 }
8150 {
8154 tf_warning_or_error);
8156 /* Force auto deduction now. Use tf_none to avoid redundant warnings
8157 on deprecated-14.C. */
8159 }
8168 /* The outer template arguments might be needed for satisfaction.
8169 (For function scope variables, do_auto_deduction will obtain the
8170 outer template arguments from current_function_decl.) */
8178 {
8183 }
8184 /* As in start_decl_1, complete so TREE_READONLY is set properly. */
8188 {
8194 }
8197 /* Update the type of the corresponding TEMPLATE_DECL to match. */
8202 }
8205 {
8208 {
8211 }
8212 }
8222 {
8224 ? TCTX_THREAD_STORAGE
8227 }
8230 {
8231 tree clone;
8233 {
8234 /* FIXME check this is 1st decl. */
8239 {
8243 }
8245 }
8247 {
8250 else
8252 }
8253 }
8256 {
8258 /* If DECL is a reference, then we want to know whether init is a
8259 reference constant; init_const_expr_p as passed tells us whether
8260 it's an rvalue constant. */
8264 {
8265 /* Set these flags now for templates. We'll update the flags in
8266 store_init_value for instantiations. */
8269 /* FIXME setting TREE_CONSTANT on refs breaks the back end. */
8272 }
8273 /* This is handled mostly by gimplify.cc, but we have to deal with
8274 not warning about int x = x; as it is a GCC extension to turn off
8275 this warning but only if warn_init_self is zero. */
8281 }
8285 /* #pragma omp declare variant on methods handled in finish_struct
8286 instead. */
8294 {
8297 /* Add this declaration to the statement-tree. */
8304 {
8307 }
8309 /* Generally, initializers in templates are expanded when the
8310 template is instantiated. But, if DECL is a variable constant
8311 then it can be used in future constant expressions, so its value
8312 must be available. */
8319 {
8322 }
8328 {
8329 /* This variable seems to be a non-dependent constant, so process
8330 its initializer. If check_initializer returns non-null the
8331 initialization wasn't constant after all. */
8332 tree init_code;
8338 }
8339 else
8340 {
8342 /* Try to deduce array size. */
8344 /* And complain about multiple initializers. */
8348 tf_warning_or_error);
8349 }
8355 {
8358 }
8361 {
8364 }
8366 }
8368 /* Just store non-static data member initializers for later. */
8372 /* Take care of TYPE_DECLs up front. */
8374 {
8377 {
8381 }
8383 /* If we have installed this as the canonical typedef for this
8384 type, and that type has not been defined yet, delay emitting
8385 the debug information for it, as we will emit it later. */
8391 at_eof);
8393 }
8395 /* A reference will be modified here, as it is initialized. */
8399 {
8402 }
8404 /* This needs to happen before extend_ref_init_temps. */
8406 {
8410 }
8413 {
8415 /* [dcl.constinit]/1 "The constinit specifier shall be applied
8416 only to a declaration of a variable with static or thread storage
8417 duration." */
8420 {
8422 "%<constinit%> can only be applied to a variable with "
8425 }
8427 /* If this is a local variable that will need a mangled name,
8428 register it now. We must do this before processing the
8429 initializer for the variable, since the initialization might
8430 require a guard variable, and since the mangled name of the
8431 guard variable will depend on the mangled name of this
8432 variable. */
8436 {
8437 /* The variable holding an anonymous union will have had its
8438 discriminator set in finish_anon_union, after which it's
8439 NAME will have been cleared. */
8442 /* Normally has_forced_label_in_static is set during GIMPLE
8443 lowering, but [cd]tors are never actually compiled directly.
8444 We need to set this early so we can deal with the label
8445 address extension. */
8449 {
8452 }
8453 /* And make sure it's in the symbol table for
8454 c_parse_final_cleanups to find. */
8456 }
8458 /* Convert the initializer to the type of DECL, if we have not
8459 already initialized DECL. */
8461 /* If !DECL_EXTERNAL then DECL is being defined. In the
8462 case of a static data member initialized inside the
8463 class-specifier, there can be an initializer even if DECL
8464 is *not* defined. */
8466 {
8470 /* Handle:
8472 [dcl.init]
8474 The memory occupied by any object of static storage
8475 duration is zero-initialized at program startup before
8476 any other initialization takes place.
8478 We cannot create an appropriate initializer until after
8479 the type of DECL is finalized. If DECL_INITIAL is set,
8480 then the DECL is statically initialized, and any
8481 necessary zero-initialization has already been performed. */
8486 /* Remember that the initialization for this variable has
8487 taken place. */
8489 /* This declaration is the definition of this variable,
8490 unless we are initializing a static data member within
8491 the class specifier. */
8494 }
8495 /* If the variable has an array type, lay out the type, even if
8496 there is no initializer. It is valid to index through the
8497 array, and we must get TYPE_ALIGN set correctly on the array
8498 type. */
8505 /* So decl is a global variable or a static member of a
8506 non local class. Record the types it uses
8507 so that we can decide later to emit debug info for them. */
8509 }
8511 /* Add this declaration to the statement-tree. This needs to happen
8512 after the call to check_initializer so that the DECL_EXPR for a
8513 reference temp is added before the DECL_EXPR for the reference itself. */
8515 {
8516 /* If we're building a variable sized type, and we might be
8517 reachable other than via the top of the current binding
8518 level, then create a new BIND_EXPR so that we deallocate
8519 the object at the right time. */
8524 {
8525 tree bind;
8530 }
8532 }
8534 /* Let the middle end know about variables and functions -- but not
8535 static data members in uninstantiated class templates. */
8537 {
8539 {
8542 /* Check again now that we have an initializer. */
8544 /* A class-scope constexpr variable with an out-of-class declaration.
8545 C++17 makes them implicitly inline, but still force it out. */
8551 }
8554 /* With -fmerge-all-constants, gimplify_init_constructor
8555 might add TREE_STATIC to the variable. */
8557 {
8558 /* If a TREE_READONLY variable needs initialization
8559 at runtime, it is no longer readonly and we need to
8560 avoid MEM_READONLY_P being set on RTL created for it. */
8562 {
8566 }
8570 /* Likewise if it needs destruction. */
8573 }
8577 /* Check for abstractness of the type. */
8582 /* No initialization required. */
8583 ;
8585 {
8587 {
8589 {
8590 /* An out-of-class default definition is defined at
8591 the point where it is explicitly defaulted. */
8596 }
8597 else
8601 decl);
8602 }
8603 /* else no initialization required. */
8604 }
8608 {
8609 /* check_initializer will have done any constant initialization. */
8610 }
8611 /* A variable definition. */
8613 /* Initialize the local variable. */
8616 /* If a variable is defined, and then a subsequent
8617 definition with external linkage is encountered, we will
8618 get here twice for the same variable. We want to avoid
8619 calling expand_static_init more than once. For variables
8620 that are not static data members, we can call
8621 expand_static_init only when we actually process the
8622 initializer. It is not legal to redeclare a static data
8623 member, so this issue does not arise in that case. */
8626 }
8628 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
8629 reference, insert it in the statement-tree now. */
8631 {
8633 {
8635 /* As in initialize_local_var. */
8637 }
8639 }
8648 {
8654 {
8660 }
8665 {
8671 {
8674 {
8678 }
8679 }
8680 }
8681 }
8683 /* This is the last point we can lower alignment so give the target the
8684 chance to do so. */
8691 }
8693 /* For class TYPE return itself or some its bases that contain
8694 any direct non-static data members. Return error_mark_node if an
8695 error has been diagnosed. */
8697 static tree
8699 {
8709 {
8713 else
8718 }
8720 {
8728 }
8729 else
8739 {
8744 {
8746 {
8751 }
8755 {
8757 "classes %qT and %qT have non-static data "
8760 }
8761 else
8763 }
8764 }
8766 }
8768 /* Return std::tuple_size<TYPE>::value. */
8770 static tree
8772 {
8788 else
8790 }
8792 /* Return std::tuple_element<I,TYPE>::type. */
8794 static tree
8796 {
8804 tf_warning_or_error);
8807 }
8809 /* Return e.get<i>() or get<i>(e). */
8811 static tree
8813 {
8820 /* [The id-expression] e is an lvalue if the type of the entity e is an
8821 lvalue reference and an xvalue otherwise. */
8830 /* To use a member get, member lookup must find at least one
8831 declaration that is a function template
8832 whose first template parameter is a non-type parameter. */
8834 {
8837 {
8841 {
8844 }
8845 }
8846 }
8849 {
8854 }
8855 else
8856 {
8862 }
8863 }
8865 /* It's impossible to recover the decltype of a tuple decomposition variable
8866 based on the actual type of the variable, so store it in a hash table. */
8870 tree
8872 {
8874 }
8876 /* Mangle a decomposition declaration if needed. Arguments like
8877 in cp_finish_decomp. */
8879 void
8881 {
8885 {
8893 }
8894 }
8896 /* Finish a decomposition declaration. DECL is the underlying declaration
8897 "e", FIRST is the head of a chain of decls for the individual identifiers
8898 chained through DECL_CHAIN in reverse order and COUNT is the number of
8899 those decls. */
8901 void
8903 {
8905 {
8906 error_out:
8908 {
8911 {
8914 }
8916 }
8920 }
8924 /* This happens for range for when not in templates.
8925 Still add the DECL_VALUE_EXPRs for later processing. */
8926 || (!processing_template_decl
8928 {
8930 {
8932 {
8938 }
8942 }
8944 }
8950 {
8953 }
8959 {
8965 {
8967 type);
8969 }
8970 }
8975 {
8976 tree nelts;
8981 {
8984 }
8987 {
8988 cnt_mismatch:
8993 else
9002 }
9005 {
9013 NULL_TREE);
9016 }
9017 }
9018 /* 2 GNU extensions. */
9020 {
9026 {
9034 t);
9037 }
9038 }
9040 {
9042 {
9045 }
9050 {
9060 NULL_TREE);
9063 }
9064 }
9066 {
9068 {
9072 }
9074 {
9081 }
9087 {
9098 {
9102 }
9104 {
9108 }
9109 /* Save the decltype away before reference collapse. */
9115 {
9116 /* In this case the names are variables, not just proxies. */
9119 }
9121 {
9125 }
9126 }
9127 /* Ignore reads from the underlying decl performed during initialization
9128 of the individual variables. If those will be read, we'll mark
9129 the underlying decl as read at that point. */
9131 }
9133 {
9136 }
9138 {
9141 }
9143 {
9146 }
9151 type);
9152 else
9153 {
9158 {
9162 }
9168 else
9169 eltscnt++;
9174 {
9178 }
9185 else
9186 {
9188 NULL_TREE);
9194 {
9197 }
9198 i++;
9199 }
9200 }
9202 {
9205 {
9210 }
9211 }
9212 }
9214 /* Returns a declaration for a VAR_DECL as if:
9216 extern "C" TYPE NAME;
9218 had been seen. Used to create compiler-generated global
9219 variables. */
9221 static tree
9223 {
9230 /* If the user has explicitly declared this variable (perhaps
9231 because the code we are compiling is part of a low-level runtime
9232 library), then it is possible that our declaration will be merged
9233 with theirs by pushdecl. */
9239 }
9241 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
9242 if "__cxa_atexit" is not being used) corresponding to the function
9243 to be called when the program exits. */
9245 static tree
9247 {
9248 tree fn_type;
9251 {
9252 tree arg_type;
9255 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
9257 else
9258 /* The parameter to "atexit" is "void (*)(void)". */
9264 }
9267 }
9269 /* Returns a pointer to the `atexit' function. Note that if
9270 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
9271 `__cxa_atexit' function specified in the IA64 C++ ABI. */
9273 static tree
9275 {
9276 tree atexit_fndecl;
9277 tree fn_type;
9278 tree fn_ptr_type;
9287 {
9288 /* The declaration for `__cxa_atexit' is:
9290 int __cxa_atexit (void (*)(void *), void *, void *)
9292 We build up the argument types and then the function type
9293 itself. */
9297 /* First, build the pointer-to-function type for the first
9298 argument. */
9300 /* Then, build the rest of the argument types. */
9303 {
9306 }
9307 else
9308 {
9311 }
9312 /* And the final __cxa_atexit type. */
9315 NULL_TREE);
9316 /* ... which needs noexcept. */
9319 {
9327 }
9328 else
9329 {
9332 }
9333 }
9334 else
9335 {
9336 /* The declaration for `atexit' is:
9338 int atexit (void (*)());
9340 We build up the argument types and then the function type
9341 itself. */
9343 /* Build the final atexit type. */
9346 /* ... which needs noexcept. */
9349 }
9351 /* Now, build the function declaration. */
9356 /* Install as hidden builtin so we're (a) more relaxed about
9357 exception spec matching and (b) will not give a confusing location
9358 in diagnostic and (c) won't magically appear in user-visible name
9359 lookups. */
9368 }
9370 /* Like get_atexit_node, but for thread-local cleanups. */
9372 static tree
9374 {
9375 /* The declaration for `__cxa_thread_atexit' is:
9377 int __cxa_thread_atexit (void (*)(void *), void *, void *) */
9381 NULL_TREE);
9383 /* Now, build the function declaration. */
9387 }
9389 /* Returns the __dso_handle VAR_DECL. */
9391 static tree
9393 {
9397 /* Declare the variable. */
9399 ptr_type_node);
9401 #ifdef HAVE_GAS_HIDDEN
9403 {
9406 }
9407 #endif
9410 }
9412 /* Begin a new function with internal linkage whose job will be simply
9413 to destroy some particular variable. */
9417 static tree
9419 {
9424 /* No need to mangle this. */
9427 /* Build the name of the function. */
9429 /* Build the function declaration. */
9433 /* It's a function with internal linkage, generated by the
9434 compiler. */
9437 /* Make the function `inline' so that it is only emitted if it is
9438 actually needed. It is unlikely that it will be inlined, since
9439 it is only called via a function pointer, but we avoid unnecessary
9440 emissions this way. */
9444 {
9445 /* Build the parameter. */
9450 }
9458 }
9460 /* Finish the cleanup function begun by start_cleanup_fn. */
9462 static void
9464 {
9468 }
9470 /* Generate code to handle the destruction of DECL, an object with
9471 static storage duration. */
9473 tree
9475 {
9476 tree cleanup;
9477 tree addr;
9478 tree compound_stmt;
9479 tree fcall;
9480 tree type;
9483 tree atex_node;
9491 {
9494 }
9496 /* If we're using "__cxa_atexit" (or "__cxa_thread_atexit" or
9497 "__aeabi_atexit"), and DECL is a class object, we can just pass the
9498 destructor to "__cxa_atexit"; we don't have to build a temporary
9499 function to do the cleanup. */
9500 dso_parm = (flag_use_cxa_atexit
9505 {
9508 /* Make sure it is accessible. */
9510 tf_warning_or_error);
9511 }
9512 else
9513 {
9514 /* Call build_cleanup before we enter the anonymous function so
9515 that any access checks will be done relative to the current
9516 scope, rather than the scope of the anonymous function. */
9519 /* Now start the function. */
9522 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
9523 to the original function, rather than the anonymous one. That
9524 will make the back end think that nested functions are in use,
9525 which causes confusion. */
9530 /* Create the body of the anonymous function. */
9535 }
9537 /* Call atexit with the cleanup function. */
9543 else
9547 {
9548 /* We must convert CLEANUP to the type that "__cxa_atexit"
9549 expects. */
9551 /* "__cxa_atexit" will pass the address of DECL to the
9552 cleanup function. */
9555 /* The declared type of the parameter to "__cxa_atexit" is
9556 "void *". For plain "T*", we could just let the
9557 machinery in cp_build_function_call convert it -- but if the
9558 type is "cv-qualified T *", then we need to convert it
9559 before passing it in, to avoid spurious errors. */
9561 }
9562 else
9563 /* Since the cleanup functions we build ignore the address
9564 they're given, there's no reason to pass the actual address
9565 in, and, in general, it's cheaper to pass NULL than any
9566 other value. */
9571 tf_warning_or_error);
9573 /* Just pass NULL to the dso handle parm if we don't actually
9574 have a DSO handle on this target. */
9576 else
9580 {
9583 {
9586 }
9587 else
9588 {
9591 }
9592 }
9593 else
9594 {
9597 }
9600 }
9602 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
9603 is its initializer. Generate code to handle the construction
9604 and destruction of DECL. */
9606 static void
9608 {
9612 /* Some variables require no dynamic initialization. */
9614 {
9615 /* Make sure the destructor is callable. */
9619 }
9623 {
9628 else
9633 {
9637 }
9639 }
9642 {
9643 /* Emit code to perform this initialization but once. */
9648 /* We don't need thread-safety code for thread-local vars. */
9652 /* Emit code to perform this initialization but once. This code
9653 looks like:
9655 static <type> guard;
9656 if (!__atomic_load (guard.first_byte)) {
9657 if (__cxa_guard_acquire (&guard)) {
9658 bool flag = false;
9659 try {
9660 // Do initialization.
9661 flag = true; __cxa_guard_release (&guard);
9662 // Register variable for destruction at end of program.
9663 } catch {
9664 if (!flag) __cxa_guard_abort (&guard);
9665 }
9666 }
9667 }
9669 Note that the `flag' variable is only set to 1 *after* the
9670 initialization is complete. This ensures that an exception,
9671 thrown during the construction, will cause the variable to
9672 reinitialized when we pass through this code again, as per:
9674 [stmt.dcl]
9676 If the initialization exits by throwing an exception, the
9677 initialization is not complete, so it will be tried again
9678 the next time control enters the declaration.
9680 This process should be thread-safe, too; multiple threads
9681 should not be able to initialize the variable more than
9682 once. */
9684 /* Create the guard variable. */
9687 /* Begin the conditional initialization. */
9694 {
9707 acquire_fn = push_library_fn
9710 NULL_TREE),
9715 NULL_TREE);
9718 ECF_NOTHROW);
9725 inner_if_stmt);
9733 void_node,
9737 /* Do the initialization itself. */
9743 /* Use atexit to register a function for destroying this static
9744 variable. Do this before calling __cxa_guard_release. */
9748 guard_addr));
9749 }
9750 else
9751 {
9754 /* Use atexit to register a function for destroying this static
9755 variable. */
9757 }
9762 {
9766 }
9771 }
9774 else
9776 }
9778 \f
9779 /* Make TYPE a complete type based on INITIAL_VALUE.
9780 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
9781 2 if there was no information (in which case assume 0 if DO_DEFAULT),
9782 3 if the initializer list is empty (in pedantic mode). */
9784 int
9786 {
9790 /* Don't get confused by a CONSTRUCTOR for some other type. */
9797 {
9798 /* An array of character type can be initialized from a
9799 brace-enclosed string constant so call reshape_init to
9800 remove the optional braces from a braced string literal. */
9804 tf_warning_or_error);
9806 /* If any of the elements are parameter packs, we can't actually
9807 complete this type now because the array size is dependent. */
9812 }
9816 /* We can create the array before the element type is complete, which
9817 means that we didn't have these two bits set in the original type
9818 either. In completing the type, we are expected to propagate these
9819 bits. See also complete_type which does the same thing for arrays
9820 of fixed size. */
9823 {
9828 }
9831 }
9833 /* As above, but either give an error or reject zero-size arrays, depending
9834 on COMPLAIN. */
9836 int
9839 {
9842 /* In SFINAE context we can't be lenient about zero-size arrays. */
9849 {
9855 {
9858 }
9862 }
9864 }
9865 \f
9866 /* Return zero if something is declared to be a member of type
9867 CTYPE when in the context of CUR_TYPE. STRING is the error
9868 message to print in that case. Otherwise, quietly return 1. */
9870 static int
9872 {
9874 {
9877 else
9880 }
9882 }
9883 \f
9884 /* Subroutine of `grokdeclarator'. */
9886 /* Generate errors possibly applicable for a given set of specifiers.
9887 This is for ARM $7.1.2. */
9889 static void
9898 {
9900 {
9944 }
9948 && !flag_noexcept_type
9954 }
9956 /* DECL is a member function or static data member and is presently
9957 being defined. Check that the definition is taking place in a
9958 valid namespace. */
9960 static void
9962 {
9963 /* These checks only apply to member functions and static data
9964 members. */
9966 /* We check for problems with specializations in pt.cc in
9967 check_specialization_namespace, where we can issue better
9968 diagnostics. */
9971 /* We check this in check_explicit_instantiation_namespace. */
9974 /* [class.mfct]
9976 A member function definition that appears outside of the
9977 class definition shall appear in a namespace scope enclosing
9978 the class definition.
9980 [class.static.data]
9982 The definition for a static data member shall appear in a
9983 namespace scope enclosing the member's class definition. */
9987 }
9989 /* Build a PARM_DECL for the "this" parameter of FN. TYPE is the
9990 METHOD_TYPE for a non-static member function; QUALS are the
9991 cv-qualifiers that apply to the function. */
9993 tree
9995 {
9996 tree this_type;
9997 tree qual_type;
9998 tree parm;
9999 cp_cv_quals this_quals;
10002 {
10003 this_type
10006 }
10007 else
10009 /* The `this' parameter is implicitly `const'; it cannot be
10010 assigned to. */
10016 }
10018 /* DECL is a static member function. Complain if it was declared
10019 with function-cv-quals. */
10021 static void
10023 {
10026 decl);
10027 }
10029 // Check that FN takes no arguments and returns bool.
10030 static void
10032 {
10033 // A constraint is nullary.
10038 // The declared return type of the concept shall be bool, and
10039 // it shall not be deduced from it definition.
10047 }
10049 /* Helper function. Replace the temporary this parameter injected
10050 during cp_finish_omp_declare_simd with the real this parameter. */
10052 static tree
10054 {
10063 }
10065 /* CTYPE is class type, or null if non-class.
10066 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
10067 or METHOD_TYPE.
10068 DECLARATOR is the function's name.
10069 PARMS is a chain of PARM_DECLs for the function.
10070 VIRTUALP is truthvalue of whether the function is virtual or not.
10071 FLAGS are to be passed through to `grokclassfn'.
10072 QUALS are qualifiers indicating whether the function is `const'
10073 or `volatile'.
10074 RAISES is a list of exceptions that this function can raise.
10075 CHECK is 1 if we must find this method in CTYPE, 0 if we should
10076 not look, and -1 if we should not call `grokclassfn' at all.
10078 SFK is the kind of special function (if any) for the new function.
10080 Returns `NULL_TREE' if something goes wrong, after issuing
10081 applicable error messages. */
10083 static tree
10085 tree type,
10086 tree declarator,
10087 tree parms,
10088 tree orig_declarator,
10090 tree decl_reqs,
10093 cp_cv_quals quals,
10094 cp_ref_qualifier rqual,
10095 tree raises,
10101 special_function_kind sfk,
10105 tree in_namespace,
10107 location_t location)
10108 {
10109 tree decl;
10111 tree t;
10116 /* Was the concept specifier present? */
10119 /* Concept declarations must have a corresponding definition. */
10121 {
10124 }
10130 /* Set the constraints on the declaration. */
10132 {
10137 && (current_template_depth
10140 {
10142 /* If there are no template parameters, something must have
10143 gone wrong. */
10145 else
10147 }
10150 {
10153 }
10154 /* C++20 CA378: Remove non-templated constrained functions. */
10156 && (block_local
10157 || (!flag_concepts_ts
10158 && (!processing_template_decl
10160 {
10163 }
10165 }
10168 {
10173 /* Allocate space to hold the vptr bit if needed. */
10175 }
10181 /* Propagate volatile out from type to decl. */
10185 /* Setup decl according to sfk. */
10187 {
10200 }
10203 {
10207 orig_declarator);
10208 else
10209 {
10214 {
10215 /* Something like `template <class T> friend void f<T>()'. */
10217 "invalid use of template-id %qD in declaration "
10219 orig_declarator);
10221 }
10224 /* A friend declaration of the form friend void f<>(). Record
10225 the information in the TEMPLATE_ID_EXPR. */
10234 {
10236 "default arguments are not allowed in declaration "
10238 decl);
10240 }
10243 {
10245 "%<inline%> is not allowed in declaration of friend "
10247 decl);
10249 }
10250 }
10251 }
10253 /* C++17 11.3.6/4: "If a friend declaration specifies a default argument
10254 expression, that declaration shall be a definition..." */
10256 {
10260 {
10262 "friend declaration of %qD specifies default "
10265 }
10266 }
10268 /* If this decl has namespace scope, set that up. */
10273 else
10276 /* `main' and builtins have implicit 'C' linkage. */
10291 /* Should probably propagate const out from type to decl I bet (mrs). */
10293 {
10296 }
10305 {
10321 }
10323 /* Members of anonymous types and local classes have no linkage; make
10324 them internal. If a typedef is made later, this will be changed. */
10330 {
10331 /* [basic.link]: A name with no linkage (notably, the name of a class
10332 or enumeration declared in a local scope) shall not be used to
10333 declare an entity with linkage.
10335 DR 757 relaxes this restriction for C++0x. */
10337 }
10341 {
10344 }
10346 /* If the declaration was declared inline, mark it as such. */
10348 {
10352 }
10356 {
10359 }
10361 // If the concept declaration specifier was found, check
10362 // that the declaration satisfies the necessary requirements.
10364 {
10367 }
10371 {
10374 TYPE_UNQUALIFIED,
10375 REF_QUAL_NONE);
10378 {
10382 decl);
10384 }
10387 {
10391 decl);
10393 }
10394 }
10397 {
10401 {
10406 }
10409 {
10413 }
10417 }
10422 {
10426 /* [over.literal]/6: Literal operators shall not have C linkage. */
10428 {
10432 }
10435 {
10438 {
10441 }
10445 {
10449 }
10451 {
10455 }
10456 /* 17.6.3.3.5 */
10460 "literal operator suffixes not preceded by %<_%>"
10462 }
10463 else
10464 {
10467 }
10468 }
10471 /* Make the init_value nonzero so pushdecl knows this is not
10472 tentative. error_mark_node is replaced later with the BLOCK. */
10479 {
10480 /* Adjust "omp declare simd" attributes. */
10483 {
10484 tree attr;
10487 {
10492 {
10494 cl = c_omp_declare_simd_clauses_to_numbers
10498 else
10500 }
10501 }
10502 }
10503 }
10505 /* Caller will do the rest of this. */
10512 /* 12.4/3 */
10522 template_count,
10534 {
10537 }
10539 /* Check main's type after attributes have been applied. */
10541 {
10543 integer_type_node))
10544 {
10546 tree newtype;
10551 }
10554 }
10557 {
10559 (current_template_depth
10561 ? current_template_parms
10568 {
10569 tree ok;
10570 tree pushed_scope;
10573 /* Because grokfndecl is always supposed to return a
10574 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
10575 here. We depend on our callers to figure out that its
10576 really a template that's being returned. */
10581 {
10582 /* Remove the `this' parm added by grokclassfn. */
10585 }
10587 {
10590 }
10592 {
10597 }
10599 /* Since we've smashed OLD_DECL to its
10600 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
10604 /* Attempt to merge the declarations. This can fail, in
10605 the case of some invalid specialization declarations. */
10611 {
10615 }
10619 }
10620 }
10632 }
10634 /* decl is a FUNCTION_DECL.
10635 specifiers are the parsed virt-specifiers.
10637 Set flags to reflect the virt-specifiers.
10639 Returns decl. */
10641 static tree
10643 {
10651 }
10653 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
10654 the linkage that DECL will receive in the object file. */
10656 static void
10658 {
10659 /* A static data member always has static storage duration and
10660 external linkage. Note that static data members are forbidden in
10661 local classes -- the only situation in which a class has
10662 non-external linkage. */
10665 /* For non-template classes, static data members are always put
10666 out in exactly those files where they are defined, just as
10667 with ordinary namespace-scope variables. */
10670 }
10672 /* Create a VAR_DECL named NAME with the indicated TYPE.
10674 If SCOPE is non-NULL, it is the class type or namespace containing
10675 the variable. If SCOPE is NULL, the variable should is created in
10676 the innermost enclosing scope. */
10678 static tree
10680 tree name,
10681 tree orig_declarator,
10688 tree scope,
10689 location_t location)
10690 {
10691 tree decl;
10692 tree explicit_scope;
10699 /* Compute the scope in which to place the variable, but remember
10700 whether or not that scope was explicitly specified by the user. */
10703 {
10704 /* An explicit "extern" specifier indicates a namespace-scope
10705 variable. */
10710 }
10714 template, we need DECL_LANG_SPECIFIC. */
10716 /* Similarly for namespace-scope variables with language linkage
10717 other than C++. */
10720 /* Similarly for static data members. */
10722 /* Similarly for explicit specializations. */
10723 || (orig_declarator
10726 else
10731 else
10735 {
10738 }
10741 {
10743 /* This function is only called with out-of-class definitions. */
10746 }
10747 /* At top level, either `static' or no s.c. makes a definition
10748 (perhaps tentative), and absence of `static' makes it public. */
10750 {
10753 || ! constp
10754 || volatilep
10757 }
10758 /* Not at top level, only `static' makes a static definition. */
10759 else
10760 {
10763 }
10768 {
10770 {
10774 }
10777 }
10779 /* If the type of the decl has no linkage, make sure that we'll
10780 notice that in mark_used. */
10789 {
10790 /* [basic.link]: A name with no linkage (notably, the name of a class
10791 or enumeration declared in a local scope) shall not be used to
10792 declare an entity with linkage.
10794 DR 757 relaxes this restriction for C++0x. */
10797 }
10798 else
10807 /* Check that the variable can be safely declared as a concept.
10808 Note that this also forbids explicit specializations. */
10810 {
10812 {
10816 }
10818 {
10822 }
10823 else
10829 {
10832 }
10833 }
10836 {
10839 }
10841 // Handle explicit specializations and instantiations of variable templates.
10847 }
10849 /* Create and return a canonical pointer to member function type, for
10850 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
10852 tree
10854 {
10856 tree t;
10861 /* Make sure that we always have the unqualified pointer-to-member
10862 type first. */
10864 {
10867 }
10869 /* If a canonical type already exists for this type, use it. We use
10870 this method instead of type_hash_canon, because it only does a
10871 simple equality check on the list of field members. */
10879 /* Let the front end know this is a pointer to member function. */
10887 delta_type_node);
10894 /* Zap out the name so that the back end will give us the debugging
10895 information for this anonymous RECORD_TYPE. */
10898 /* Cache this pointer-to-member type so that we can find it again
10899 later. */
10908 }
10910 /* Create and return a pointer to data member type. */
10912 tree
10914 {
10916 {
10921 }
10922 else
10923 {
10926 }
10927 }
10929 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
10930 Check to see that the definition is valid. Issue appropriate error
10931 messages. */
10933 static void
10935 {
10936 /* Avoid redundant diagnostics on out-of-class definitions. */
10938 ;
10939 /* Can't check yet if we don't know the type. */
10941 ;
10942 /* If DECL is declared constexpr, we'll do the appropriate checks
10943 in check_initializer. Similarly for inline static data members. */
10947 ;
10949 {
10952 "in-class initialization of static data member %q#D of "
10956 "%<constexpr%> needed for in-class initialization of "
10958 else
10960 "in-class initialization of static data member %q#D of "
10962 }
10963 /* Motion 10 at San Diego: If a static const integral data member is
10964 initialized with an integral constant expression, the initializer
10965 may appear either in the declaration (within the class), or in
10966 the definition, but not both. If it appears in the class, the
10967 member is a member constant. The file-scope definition is always
10968 required. */
10971 "invalid in-class initialization of static data member "
10973 type);
10976 "ISO C++ forbids in-class initialization of non-const "
10978 decl);
10981 "ISO C++ forbids initialization of member constant "
10983 }
10985 /* *expr_p is part of the TYPE_SIZE of a variably-sized array. If any
10986 SAVE_EXPRs in *expr_p wrap expressions with side-effects, break those
10987 expressions out into temporary variables so that walk_tree doesn't
10988 step into them (c++/15764). */
10990 static tree
10992 {
10996 {
11002 }
11006 }
11008 /* Entry point for the above. */
11010 static void
11012 {
11014 /* Break out any function calls into temporary variables. */
11016 }
11018 /* Reduce a SIZEOF_EXPR to its value. */
11020 tree
11022 {
11023 tree r;
11032 else
11039 }
11041 /* Given the SIZE (i.e., number of elements) in an array, compute
11042 an appropriate index type for the array. If non-NULL, NAME is
11043 the name of the entity being declared. */
11045 static tree
11047 tsubst_flags_t complain)
11048 {
11052 /* The type of the index being computed. */
11053 tree itype;
11055 /* The original numeric size as seen in the source code before
11056 conversion to size_t. */
11062 {
11067 /* In C++98, we mark a non-constant array bound with a magic
11069 else
11070 {
11072 /* Pedantically a constant expression is required here and so
11073 __builtin_is_constant_evaluated () should fold to true if it
11074 is successfully folded into a constant. */
11080 }
11085 /* The array bound must be an integer type. */
11088 {
11094 else
11097 }
11098 }
11100 /* A type is dependent if it is...an array type constructed from any
11101 dependent type or whose size is specified by a constant expression
11102 that is value-dependent. */
11103 /* We can only call value_dependent_expression_p on integral constant
11104 expressions. */
11108 {
11109 /* Just build the index type and mark that it requires
11110 structural equality checks. */
11111 in_template:
11118 }
11121 {
11124 {
11128 else
11131 }
11133 /* We might have lost the TREE_CONSTANT flag e.g. when we are
11134 folding a conversion from a pointer to integral type. In that
11136 else
11137 /* Use the folded result for VLAs, too; it will have resolved
11138 SIZEOF_EXPR. */
11140 }
11142 /* Normally, the array-bound will be a constant. */
11144 {
11145 /* The size to use in diagnostics that reflects the constant
11146 size used in the source, rather than SIZE massaged above. */
11149 /* If the original size before conversion to size_t was signed
11150 and negative, convert it to ssizetype to restore the sign. */
11154 {
11157 /* Clear the overflow bit that may have been set as a result
11158 of the conversion from the sizetype of the new size to
11159 ssizetype. */
11161 }
11163 /* Verify that the array has a positive number of elements
11164 and issue the appropriate diagnostic if it doesn't. */
11166 {
11170 }
11171 /* As an extension we allow zero-sized arrays. */
11173 {
11175 /* We must fail if performing argument deduction (as
11176 indicated by the state of complain), so that
11177 another substitution can be found. */
11182 else
11185 }
11186 }
11188 /* We don't allow VLAs at non-function scopes, or during
11189 tentative template substitution. */
11192 {
11195 /* `(int) &fn' is not a valid array bound. */
11199 name);
11200 else
11203 }
11205 {
11209 else
11212 }
11214 {
11218 else
11221 }
11225 else
11226 {
11228 {
11229 /* A variable sized array. Arrange for the SAVE_EXPR on the inside
11230 of the MINUS_EXPR, which allows the -1 to get folded with the +1
11231 that happens when building TYPE_SIZE. */
11234 }
11236 /* Compute the index of the largest element in the array. It is
11237 one less than the number of elements in the array. We save
11238 and restore PROCESSING_TEMPLATE_DECL so that computations in
11239 cp_build_binary_op will be appropriately folded. */
11240 {
11241 processing_template_decl_sentinel s;
11243 MINUS_EXPR,
11246 complain),
11247 complain);
11249 }
11252 {
11255 {
11256 /* We have to add 1 -- in the ubsan routine we generate
11257 LE_EXPR rather than LT_EXPR. */
11262 }
11263 }
11264 /* Make sure that there was no overflow when creating to a signed
11265 index type. (For example, on a 32-bit machine, an array with
11266 size 2^32 - 1 is too big.) */
11269 {
11274 }
11275 }
11277 /* Create and return the appropriate index type. */
11280 /* If the index type were dependent, we would have returned early, so
11281 remember that it isn't. */
11285 }
11287 tree
11289 {
11291 }
11293 /* Returns the scope (if any) in which the entity declared by
11294 DECLARATOR will be located. If the entity was declared with an
11295 unqualified name, NULL_TREE is returned. */
11297 tree
11299 {
11303 /* If the declarator-id is a SCOPE_REF, the scope in which the
11304 declaration occurs is the first operand. */
11309 /* Otherwise, the declarator is not a qualified name; the entity will
11310 be declared in the current scope. */
11312 }
11314 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
11315 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
11316 with this type. */
11318 static tree
11320 {
11323 /* If things have already gone awry, bail now. */
11327 /* [dcl.type.class.deduct] prohibits forming an array of placeholder
11328 for a deduced class type. */
11330 {
11334 else
11337 }
11339 /* If there are some types which cannot be array elements,
11340 issue an error-message and return. */
11342 {
11346 else
11353 else
11360 else
11367 name);
11368 else
11374 }
11380 /* [dcl.array]
11382 The constant expressions that specify the bounds of the arrays
11383 can be omitted only for the first member of the sequence. */
11385 {
11389 name);
11390 else
11395 }
11397 /* Figure out the index type for the array. */
11399 {
11401 tf_warning_or_error);
11404 {
11407 }
11408 }
11411 }
11413 /* Returns the smallest location that is not UNKNOWN_LOCATION. */
11415 static location_t
11417 {
11423 }
11425 /* Returns the smallest location != UNKNOWN_LOCATION among the
11426 three stored in LOCATIONS[ds_const], LOCATIONS[ds_volatile],
11427 and LOCATIONS[ds_restrict]. */
11429 static location_t
11431 {
11444 }
11446 /* Returns the smallest among the latter and locations[ds_type_spec]. */
11448 static location_t
11450 {
11453 }
11455 static location_t
11457 {
11460 }
11462 /* Check that it's OK to declare a function with the indicated TYPE
11463 and TYPE_QUALS. SFK indicates the kind of special function (if any)
11464 that this function is. OPTYPE is the type given in a conversion
11465 operator declaration, or the class type for a constructor/destructor.
11466 Returns the actual return type of the function; that may be different
11467 than TYPE if an error occurs, or for certain special functions. */
11469 static tree
11471 tree type,
11472 tree optype,
11475 {
11477 {
11488 else
11500 /* We can't use the proper return type here because we run into
11501 problems with ambiguous bases and covariant returns. */
11504 else
11514 "qualifiers are not allowed on declaration of "
11526 "qualifiers are not allowed on declaration of "
11529 {
11533 }
11534 else
11544 }
11547 }
11549 /* A variable or data member (whose unqualified name is IDENTIFIER)
11550 has been declared with the indicated TYPE. If the TYPE is not
11551 acceptable, issue an error message and return a type to use for
11552 error-recovery purposes. */
11554 tree
11556 {
11558 {
11562 {
11565 identifier);
11566 }
11567 else
11570 }
11573 }
11575 /* Handle declaring DECL as an inline variable. */
11577 static void
11579 {
11582 {
11586 }
11591 {
11594 }
11595 }
11598 /* Assign a typedef-given name to a class or enumeration type declared
11599 as anonymous at first. This was split out of grokdeclarator
11600 because it is also used in libcc1. */
11602 void
11604 {
11607 /* Replace the anonymous decl with the real decl. Be careful not to
11608 rename other typedefs (such as the self-reference) of type. */
11614 /* If this is a typedef within a template class, the nested
11615 type is a (non-primary) template. The name for the
11616 template needs updating as well. */
11620 /* Adjust linkage now that we aren't unnamed anymore. */
11623 /* FIXME remangle member functions; member functions of a
11624 type with external linkage have external linkage. */
11626 /* Check that our job is done, and that it would fail if we
11627 attempted to do it again. */
11629 }
11631 /* Check that decltype(auto) was well-formed: only plain decltype(auto)
11632 is allowed. TYPE might contain a decltype(auto). Returns true if
11633 there was a problem, false otherwise. */
11635 static bool
11637 {
11639 {
11641 {
11643 {
11647 }
11649 {
11652 }
11653 }
11654 }
11656 }
11658 /* Given declspecs and a declarator (abstract or otherwise), determine
11659 the name and type of the object declared and construct a DECL node
11660 for it.
11662 DECLSPECS points to the representation of declaration-specifier
11663 sequence that precedes declarator.
11665 DECL_CONTEXT says which syntactic context this declaration is in:
11666 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
11667 FUNCDEF for a function definition. Like NORMAL but a few different
11668 error messages in each case. Return value may be zero meaning
11669 this definition is too screwy to try to parse.
11670 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
11671 handle member functions (which have FIELD context).
11672 Return value may be zero meaning this definition is too screwy to
11673 try to parse.
11674 PARM for a parameter declaration (either within a function prototype
11675 or before a function body). Make a PARM_DECL, or return void_type_node.
11676 TPARM for a template parameter declaration.
11677 CATCHPARM for a parameter declaration before a catch clause.
11678 TYPENAME if for a typename (in a cast or sizeof).
11679 Don't make a DECL node; just return the ..._TYPE node.
11680 FIELD for a struct or union field; make a FIELD_DECL.
11681 BITFIELD for a field with specified width.
11683 INITIALIZED is as for start_decl.
11685 ATTRLIST is a pointer to the list of attributes, which may be NULL
11686 if there are none; *ATTRLIST may be modified if attributes from inside
11687 the declarator should be applied to the declaration.
11689 When this function is called, scoping variables (such as
11690 CURRENT_CLASS_TYPE) should reflect the scope in which the
11691 declaration occurs, not the scope in which the new declaration will
11692 be placed. For example, on:
11694 void S::f() { ... }
11696 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
11697 should not be `S'.
11699 Returns a DECL (if a declarator is present), a TYPE (if there is no
11700 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
11701 error occurs. */
11703 tree
11709 {
11722 /* True if this declarator is a function definition. */
11726 #if 0
11727 /* See the code below that used this. */
11729 #endif
11731 /* Keep track of what sort of function is being processed
11732 so that we can warn about default return values, or explicit
11733 return values which do not match prescribed defaults. */
11739 /* cv-qualifiers that apply to the declarator, for a declaration of
11740 a member function. */
11742 /* virt-specifiers that apply to the declarator, for a declaration of
11743 a member function. */
11745 /* ref-qualifier that applies to the declarator, for a declaration of
11746 a member function. */
11748 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
11755 /* The unqualified name of the declarator; either an
11756 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
11757 tree unqualified_id;
11758 /* The class type, if any, in which this entity is located,
11759 or NULL_TREE if none. Note that this value may be different from
11760 the current class type; for example if an attempt is made to declare
11761 "A::f" inside "B", this value will be "A". */
11763 /* The NAMESPACE_DECL for the namespace in which this entity is
11764 located. If an unqualified name is used to declare the entity,
11765 this value will be NULL_TREE, even if the entity is located at
11766 namespace scope. */
11768 cp_storage_class storage_class;
11791 // Was concept_p specified? Note that ds_concept
11792 // implies ds_constexpr!
11814 location_t id_loc;
11815 location_t init_loc;
11817 {
11820 }
11821 else
11824 /* Look inside a declarator for the name being declared
11825 and get it as a string, for an error message. */
11827 id_declarator;
11829 {
11834 {
11838 {
11842 }
11846 {
11852 {
11857 {
11858 /* [dcl.meaning]
11860 A declarator-id shall not be qualified except
11861 for ...
11863 None of the cases are permitted in block
11864 scope. */
11867 decl);
11871 else
11875 }
11877 {
11880 {
11884 }
11886 && current_class_type
11888 current_class_type))
11889 {
11894 }
11895 }
11898 }
11900 {
11902 {
11904 {
11908 }
11911 {
11915 }
11922 }
11926 {
11932 }
11933 /* Fall through. */
11940 {
11942 dname);
11944 }
11947 else
11948 {
11955 else
11957 }
11962 }
11964 }
11981 }
11984 }
11986 /* [dcl.fct.edf]
11988 The declarator in a function-definition shall have the form
11989 D1 ( parameter-declaration-clause) ... */
11991 {
11994 }
11999 {
12002 }
12005 {
12008 {
12011 }
12014 {
12016 {
12019 }
12021 {
12024 }
12025 }
12026 }
12028 /* Anything declared one level down from the top level
12029 must be one of the parameters of a function
12030 (because the body is at least two levels down). */
12032 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
12033 by not allowing C++ class definitions to specify their parameters
12034 with xdecls (must be spec.d in the parmlist).
12036 Since we now wait to push a class scope until we are sure that
12037 we are in a legitimate method context, we must set oldcname
12038 explicitly (since current_class_name is not yet alive).
12040 We also want to avoid calling this a PARM if it is in a namespace. */
12043 {
12049 }
12055 {
12059 }
12062 {
12066 }
12069 {
12073 }
12076 {
12080 }
12083 {
12087 }
12089 /* [dcl.spec]/2 "At most one of the constexpr, consteval, and constinit
12090 keywords shall appear in a decl-specifier-seq." */
12092 {
12096 "can use at most one of the %<constinit%> and %<constexpr%> "
12099 }
12101 /* If there were multiple types specified in the decl-specifier-seq,
12102 issue an error message. */
12104 {
12108 }
12113 /* Extract the basic type from the decl-specifier-seq. */
12116 {
12119 }
12121 /* Ignore erroneous attributes. */
12125 /* An object declared as __attribute__((unavailable)) suppresses
12126 any reports of being declared with unavailable or deprecated
12127 items. An object declared as __attribute__((deprecated))
12128 suppresses warnings of uses of other deprecated items. */
12137 {
12143 }
12144 /* No type at all: default to `int', and set DEFAULTED_INT
12145 because it was not a user-defined typedef. */
12147 {
12149 {
12150 /* These imply 'int'. */
12153 }
12154 /* If we just have "complex", it is equivalent to "complex double". */
12157 {
12160 "ISO C++ does not support plain %<complex%> meaning "
12162 }
12163 }
12164 /* Gather flags. */
12168 #if 0
12169 /* See the code below that used this. */
12172 #endif
12177 else
12181 {
12183 ctor_return_type,
12184 type_quals,
12187 }
12189 {
12194 /* We handle `main' specially here, because 'main () { }' is so
12195 common. With no options, it is allowed. With -Wreturn-type,
12196 it is a warning. It is only an error with -pedantic-errors. */
12197 is_main = (funcdef_flag
12210 name);
12214 else
12219 /* FIXME we should be able to propagate the error_mark_node as is
12220 for other contexts too. */
12222 else
12224 }
12229 {
12231 {
12236 }
12237 /* Don't pedwarn if the alternate "__intN__" form has been used instead
12238 of "__intN". */
12243 }
12245 /* Now process the modifiers that were specified
12246 and check for invalid combinations. */
12248 /* Long double is a special combination. */
12250 {
12254 }
12256 /* Check all other uses of type modifiers. */
12259 {
12260 location_t loc;
12263 {
12266 }
12268 {
12271 }
12273 {
12276 }
12278 {
12281 }
12283 {
12286 }
12291 {
12296 }
12298 {
12302 }
12312 {
12314 {
12320 }
12323 else
12325 }
12326 else
12329 /* Discard the type modifiers if they are invalid. */
12331 {
12337 }
12338 }
12340 /* Decide whether an integer type is signed or not.
12341 Optionally treat bitfields as signed by default. */
12343 /* [class.bit]
12345 It is implementation-defined whether a plain (neither
12346 explicitly signed or unsigned) char, short, int, or long
12347 bit-field is signed or unsigned.
12349 Naturally, we extend this to long long as well. Note that
12350 this does not include wchar_t. */
12352 && !signed_p
12353 /* A typedef for plain `int' without `signed' can be
12354 controlled just like plain `int', but a typedef for
12355 `signed int' cannot be so controlled. */
12356 && !(typedef_decl
12360 {
12373 else
12375 }
12388 {
12392 /* If a modifier is specified, the resulting complex is the complex
12393 form of TYPE. E.g, "complex short" is "complex short int". */
12402 else
12404 }
12406 /* If we're using the injected-class-name to form a compound type or a
12407 declaration, replace it with the underlying class so we don't get
12408 redundant typedefs in the debug output. But if we are returning the
12409 type unchanged, leave it alone so that it's available to
12410 maybe_get_template_decl_from_type_decl. */
12418 type = cp_build_qualified_type
12422 /* We might have ignored or rejected some of the qualifiers. */
12427 /* Placeholder in parm gets a better error below. */
12431 {
12432 auto_diagnostic_group g;
12436 "for deduction, template placeholder must be followed "
12440 }
12451 /* Treat class-scope deduction guides as static member functions
12452 so that they get a FUNCTION_TYPE instead of a METHOD_TYPE. */
12456 {
12458 {
12465 }
12467 {
12471 "declared both %<virtual%> and %<constexpr%> only in "
12473 }
12474 }
12477 /* Issue errors about use of storage classes for parameters. */
12479 {
12481 {
12485 }
12487 {
12491 name);
12493 }
12497 {
12502 }
12504 /* Function parameters cannot be concept. */
12506 {
12511 }
12512 /* Function parameters cannot be constexpr. If we saw one, moan
12513 and pretend it wasn't there. */
12515 {
12519 }
12521 {
12525 }
12527 {
12531 }
12532 }
12534 /* Give error if `virtual' is used outside of class declaration. */
12537 {
12541 }
12544 {
12561 "structured binding declaration can be %qs only in "
12563 declspecs->gnu_thread_keyword_p
12568 /* [dcl.struct.bind] "A cv that includes volatile is deprecated." */
12573 {
12583 "structured binding declaration can be %qs only in "
12600 }
12603 {
12605 {
12609 "type must be cv-qualified %<auto%> or reference to "
12611 }
12614 }
12621 {
12624 }
12625 }
12627 /* Static anonymous unions are dealt with here. */
12633 /* Warn about storage classes that are invalid for certain
12634 kinds of declarations (parameters, typenames, etc.). */
12636 && ((storage_class
12640 {
12641 location_t loc
12646 }
12651 {
12655 ;
12657 ;
12659 /* C++ allows static class elements. */
12661 /* C++ also allows inlines and signed and unsigned elements,
12662 but in those cases we don't come in here. */
12663 ;
12664 else
12665 {
12666 location_t loc
12673 else
12680 }
12681 }
12686 {
12690 }
12694 {
12700 /* When thread_local is applied to a variable of block scope the
12701 storage-class-specifier static is implied if it does not appear
12702 explicitly. */
12705 }
12708 {
12711 "storage class specifiers invalid in friend function "
12715 }
12719 else
12720 {
12723 {
12736 }
12737 }
12740 {
12745 }
12747 /* Determine the type of the entity declared by recurring on the
12748 declarator. */
12750 {
12752 tree attrs;
12759 {
12771 /* Assume that any attributes that get applied late to
12772 templates will DTRT when applied to the declaration
12773 as a whole. */
12777 attrs),
12778 attr_flags);
12780 }
12784 /* We don't want to warn in parameter context because we don't
12785 yet know if the parse will succeed, and this might turn out
12786 to be a constructor call. */
12789 && !typedef_p
12791 /* If the type is class-like and the inner name used a
12792 global namespace qualifier, we need the parens.
12793 Unfortunately all we can tell is whether a qualified name
12794 was used or not. */
12795 && !(inner_declarator
12800 {
12803 name))
12804 {
12809 }
12810 }
12815 {
12826 /* [dcl.array]/1:
12828 The optional attribute-specifier-seq appertains to the
12829 array. */
12835 {
12836 tree arg_types;
12839 /* Declaring a function type. */
12841 /* Pick up type qualifiers which should be applied to `this'. */
12843 /* Pick up virt-specifiers. */
12845 /* And ref-qualifier, too */
12847 /* And tx-qualifier. */
12849 /* Pick up the exception specifications. */
12851 /* If the exception-specification is ill-formed, let's pretend
12852 there wasn't one. */
12860 /* Say it's a definition only for the CALL_EXPR
12861 closest to the identifier. */
12864 /* Handle a late-specified return type. */
12867 {
12869 {
12876 {
12878 "%<auto%> type specifier without "
12881 "deduced return type only available "
12883 }
12885 {
12889 }
12890 }
12892 {
12894 "return type has %qT as its type rather "
12897 }
12899 {
12902 "%qs function with trailing return type "
12903 "has %<decltype(auto)%> as its type "
12905 else
12909 }
12915 {
12917 {
12918 auto_diagnostic_group g;
12925 }
12927 {
12929 "for %qT must have trailing return "
12934 }
12940 else
12944 }
12945 }
12948 {
12952 /* Not using maybe_warn_cpp0x because this should
12953 always be an error. */
12955 "trailing return type only available "
12957 else
12959 "return type not declared with %<auto%> "
12962 }
12964 {
12967 }
12973 {
12976 }
12979 {
12983 /* [dcl.fct] "A volatile-qualified return type is
12984 deprecated." */
12987 "%<volatile%>-qualified return type is "
12990 /* We now know that the TYPE_QUALS don't apply to the
12991 decl, but to its return type. */
12993 }
12995 /* Error about some types functions can't return. */
12998 {
13002 }
13004 {
13008 }
13010 {
13012 "%<constinit%> on function return type is not "
13015 }
13022 && funcdecl_p
13028 {
13029 /* We are within a class's scope. If our declarator name
13030 is the same as the class name, and we are defining
13031 a function, then it is a constructor/destructor, and
13032 therefore returns a void type. */
13034 /* ISO C++ 12.4/2. A destructor may not be declared
13035 const or volatile. A destructor may not be static.
13036 A destructor may not be declared with ref-qualifier.
13038 ISO C++ 12.1. A constructor may not be declared
13039 const or volatile. A constructor may not be
13040 virtual. A constructor may not be static.
13041 A constructor may not be declared with ref-qualifier. */
13050 {
13055 }
13058 {
13064 }
13068 current_class_type,
13069 flags))
13073 {
13074 /* It's a constructor. */
13078 {
13082 }
13086 }
13089 }
13091 {
13093 {
13094 /* Cannot be both friend and virtual. */
13099 }
13104 {
13106 "cannot define friend function %qs in a local "
13109 }
13110 /* [class.friend]/6: A function can be defined in a friend
13111 declaration if the function name is unqualified. */
13113 {
13116 "friend function definition %qs cannot have "
13118 else
13120 "friend function definition %qs cannot have "
13122 in_namespace);
13123 }
13124 }
13126 {
13128 {
13131 }
13132 }
13134 {
13137 }
13144 pushed_scope
13156 {
13161 }
13167 {
13169 /* transaction_safe applies to the type, but
13170 transaction_safe_dynamic applies to the function. */
13173 else
13175 }
13177 /* [dcl.fct]/2:
13179 The optional attribute-specifier-seq appertains to
13180 the function type. */
13185 }
13191 /* Filter out pointers-to-references and references-to-references.
13192 We can get these if a TYPE_DECL is used. */
13195 {
13197 {
13200 }
13202 /* In C++0x, we allow reference to reference declarations
13203 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
13204 and template type arguments [14.3.1/4 temp.arg.type]. The
13205 check for direct reference to reference declarations, which
13206 are still forbidden, occurs below. Reasoning behind the change
13207 can be found in DR106, DR540, and the rvalue reference
13208 proposals. */
13210 {
13213 }
13214 }
13216 {
13221 }
13223 /* We now know that the TYPE_QUALS don't apply to the decl,
13224 but to the target of the pointer. */
13227 /* This code used to handle METHOD_TYPE, but I don't think it's
13228 possible to get it here anymore. */
13232 {
13236 memfn_quals,
13237 rqual);
13243 }
13251 type);
13253 /* When the pointed-to type involves components of variable size,
13254 care must be taken to ensure that the size evaluation code is
13255 emitted early enough to dominate all the possible later uses
13256 and late enough for the variables on which it depends to have
13257 been assigned.
13259 This is expected to happen automatically when the pointed-to
13260 type has a name/declaration of it's own, but special attention
13261 is required if the type is anonymous.
13263 We handle the NORMAL and FIELD contexts here by inserting a
13264 dummy statement that just evaluates the size at a safe point
13265 and ensures it is not deferred until e.g. within a deeper
13266 conditional context (c++/43555).
13268 We expect nothing to be needed here for PARM or TYPENAME.
13269 Evaluating the size at this point for TYPENAME would
13270 actually be incorrect, as we might be in the middle of an
13271 expression with side effects on the pointed-to type size
13272 "arguments" prior to the pointer declaration point and the
13273 size evaluation could end up prior to the side effects. */
13279 {
13283 }
13286 {
13287 /* In C++0x, the type we are creating a reference to might be
13288 a typedef which is itself a reference type. In that case,
13289 we follow the reference collapsing rules in
13290 [7.1.3/8 dcl.typedef] to create the final reference type:
13292 "If a typedef TD names a type that is a reference to a type
13293 T, an attempt to create the type 'lvalue reference to cv TD'
13294 creates the type 'lvalue reference to T,' while an attempt
13295 to create the type "rvalue reference to cv TD' creates the
13296 type TD."
13297 */
13301 {
13304 else
13306 }
13307 else
13308 type = cp_build_reference_type
13311 /* In C++0x, we need this check for direct reference to
13312 reference declarations, which are forbidden by
13313 [8.3.2/5 dcl.ref]. Reference to reference declarations
13314 are only allowed indirectly through typedefs and template
13315 type arguments. Example:
13317 void foo(int & &); // invalid ref-to-ref decl
13319 typedef int & int_ref;
13320 void foo(int_ref &); // valid ref-to-ref decl
13321 */
13325 }
13329 {
13333 /* We will already have complained. */
13335 else
13337 type);
13338 }
13339 else
13342 /* Process a list of type modifier keywords (such as
13343 const or volatile) that were given inside the `*' or `&'. */
13346 {
13347 type
13351 }
13353 /* Apply C++11 attributes to the pointer, and not to the
13354 type pointed to. This is unlike what is done for GNU
13355 attributes above. It is to comply with [dcl.ptr]/1:
13357 [the optional attribute-specifier-seq (7.6.1) appertains
13358 to the pointer and not to the object pointed to]. */
13371 }
13372 }
13377 /* Don't check this if it can be the artifical decltype(auto)
13378 we created when building a constraint in a compound-requirement:
13379 that the type-constraint is plain is going to be checked in
13380 cp_parser_compound_requirement. */
13385 /* A `constexpr' specifier used in an object declaration declares
13386 the object as `const'. */
13388 {
13389 /* DR1688 says that a `constexpr' specifier in combination with
13390 `volatile' is valid. */
13393 {
13396 }
13397 }
13402 {
13404 unqualified_id);
13406 }
13408 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
13409 qualified with a class-name, turn it into a METHOD_TYPE, unless
13410 we know that the function is static. We take advantage of this
13411 opportunity to do other processing that pertains to entities
13412 explicitly declared to be class members. Note that if DECLARATOR
13413 is non-NULL, we know it is a cdk_id declarator; otherwise, we
13414 would not have exited the loop above. */
13419 {
13425 {
13427 {
13429 "member functions are implicitly "
13432 }
13433 else
13436 }
13438 can skip the following checks. */
13441 qualifying type must certainly be complete. */
13442 funcdef_flag
13443 /* A friend declaration of "T::f" is OK, even if
13444 "T" is a template parameter. But, if this
13445 function is not a friend, the qualifying type
13446 must be a class. */
13448 /* For a declaration, the type need not be
13449 complete, if either it is dependent (since there
13450 is no meaningful definition of complete in that
13451 case) or the qualifying class is currently being
13452 defined. */
13455 /* Check that the qualifying type is complete. */
13459 {
13462 {
13470 }
13471 }
13473 {
13477 }
13478 }
13483 /* Now TYPE has the actual type. */
13486 {
13489 else
13491 }
13497 {
13498 /* [dcl.meaning]/1: The optional attribute-specifier-seq following
13499 a declarator-id appertains to the entity that is declared. */
13502 else
13503 /* We should have already diagnosed the issue (c++/78344). */
13505 }
13507 /* Handle parameter packs. */
13509 {
13511 /* Turn the type into a pack expansion.*/
13513 else
13515 }
13518 && !processing_template_decl
13520 {
13524 else
13528 }
13531 {
13532 /* [dcl.fct.spec] (C++11) The explicit specifier shall be used only
13533 in the declaration of a constructor or conversion function within
13534 a class definition. */
13541 else
13543 "only declarations of constructors and conversion operators "
13546 }
13549 {
13552 {
13554 name);
13556 }
13558 {
13561 name);
13563 }
13565 {
13567 name);
13569 }
13571 {
13573 name);
13575 }
13577 {
13579 name);
13581 }
13583 {
13585 name);
13587 }
13588 }
13590 /* If this is declaring a typedef name, return a TYPE_DECL. */
13592 {
13594 tree decl;
13597 {
13601 else
13605 }
13607 /* This declaration:
13609 typedef void f(int) const;
13611 declares a function type which is not a member of any
13612 particular class, but which is cv-qualified; for
13613 example "f S::*" declares a pointer to a const-qualified
13614 member function of S. We record the cv-qualification in the
13615 function type. */
13617 {
13620 /* We have now dealt with these qualifiers. */
13623 }
13626 {
13630 else
13634 }
13640 {
13643 }
13647 else
13651 {
13655 /* The TYPE_DECL is "abstract" because there will be
13656 clones of this constructor/destructor, and there will
13657 be copies of this TYPE_DECL generated in those
13658 clones. The decloning optimization (for space) may
13659 revert this subsequently if it determines that
13660 the clones should share a common implementation. */
13664 }
13669 unqualified_id);
13671 /* If the user declares "typedef struct {...} foo" then the
13672 struct will have an anonymous name. Fill that name in now.
13673 Nothing can refer to it, so nothing needs know about the name
13674 change. */
13676 && unqualified_id
13695 /* Acknowledge that this was written:
13696 `using analias = atype;'. */
13700 }
13702 /* Detect the case of an array type of unspecified size
13703 which came, as such, direct from a typedef name.
13704 We must copy the type, so that the array's domain can be
13705 individually set by the object's initializer. */
13712 /* Detect where we're using a typedef of function type to declare a
13713 function. PARMS will not be set, so we must create it now. */
13716 {
13718 tree args;
13723 {
13729 }
13734 {
13735 /* The qualifiers on the function type become the qualifiers on
13736 the non-static member function. */
13741 }
13742 }
13744 /* If this is a type name (such as, in a cast or sizeof),
13745 compute the type and return it now. */
13748 {
13749 /* Note that here we don't care about type_quals. */
13751 /* Special case: "friend class foo" looks like a TYPENAME context. */
13753 {
13755 {
13758 }
13761 {
13762 /* Don't allow friend declaration without a class-key. */
13769 else
13772 type);
13773 }
13775 /* Only try to do this stuff if we didn't already give up. */
13777 {
13778 /* A friendly class? */
13782 else
13784 type);
13787 }
13788 }
13790 {
13797 /* Core issue #547: need to allow this in template type args.
13798 Allow it in general in C++11 for alias-declarations. */
13802 else
13804 }
13810 }
13814 && ! bitfield
13816 {
13819 }
13822 {
13823 /* Only functions may be declared using an operator-function-id. */
13825 {
13828 }
13833 type);
13834 }
13836 /* We don't check parameter types here because we can emit a better
13837 error message later. */
13839 {
13843 }
13845 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
13846 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
13849 {
13855 {
13857 {
13862 {
13863 auto_diagnostic_group g;
13867 "missing template argument list after %qE; template "
13873 }
13874 else
13877 }
13878 else
13881 }
13883 /* A parameter declared as an array of T is really a pointer to T.
13884 One declared as a function is really a pointer to a function.
13885 One declared as a member is really a pointer to member. */
13888 {
13889 /* Transfer const-ness of array into that of type pointed to. */
13893 }
13896 }
13899 && !(unqualified_id
13902 {
13908 }
13910 {
13914 {
13922 }
13924 {
13927 {
13933 else
13937 }
13939 /* The C99 flexible array extension. */
13942 {
13946 {
13949 }
13950 else
13951 {
13952 /* Array is a flexible member. */
13956 else
13960 /* Flexible array member has a null domain. */
13962 }
13963 }
13966 {
13967 /* Happens when declaring arrays of sizes which
13968 are error_mark_node, for example. */
13970 }
13972 {
13973 /* Something like struct S { int N::j; }; */
13976 }
13978 {
13980 tree function_context;
13983 {
13984 /* This should never happen in pure C++ (the check
13985 could be an assert). It could happen in
13986 Objective-C++ if someone writes invalid code that
13987 uses a function declaration for an instance
13988 variable or property (instance variables and
13989 properties are parsed as FIELD_DECLs, but they are
13990 part of an Objective-C class, not a C++ class).
13991 That code is invalid and is caught by this
13992 check. */
13994 {
13996 unqualified_id);
13998 }
14000 /* ``A union may [ ... ] not [ have ] virtual functions.''
14001 ARM 9.5 */
14003 {
14006 unqualified_id);
14008 }
14013 {
14015 "%qD cannot be declared %<virtual%>, since it "
14018 }
14019 }
14021 /* Check that the name used for a destructor makes sense. */
14023 {
14027 {
14032 }
14035 {
14039 }
14041 {
14045 }
14047 {
14049 "%<constexpr%> destructors only available"
14052 }
14054 {
14058 }
14059 }
14061 {
14066 }
14069 {
14073 }
14075 {
14079 }
14083 {
14087 }
14090 {
14093 {
14099 }
14100 }
14102 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
14103 function_context
14112 parms,
14113 unqualified_id,
14114 declspecs,
14115 reqs,
14127 #if 0
14128 /* This clobbers the attrs stored in `decl' from `attrlist'. */
14129 /* The decl and setting of decl_attr is also turned off. */
14131 #endif
14133 /* [class.conv.ctor]
14135 A constructor declared without the function-specifier
14136 explicit that can be called with a single parameter
14137 specifies a conversion from the type of its first
14138 parameter to the type of its class. Such a constructor
14139 is called a converting constructor. */
14145 }
14147 && ((current_class_type
14153 {
14156 {
14158 {
14162 }
14163 else
14168 }
14169 }
14171 staticp
14172 ? TCTX_STATIC_STORAGE
14174 {
14177 }
14178 else
14179 {
14181 {
14184 "%qE is neither function nor member function; "
14186 else
14190 }
14192 }
14195 {
14196 /* Packages tend to use GNU attributes on friends, so we only
14197 warn for standard attributes. */
14199 {
14204 }
14205 /* Friends are treated specially. */
14209 {
14213 /* Kludge: We need funcdef_flag to be true in do_friend for
14214 in-class defaulted functions, but that breaks grokfndecl.
14215 So set it here. */
14221 }
14222 else
14224 }
14226 /* Structure field. It may not be a function, except for C++. */
14229 {
14231 {
14232 /* C++ allows static class members. All other work
14233 for this is done by grokfield. */
14242 {
14244 "%<constexpr%> static data member %qD must "
14247 }
14258 /* Even if there is an in-class initialization, DECL
14259 is considered undefined until an out-of-class
14260 definition is provided, unless this is an inline
14261 variable. */
14265 {
14271 }
14273 /* Set the constraints on the declaration. */
14277 {
14280 }
14281 }
14282 else
14283 {
14285 {
14291 }
14293 {
14298 }
14300 {
14305 }
14307 {
14312 }
14319 {
14322 }
14325 {
14326 /* An attempt is being made to initialize a non-static
14327 member. This is new in C++11. */
14330 /* If this has been parsed with static storage class, but
14331 errors forced staticp to be cleared, ensure NSDMI is
14332 not present. */
14335 }
14336 }
14343 }
14344 }
14346 {
14347 tree original_name;
14355 else
14357 // FIXME:gcc_assert (original_name == dname);
14365 name);
14367 {
14371 name);
14372 else
14374 "storage class %<thread_local%> invalid for "
14376 }
14381 /* Function declaration not at top level.
14382 Storage classes other than `extern' are not allowed
14383 and `extern' makes no difference. */
14388 {
14391 "%<static%> specifier invalid for function %qs "
14393 else
14395 "%<inline%> specifier invalid for function %qs "
14397 }
14400 {
14402 {
14405 }
14408 {
14413 }
14414 }
14418 {
14422 }
14424 /* Record whether the function is public. */
14429 declspecs,
14432 publicp,
14436 sfk,
14437 funcdef_flag,
14438 late_return_type_p,
14440 id_loc);
14447 {
14450 /* Don't allow a static member function in a class, and forbid
14451 declaring main to be static. */
14453 {
14457 }
14459 {
14460 /* 7.1.1: There can be no static function declarations within a
14461 block. */
14465 }
14468 {
14471 }
14472 }
14475 }
14476 else
14477 {
14478 /* It's a variable. */
14480 /* An uninitialized decl with `extern' is a reference. */
14482 declspecs,
14483 initialized,
14484 type_quals,
14485 inlinep,
14486 concept_p,
14487 template_count,
14489 id_loc);
14499 {
14502 {
14504 "%<static%> may not be used when defining "
14508 }
14510 {
14513 }
14515 {
14517 "cannot explicitly declare member %q#D to have "
14520 }
14521 }
14523 {
14525 "declaration of %<constexpr%> variable %qD "
14528 }
14530 {
14534 }
14539 {
14544 }
14545 }
14550 {
14554 }
14557 {
14559 {
14560 /* It's common practice (and completely valid) to have a const
14561 be initialized and declared extern. */
14565 }
14566 else
14567 {
14571 }
14572 }
14574 /* Record `register' declaration for warnings on &
14575 and in case doing stupid register allocation. */
14578 {
14580 /* Warn about register storage specifiers on PARM_DECLs. */
14582 {
14585 "ISO C++17 does not allow %<register%> storage "
14587 else
14590 }
14591 }
14598 {
14599 /* Set constexpr flag on vars (functions got it in grokfndecl). */
14602 /* And the constinit flag (which only applies to variables). */
14605 }
14607 /* Record constancy and volatility on the DECL itself . There's
14608 no need to do this when processing a template; we'll do this
14609 for the instantiated declaration based on the type of DECL. */
14614 }
14615 }
14616 \f
14617 /* Subroutine of start_function. Ensure that each of the parameter
14618 types (as listed in PARMS) is complete, as is required for a
14619 function definition. */
14621 static void
14623 {
14625 {
14630 {
14637 }
14638 else
14639 /* grokparms or complete_type_or_else will have already issued
14640 an error. */
14642 }
14643 }
14645 /* Returns nonzero if T is a local variable. */
14647 int
14649 {
14658 }
14660 /* Like local_variable_p, but suitable for use as a tree-walking
14661 function. */
14663 static tree
14666 {
14668 {
14669 /* DR 2082 permits local variables in unevaluated contexts
14670 within a default argument. */
14673 }
14682 }
14684 /* Check that ARG, which is a default-argument expression for a
14685 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
14686 something goes wrong. DECL may also be a _TYPE node, rather than a
14687 DECL, if there is no DECL available. */
14689 tree
14691 {
14692 tree var;
14693 tree decl_type;
14696 /* We get a DEFERRED_PARSE when looking at an in-class declaration
14697 with a default argument. Ignore the argument for now; we'll
14698 deal with it after the class is complete. */
14702 {
14705 }
14706 else
14713 /* Something already went wrong. There's no need to check
14714 further. */
14717 /* [dcl.fct.default]
14719 A default argument expression is implicitly converted to the
14720 parameter type. */
14722 /* Avoid digest_init clobbering the initializer. */
14725 LOOKUP_IMPLICIT);
14728 /* Avoid redundant -Wzero-as-null-pointer-constant warnings at
14729 the call sites. */
14732 /* Don't lose side-effects as in PR90473. */
14736 /* [dcl.fct.default]
14738 Local variables shall not be used in default argument
14739 expressions.
14741 The keyword `this' shall not be used in a default argument of a
14742 member function. */
14745 {
14747 {
14751 else
14753 }
14755 }
14757 /* All is well. */
14759 }
14761 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
14763 static tree
14765 {
14770 {
14773 else
14774 {
14777 }
14778 }
14780 /* Do warn about using typedefs to a deprecated class. */
14792 return type_is_deprecated
14796 }
14798 /* Returns an unavailable type used within TYPE, or NULL_TREE if none. */
14800 static tree
14802 {
14807 {
14810 else
14811 {
14814 }
14815 }
14817 /* Do warn about using typedefs to a deprecated class. */
14829 return type_is_unavailable
14833 }
14835 /* Decode the list of parameter types for a function type.
14836 Given the list of things declared inside the parens,
14837 return a list of types.
14839 If this parameter does not end with an ellipsis, we append
14840 void_list_node.
14842 *PARMS is set to the chain of PARM_DECLs created. */
14844 tree
14846 {
14849 tree parm;
14853 {
14862 {
14865 }
14869 {
14871 && !init
14874 /* DR 577: A parameter list consisting of a single
14875 unnamed parameter of non-dependent type 'void'. */
14879 "invalid use of cv-qualified type %qT in "
14881 else
14883 "invalid use of type %<void%> in parameter "
14885 /* It's not a good idea to actually create parameters of
14886 type `void'; other parts of the compiler assume that a
14887 void type terminates the parameter list. */
14890 }
14893 {
14895 {
14899 }
14902 {
14906 }
14908 /* [dcl.fct] "A parameter with volatile-qualified type is
14909 deprecated." */
14912 "%<volatile%>-qualified parameter is "
14915 /* Top-level qualifiers on the parameters are
14916 ignored for function types. */
14919 {
14923 }
14925 {
14926 /* Before C++17 DR 393:
14927 [dcl.fct]/6, parameter types cannot contain pointers
14928 (references) to arrays of unknown bound. */
14933 {
14941 }
14944 ptr
14950 }
14954 }
14959 }
14969 /* We had parm errors, recover by giving the function (...) type. */
14973 }
14975 \f
14976 /* D is a constructor or overloaded `operator='.
14978 Let T be the class in which D is declared. Then, this function
14979 returns:
14981 -1 if D's is an ill-formed constructor or copy assignment operator
14982 whose first parameter is of type `T'.
14983 0 if D is not a copy constructor or copy assignment
14984 operator.
14985 1 if D is a copy constructor or copy assignment operator whose
14986 first parameter is a reference to non-const qualified T.
14987 2 if D is a copy constructor or copy assignment operator whose
14988 first parameter is a reference to const qualified T.
14990 This function can be used as a predicate. Positive values indicate
14991 a copy constructor and nonzero values indicate a copy assignment
14992 operator. */
14994 int
14996 {
14997 tree args;
14998 tree arg_type;
15006 /* Instantiations of template member functions are never copy
15007 functions. Note that member functions of templated classes are
15008 represented as template functions internally, and we must
15009 accept those as copy functions. */
15025 {
15026 /* Pass by value copy assignment operator. */
15028 }
15032 {
15035 }
15036 else
15042 /* There are more non-optional args. */
15046 }
15048 /* D is a constructor or overloaded `operator='.
15050 Let T be the class in which D is declared. Then, this function
15051 returns true when D is a move constructor or move assignment
15052 operator, false otherwise. */
15054 bool
15056 {
15058 /* There are no move constructors if we are in C++98 mode. */
15064 /* Instantiations of template member functions are never move
15065 functions. Note that member functions of templated classes are
15066 represented as template functions internally, and we must
15067 accept those as move functions. */
15071 }
15073 /* D is a constructor or overloaded `operator='.
15075 Then, this function returns true when D has the same signature as a move
15076 constructor or move assignment operator (because either it is such a
15077 ctor/op= or it is a template specialization with the same signature),
15078 false otherwise. */
15080 bool
15082 {
15083 tree args;
15084 tree arg_type;
15108 /* There are more non-optional args. */
15112 }
15114 /* Remember any special properties of member function DECL. */
15116 void
15118 {
15119 tree class_type;
15127 {
15134 {
15135 /* [class.copy]
15137 A non-template constructor for class X is a copy
15138 constructor if its first parameter is of type X&, const
15139 X&, volatile X& or const volatile X&, and either there
15140 are no other parameters or else all other parameters have
15141 default arguments. */
15145 }
15156 }
15158 {
15159 /* [class.copy]
15161 A non-template assignment operator for class X is a copy
15162 assignment operator if its parameter is of type X, X&, const
15163 X&, volatile X& or const volatile X&. */
15168 {
15172 }
15173 }
15177 /* Destructors are handled in check_methods. */
15178 }
15180 /* Check a constructor DECL has the correct form. Complains
15181 if the class has a constructor of the form X(X). */
15183 bool
15185 {
15189 {
15190 /* [class.copy]
15192 A declaration of a constructor for a class X is ill-formed if
15193 its first parameter is of type (optionally cv-qualified) X
15194 and either there are no other parameters or else all other
15195 parameters have default arguments.
15197 We *don't* complain about member template instantiations that
15198 have this form, though; they can occur as we try to decide
15199 what constructor to use during overload resolution. Since
15200 overload resolution will never prefer such a constructor to
15201 the non-template copy constructor (which is either explicitly
15202 or implicitly defined), there's no need to worry about their
15203 existence. Theoretically, they should never even be
15204 instantiated, but that's hard to forestall. */
15209 }
15212 }
15214 /* DECL is a declaration for an overloaded or conversion operator. If
15215 COMPLAIN is true, errors are issued for invalid declarations. */
15217 bool
15219 {
15229 tree_code operator_code;
15232 {
15233 /* Conversion operators are TYPE_EXPR for the purposes of this
15234 function. */
15237 }
15238 else
15239 {
15246 }
15249 {
15250 /* operator new and operator delete are quite special. */
15253 {
15272 }
15274 /* [basic.std.dynamic.allocation]/1:
15276 A program is ill-formed if an allocation function is declared
15277 in a namespace scope other than global scope or declared
15278 static in global scope.
15280 The same also holds true for deallocation functions. */
15282 {
15284 {
15286 decl);
15288 }
15291 {
15294 }
15295 }
15298 {
15301 }
15302 else
15303 {
15306 }
15309 }
15311 /* An operator function must either be a non-static member function
15312 or have at least one parameter of a class, a reference to a class,
15313 an enumeration, or a reference to an enumeration. 13.4.0.6 */
15315 {
15317 {
15319 {
15322 }
15324 /* For lambdas we diagnose static lambda specifier elsewhere. */
15326 /* For instantiations, we have diagnosed this already. */
15330 /* There are no further restrictions on the arguments to an
15331 overloaded "operator ()". */
15333 }
15338 {
15341 }
15344 {
15348 }
15351 {
15353 {
15358 }
15364 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
15365 because these checks are performed even on template
15366 functions. */
15370 }
15371 }
15374 /* There are no further restrictions on the arguments to an overloaded
15375 "operator ()". */
15378 /* C++23 allows an arbitrary number of parameters and default arguments for
15379 operator[], and none of the other checks below apply. */
15384 {
15385 /* 13.4.0.3 */
15388 }
15390 /* Count the number of arguments and check for ellipsis. */
15393 {
15395 {
15397 decl);
15399 }
15401 }
15403 /* Verify correct number of arguments. */
15405 {
15408 {
15409 /* We have a unary instance of an ambi-ary op. Remap to the
15410 unary one. */
15416 }
15418 {
15419 /* This was an ambiguous operator but is invalid. */
15421 methodp
15425 }
15428 && ! processing_template_decl
15429 /* x++ and x--'s second argument must be an int. */
15431 integer_type_node))
15432 {
15434 methodp
15437 decl);
15439 }
15444 {
15446 methodp
15450 }
15455 {
15457 methodp
15461 }
15466 }
15468 /* There can be no default arguments. */
15472 {
15476 }
15478 /* At this point the declaration is well-formed. It may not be
15479 sensible though. */
15481 /* Check member function warnings only on the in-class declaration.
15482 There's no point warning on an out-of-class definition. */
15486 /* Warn about conversion operators that will never be used. */
15490 {
15501 {
15504 ref
15509 class_type);
15510 /* Don't force t to be complete here. */
15515 ref
15521 }
15522 }
15527 /* Effective C++ rules below. */
15529 /* More Effective C++ rule 7. */
15536 /* More Effective C++ rule 6. */
15541 {
15550 {
15555 }
15556 else
15557 {
15561 }
15562 }
15564 /* Effective C++ rule 23. */
15575 }
15576 \f
15577 /* Return a string giving the keyword associate with CODE. */
15581 {
15583 {
15596 }
15597 }
15599 /* Name lookup in an elaborated-type-specifier (after the keyword
15600 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
15601 elaborated-type-specifier is invalid, issue a diagnostic and return
15602 error_mark_node; otherwise, return the *_TYPE to which it referred.
15603 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
15605 tree
15607 tree decl,
15609 {
15610 tree type;
15612 /* In the case of:
15614 struct S { struct S *p; };
15616 name lookup will find the TYPE_DECL for the implicit "S::S"
15617 typedef. Adjust for that here. */
15623 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
15624 is false for this case as well. */
15626 {
15630 }
15631 /* Accept template template parameters. */
15635 ;
15636 /* [dcl.type.elab]
15638 If the identifier resolves to a typedef-name or the
15639 simple-template-id resolves to an alias template
15640 specialization, the elaborated-type-specifier is ill-formed.
15642 In other words, the only legitimate declaration to use in the
15643 elaborated type specifier is the implicit typedef created when
15644 the type is declared. */
15648 {
15652 else
15657 }
15662 {
15666 }
15669 {
15673 }
15677 {
15678 /* If a class template appears as elaborated type specifier
15679 without a template header such as:
15681 template <class T> class C {};
15682 void f(class C); // No template header here
15684 then the required template argument is missing. */
15689 }
15692 }
15694 /* Lookup NAME of an elaborated type specifier according to SCOPE and
15695 issue diagnostics if necessary. Return *_TYPE node upon success,
15696 NULL_TREE when the NAME is not found, and ERROR_MARK_NODE for type
15697 error. */
15699 static tree
15702 {
15703 tree decl;
15705 {
15706 /* First try ordinary name lookup, ignoring hidden class name
15707 injected via friend declaration. */
15710 /* If that fails, the name will be placed in the smallest
15711 non-class, non-function-prototype scope according to 3.3.1/5.
15712 We may already have a hidden name declared as friend in this
15713 scope. So lookup again but not ignoring hidden names.
15714 If we find one, that name will be made visible rather than
15715 creating a new tag. */
15718 }
15719 else
15723 /* We found nothing. */
15727 {
15731 }
15734 && !template_header_p
15736 {
15741 }
15744 /* If scope is TAG_how::CURRENT_ONLY we're defining a class,
15745 so ignore a template template parameter. */
15750 /* Found not-a-type. */
15753 /* Look for invalid nested type:
15754 class C {
15755 class C {};
15756 }; */
15758 {
15762 }
15764 /* Two cases we need to consider when deciding if a class
15765 template is allowed as an elaborated type specifier:
15766 1. It is a self reference to its own class.
15767 2. It comes with a template header.
15769 For example:
15771 template <class T> class C {
15772 class C *c1; // DECL_SELF_REFERENCE_P is true
15773 class D;
15774 };
15775 template <class U> class C; // template_header_p is true
15776 template <class T> class C<T>::D {
15777 class C *c2; // DECL_SELF_REFERENCE_P is true
15778 }; */
15781 template_header_p
15786 {
15795 }
15798 }
15800 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
15801 Define the tag as a forward-reference if it is not defined.
15803 If a declaration is given, process it here, and report an error if
15804 multiple declarations are not identical.
15806 SCOPE is TS_CURRENT when this is also a definition. Only look in
15807 the current frame for the name (since C++ allows new names in any
15808 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
15809 declaration. Only look beginning from the current scope outward up
15810 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
15812 TEMPLATE_HEADER_P is true when this declaration is preceded by
15813 a set of template parameters. */
15815 tree
15818 {
15827 {
15840 }
15842 /* In case of anonymous name, xref_tag is only called to
15843 make type node and push name. Name lookup is not required. */
15854 {
15858 /* Since HOW is not TAG_how::CURRENT_ONLY, we are not looking at
15859 a definition of this tag. Since, in addition, we are
15860 currently processing a (member) template declaration of a
15861 template class, we must be very careful; consider:
15863 template <class X> struct S1
15865 template <class U> struct S2
15866 {
15867 template <class V> friend struct S1;
15868 };
15870 Here, the S2::S1 declaration should not be confused with the
15871 outer declaration. In particular, the inner version should
15872 have a template parameter of level 2, not level 1.
15874 On the other hand, when presented with:
15876 template <class T> struct S1
15877 {
15878 template <class U> struct S2 {};
15879 template <class U> friend struct S2;
15880 };
15882 the friend must find S1::S2 eventually. We accomplish this
15883 by making sure that the new type we create to represent this
15884 declaration has the right TYPE_CONTEXT. */
15887 }
15890 {
15891 /* If no such tag is yet defined, create a forward-reference node
15892 and record it as the "definition".
15893 When a real declaration of this type is found,
15894 the forward-reference will be altered into a real type. */
15896 {
15899 }
15904 /* Mark it as a lambda type right now. Our caller will
15905 correct the value. */
15908 }
15909 else
15910 {
15912 {
15913 /* Check that we aren't trying to overload a class with different
15914 constraints. */
15918 }
15922 {
15926 }
15930 {
15933 {
15937 }
15946 {
15947 /* Push it into this TU's symbol slot. */
15950 /* We're in the template parm binding level.
15951 Pushtag has logic to slide under that, but we're
15952 not pushing a *new* type. */
15958 }
15961 }
15962 }
15965 }
15967 /* Create the binfo hierarchy for REF with (possibly NULL) base list
15968 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
15969 access_* node, and the TREE_VALUE is the type of the base-class.
15970 Non-NULL TREE_TYPE indicates virtual inheritance. */
15972 void
15974 {
15981 tree default_access;
15987 /* The base of a derived class is private by default, all others are
15988 public. */
15993 /* First, make sure that any templates in base-classes are
15994 instantiated. This ensures that if we call ourselves recursively
15995 we do not get confused about which classes are marked and which
15996 are not. */
15999 {
16002 /* The dependent_type_p call below should really be dependent_scope_p
16003 so that we give a hard error about using an incomplete type as a
16004 base, but we allow it with a pedwarn for backward
16005 compatibility. */
16011 /* An incomplete type. Remove it from the list. */
16013 else
16014 {
16015 max_bases++;
16017 max_dvbases++;
16021 }
16022 }
16027 /* The binfo slot should be empty, unless this is an (ill-formed)
16028 redefinition. */
16039 /* Apply base-class info set up to the variants of this type. */
16043 {
16045 /* A C++98 POD cannot have base classes. */
16049 {
16052 }
16053 }
16060 {
16061 /* An aggregate can't have virtual base classes. */
16069 }
16072 {
16080 /* Before C++17, an aggregate cannot have base classes. In C++17, an
16081 aggregate can't have virtual, private, or protected base classes. */
16092 {
16094 basetype);
16096 }
16100 {
16102 /* The original basetype could have been a typedef'd type. */
16105 /* Inherit flags from the base. */
16116 }
16118 /* We must do this test after we've seen through a typedef
16119 type. */
16121 {
16124 else
16127 }
16130 /* Regenerate the pack expansion for the bases. */
16144 dropped_base:
16145 /* Update max_vbases to reflect the reality that we are dropping
16146 this base: if it reaches zero we want to undo the vec_alloc
16147 above to avoid inconsistencies during error-recovery: eg, in
16148 build_special_member_call, CLASSTYPE_VBASECLASSES non null
16149 and vtt null (c++/27952). */
16151 max_vbases--;
16153 max_vbases
16155 }
16162 /* If we didn't get max_vbases vbases, we must have shared at
16163 least one of them, and are therefore diamond shaped. */
16166 /* Unmark all the types. */
16171 /* Now see if we have a repeated base type. */
16173 {
16176 {
16178 {
16181 }
16183 }
16188 else
16190 }
16191 }
16193 \f
16194 /* Copies the enum-related properties from type SRC to type DST.
16195 Used with the underlying type of an enum and the enum itself. */
16196 static void
16198 {
16199 tree t;
16201 {
16211 else
16215 }
16216 }
16218 /* Begin compiling the definition of an enumeration type.
16219 NAME is its name,
16221 if ENUMTYPE is not NULL_TREE then the type has alredy been found.
16223 UNDERLYING_TYPE is the type that will be used as the storage for
16224 the enumeration type. This should be NULL_TREE if no storage type
16225 was specified.
16227 ATTRIBUTES are any attributes specified after the enum-key.
16229 SCOPED_ENUM_P is true if this is a scoped enumeration type.
16231 if IS_NEW is not NULL, gets TRUE iff a new type is created.
16233 Returns the type object, as yet incomplete.
16234 Also records info about it so that build_enumerator
16235 may be used to declare the individual values as they are read. */
16237 tree
16240 {
16246 /* [C++0x dcl.enum]p5:
16248 If not explicitly specified, the underlying type of a scoped
16249 enumeration type is int. */
16256 /* If this is the real definition for a previous forward reference,
16257 fill in the contents in the same object that used to be the
16258 forward reference. */
16264 /* In case of a template_decl, the only check that should be deferred
16265 to instantiation time is the comparison of underlying types. */
16267 {
16269 {
16275 }
16277 {
16283 }
16287 {
16293 }
16296 {
16298 {
16304 }
16306 }
16307 }
16311 {
16312 /* In case of error, make a dummy enum to allow parsing to
16313 continue. */
16315 {
16318 }
16320 /* enumtype may be an ENUMERAL_TYPE if this is a redefinition
16321 of an opaque enum, or an opaque enum of an already defined
16322 enumeration (C++11).
16323 In any other case, it'll be NULL_TREE. */
16325 {
16328 }
16331 /* Do not push the decl more than once. */
16334 {
16338 /* std::byte aliases anything. */
16343 }
16344 else
16350 /* The enum is considered opaque until the opening '{' of the
16351 enumerator list. */
16354 }
16361 {
16363 /* We already checked that it matches, don't change it to a different
16366 {
16369 }
16372 else
16373 {
16377 }
16378 }
16380 /* If into a template class, the returned enum is always the first
16381 declaration (opaque or not) seen. This way all the references to
16382 this type will be to the same declaration. The following ones are used
16383 only to check for definition errors. */
16386 else
16388 }
16390 /* After processing and defining all the values of an enumeration type,
16391 install their decls in the enumeration type.
16392 ENUMTYPE is the type object. */
16394 void
16396 {
16397 tree values;
16398 tree underlying_type;
16399 tree decl;
16400 tree value;
16402 tree t;
16404 bool fixed_underlying_type_p
16407 /* We built up the VALUES in reverse order. */
16410 /* For an enum defined in a template, just set the type of the values;
16411 all further processing is postponed until the template is
16412 instantiated. We need to set the type so that tsubst of a CONST_DECL
16413 works. */
16415 {
16417 values;
16421 }
16423 /* Determine the minimum and maximum values of the enumerators. */
16425 {
16429 values;
16431 {
16434 /* [dcl.enum]: Following the closing brace of an enum-specifier,
16435 each enumerator has the type of its enumeration. Prior to the
16436 closing brace, the type of each enumerator is the type of its
16437 initializing value. */
16440 /* Update the minimum and maximum values, if appropriate. */
16444 /* Figure out what the minimum and maximum values of the
16445 enumerators are. */
16452 }
16453 }
16454 else
16455 /* [dcl.enum]
16457 If the enumerator-list is empty, the underlying type is as if
16458 the enumeration had a single enumerator with value 0. */
16462 {
16463 /* Compute the number of bits require to represent all values of the
16464 enumeration. We must do this before the type of MINNODE and
16465 MAXNODE are transformed, since tree_int_cst_min_precision relies
16466 on the TREE_TYPE of the value it is passed. */
16474 /* Determine the underlying type of the enumeration.
16476 [dcl.enum]
16478 The underlying type of an enumeration is an integral type that
16479 can represent all the enumerator values defined in the
16480 enumeration. It is implementation-defined which integral type is
16481 used as the underlying type for an enumeration except that the
16482 underlying type shall not be larger than int unless the value of
16483 an enumerator cannot fit in an int or unsigned int.
16485 We use "int" or an "unsigned int" as the underlying type, even if
16486 a smaller integral type would work, unless the user has
16487 explicitly requested that we use the smallest possible type. The
16488 user can request that for all enumerations with a command line
16489 flag, or for just one enumeration with an attribute. */
16491 use_short_enum = flag_short_enums
16494 /* If the precision of the type was specified with an attribute and it
16495 was too small, give an error. Otherwise, use it. */
16497 {
16500 else
16501 {
16504 }
16505 }
16509 itk++)
16510 {
16516 }
16518 {
16519 /* DR 377
16521 IF no integral type can represent all the enumerator values, the
16522 enumeration is ill-formed. */
16527 }
16529 /* [dcl.enum]
16531 The value of sizeof() applied to an enumeration type, an object
16532 of an enumeration type, or an enumerator, is the value of sizeof()
16533 applied to the underlying type. */
16536 /* Compute the minimum and maximum values for the type.
16538 [dcl.enum]
16540 For an enumeration where emin is the smallest enumerator and emax
16541 is the largest, the values of the enumeration are the values of the
16542 underlying type in the range bmin to bmax, where bmin and bmax are,
16543 respectively, the smallest and largest values of the smallest bit-
16544 field that can store emin and emax. */
16546 /* The middle-end currently assumes that types with TYPE_PRECISION
16547 narrower than their underlying type are suitably zero or sign
16548 extended to fill their mode. Similarly, it assumes that the front
16549 end assures that a value of a particular type must be within
16550 TYPE_MIN_VALUE and TYPE_MAX_VALUE.
16552 We used to set these fields based on bmin and bmax, but that led
16553 to invalid assumptions like optimizing away bounds checking. So
16554 now we just set the TYPE_PRECISION, TYPE_MIN_VALUE, and
16555 TYPE_MAX_VALUE to the values for the mode above and only restrict
16556 the ENUM_UNDERLYING_TYPE for the benefit of diagnostics. */
16560 set_min_and_max_values_for_integral_type
16563 /* If -fstrict-enums, still constrain TYPE_MIN/MAX_VALUE. */
16566 }
16567 else
16570 /* If the enum is exported, mark the consts too. */
16575 /* Convert each of the enumerators to the type of the underlying
16576 type of the enumeration. */
16578 {
16582 /* If the enumeration type has a fixed underlying type, we
16583 already checked all of the enumerator values. */
16585 else
16588 tf_warning_or_error);
16589 /* Do not clobber shared ints. */
16591 {
16595 }
16599 }
16601 /* Fix up all variant types of this enum type. */
16608 {
16610 /* TYPE_FIELDS needs fixup. */
16612 }
16614 /* Finish debugging output for this type. */
16617 /* Each enumerator now has the type of its enumeration. Clear the cache
16618 so that this change in types doesn't confuse us later on. */
16620 }
16622 /* Finishes the enum type. This is called only the first time an
16623 enumeration is seen, be it opaque or odinary.
16624 ENUMTYPE is the type object. */
16626 void
16628 {
16630 {
16634 }
16636 /* If this is a forward declaration, there should not be any variants,
16637 though we can get a variant in the middle of an enum-specifier with
16638 wacky code like 'enum E { e = sizeof(const E*) };' */
16642 }
16644 /* Build and install a CONST_DECL for an enumeration constant of the
16645 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
16646 Apply ATTRIBUTES if available. LOC is the location of NAME.
16647 Assignment of sequential values by default is handled here. */
16649 tree
16651 location_t loc)
16652 {
16653 tree decl;
16654 tree context;
16655 tree type;
16657 /* scalar_constant_value will pull out this expression, so make sure
16658 it's folded as appropriate. */
16662 /* If the VALUE was erroneous, pretend it wasn't there; that will
16663 result in the enum being assigned the next value in sequence. */
16667 /* Remove no-op casts from the value. */
16672 {
16673 /* Validate and default VALUE. */
16675 {
16677 {
16682 }
16685 value = perform_implicit_conversion_flags
16693 {
16696 {
16698 "enumerator value for %qD must have integral or "
16701 }
16702 else
16703 {
16707 {
16711 }
16712 }
16713 }
16714 }
16716 /* Default based on previous value. */
16718 {
16720 {
16721 tree prev_value;
16723 /* C++03 7.2/4: If no initializer is specified for the first
16724 enumerator, the type is an unspecified integral
16725 type. Otherwise the type is the same as the type of the
16726 initializing value of the preceding enumerator unless the
16727 incremented value is not representable in that type, in
16728 which case the type is an unspecified integral type
16729 sufficient to contain the incremented value. */
16733 else
16734 {
16741 {
16744 {
16747 {
16753 }
16760 }
16763 else
16765 }
16768 {
16771 }
16772 }
16773 }
16774 else
16776 }
16778 /* Remove no-op casts from the value. */
16781 /* If the underlying type of the enum is fixed, check whether
16782 the enumerator values fits in the underlying type. If it
16783 does not fit, the program is ill-formed [C++0x dcl.enum]. */
16785 && value
16787 {
16792 /* Convert the value to the appropriate type. */
16794 }
16795 }
16797 /* C++ associates enums with global, function, or class declarations. */
16800 /* Build the actual enumeration constant. Note that the enumeration
16801 constants have the underlying type of the enum (if it is fixed)
16802 or the type of their initializer (if the underlying type of the
16803 enum is not fixed):
16805 [ C++0x dcl.enum ]
16807 If the underlying type is fixed, the type of each enumerator
16808 prior to the closing brace is the underlying type; if the
16809 initializing value of an enumerator cannot be represented by
16810 the underlying type, the program is ill-formed. If the
16811 underlying type is not fixed, the type of each enumerator is
16812 the type of its initializing value.
16814 If the underlying type is not fixed, it will be computed by
16815 finish_enum and we will reset the type of this enumerator. Of
16816 course, if we're processing a template, there may be no value. */
16830 {
16831 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
16832 on the TYPE_FIELDS list for `S'. (That's so that you can say
16833 things like `S::i' later.) */
16835 /* The enumerator may be getting declared outside of its enclosing
16836 class, like so:
16838 class S { public: enum E : int; }; enum S::E : int { i = 7; };
16840 For which case we need to make sure that the access of `S::i'
16841 matches the access of `S::E'. */
16845 }
16846 else
16849 /* Add this enumeration constant to the list for this type. */
16853 }
16855 /* Look for an enumerator with the given NAME within the enumeration
16856 type ENUMTYPE. This routine is used primarily for qualified name
16857 lookup into an enumerator in C++0x, e.g.,
16859 enum class Color { Red, Green, Blue };
16861 Color color = Color::Red;
16863 Returns the value corresponding to the enumerator, or
16864 NULL_TREE if no such enumerator was found. */
16865 tree
16867 {
16868 tree e;
16873 }
16875 /* Implement LANG_HOOKS_SIMULATE_ENUM_DECL. */
16877 tree
16880 {
16887 {
16892 }
16906 }
16908 /* Implement LANG_HOOKS_SIMULATE_RECORD_DECL. */
16910 tree
16913 {
16920 {
16923 }
16942 }
16943 \f
16944 /* We're defining DECL. Make sure that its type is OK. */
16946 static void
16948 {
16952 /* In a function definition, arg types must be complete. */
16959 {
16964 /* Make it return void instead. */
16967 void_type_node,
16969 else
16971 fntype = (cp_build_type_attribute_variant
16975 }
16976 else
16977 {
16981 }
16982 }
16984 /* True iff FN is an implicitly-defined default constructor. */
16986 static bool
16988 {
16992 }
16994 /* Clobber the contents of *this to let the back end know that the object
16995 storage is dead when we enter the constructor or leave the destructor. */
16997 static tree
16999 {
17000 /* Clobbering an empty base is pointless, and harmful if its one byte
17001 TYPE_SIZE overlays real data. */
17005 /* If we have virtual bases, clobber the whole object, but only if we're in
17006 charge. If we don't have virtual bases, clobber the as-base type so we
17007 don't mess with tail padding. */
17018 {
17021 }
17028 }
17030 /* Create the FUNCTION_DECL for a function definition.
17031 DECLSPECS and DECLARATOR are the parts of the declaration;
17032 they describe the function's name and the type it returns,
17033 but twisted together in a fashion that parallels the syntax of C.
17035 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
17036 DECLARATOR is really the DECL for the function we are about to
17037 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
17038 indicating that the function is an inline defined in-class.
17040 This function creates a binding context for the function body
17041 as well as setting up the FUNCTION_DECL in current_function_decl.
17043 For C++, we must first check whether that datum makes any sense.
17044 For example, "class A local_a(1,2);" means that variable local_a
17045 is an aggregate of type A, which should have a constructor
17046 applied to it with the argument list [1, 2].
17048 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
17049 or may be a BLOCK if the function has been defined previously
17050 in this translation unit. On exit, DECL_INITIAL (decl1) will be
17051 error_mark_node if the function has never been defined, or
17052 a BLOCK if the function has been defined somewhere. */
17054 bool
17056 {
17060 /* Sanity check. */
17067 else
17068 {
17073 }
17080 /* Handle gnu_inline attribute. */
17082 {
17087 }
17090 /* This is a constructor, we must ensure that any default args
17091 introduced by this definition are propagated to the clones
17092 now. The clones are used directly in overload resolution. */
17095 /* Sometimes we don't notice that a function is a static member, and
17096 build a METHOD_TYPE for it. Fix that up now. */
17100 /* Set up current_class_type, and enter the scope of the class, if
17101 appropriate. */
17107 /* Now that we have entered the scope of the class, we must restore
17108 the bindings for any template parameters surrounding DECL1, if it
17109 is an inline member template. (Order is important; consider the
17110 case where a template parameter has the same name as a field of
17111 the class.) It is not until after this point that
17112 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
17116 /* Effective C++ rule 15. */
17124 /* Make the init_value nonzero so pushdecl knows this is not tentative.
17125 error_mark_node is replaced below (in poplevel) with the BLOCK. */
17129 /* This function exists in static storage.
17130 (This does not mean `static' in the C sense!) */
17133 /* We must call push_template_decl after current_class_type is set
17134 up. (If we are processing inline definitions after exiting a
17135 class scope, current_class_type will be NULL_TREE until set above
17136 by push_nested_class.) */
17138 {
17141 {
17145 }
17147 }
17149 /* Make sure the parameter and return types are reasonable. When
17150 you declare a function, these types can be incomplete, but they
17151 must be complete when you define the function. */
17154 /* Build the return declaration for the function. */
17158 {
17159 tree resdecl;
17167 }
17169 /* Record the decl so that the function name is defined.
17170 If we already have a decl for this name, and it is a FUNCTION_DECL,
17171 use the old decl. */
17173 {
17174 /* A specialization is not used to guide overload resolution. */
17178 {
17182 /* If something went wrong when registering the declaration,
17183 use DECL1; we have to have a FUNCTION_DECL to use when
17184 parsing the body of the function. */
17185 ;
17186 else
17187 {
17188 /* Otherwise, OLDDECL is either a previous declaration
17189 of the same function or DECL1 itself. */
17196 {
17197 tree context;
17199 /* Check whether DECL1 is in an anonymous
17200 namespace. */
17202 context;
17204 {
17208 }
17212 OPT_Wmissing_declarations,
17214 }
17217 }
17218 }
17219 else
17220 {
17221 /* We need to set the DECL_CONTEXT. */
17224 }
17228 /* If #pragma weak applies, mark the decl appropriately now.
17229 The pragma only applies to global functions. Because
17230 determining whether or not the #pragma applies involves
17231 computing the mangled name for the declaration, we cannot
17232 apply the pragma until after we have merged this declaration
17233 with any previous declarations; if the original declaration
17234 has a linkage specification, that specification applies to
17235 the definition as well, and may affect the mangled name. */
17238 }
17240 /* We are now in the scope of the function being defined. */
17243 /* Save the parm names or decls from this function's declarator
17244 where store_parm_decls will find them. */
17247 /* Let the user know we're compiling this function. */
17252 /* This function may already have been parsed, in which case just
17253 return; our caller will skip over the body without parsing. */
17257 /* Initialize RTL machinery. We cannot do this until
17258 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
17259 even when processing a template; this is how we get
17260 CFUN set up, and our per-function variables initialized.
17261 FIXME factor out the non-RTL stuff. */
17265 /* Initialize the language data structures. Whenever we start
17266 a new function, we destroy temporaries in the usual way. */
17271 /* If we are (erroneously) defining a function that we have already
17272 defined before, wipe out what we knew before. */
17278 {
17281 }
17283 /* Start the statement-tree, start the tree now. */
17287 {
17288 /* We know that this was set up by `grokclassfn'. We do not
17289 wait until `store_parm_decls', since evil parse errors may
17290 never get us to that point. Here we keep the consistency
17291 between `current_class_type' and `current_class_ptr'. */
17297 cp_function_chain->x_current_class_ref
17299 /* Set this second to avoid shortcut in cp_build_indirect_ref. */
17302 /* Constructors and destructors need to know whether they're "in
17303 charge" of initializing virtual base classes. */
17306 {
17309 }
17311 {
17314 }
17315 }
17318 /* Implicitly-defined methods (like the
17319 destructor for a class in which no destructor
17320 is explicitly declared) must not be defined
17321 until their definition is needed. So, we
17322 ignore interface specifications for
17323 compiler-generated functions. */
17331 {
17338 /* This is a function in a local class in an extern inline
17339 or template function. */
17341 }
17342 /* If this function belongs to an interface, it is public.
17343 If it belongs to someone else's interface, it is also external.
17344 This only affects inlines and template instantiations. */
17346 {
17349 {
17353 && ! flag_implement_inlines
17356 /* For WIN32 we also want to put these in linkonce sections. */
17358 }
17359 else
17362 /* If this function is in an interface implemented in this file,
17363 make sure that the back end knows to emit this function
17364 here. */
17367 }
17370 {
17371 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
17372 interface, we will have both finfo->interface_unknown and
17373 finfo->interface_only set. In that case, we don't want to
17374 use the normal heuristics because someone will supply a
17375 #pragma implementation elsewhere, and deducing it here would
17376 produce a conflict. */
17381 }
17382 else
17383 {
17384 /* This is a definition, not a reference.
17385 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
17393 else
17395 }
17397 /* Determine the ELF visibility attribute for the function. We must not
17398 do this before calling "pushdecl", as we must allow "duplicate_decls"
17399 to merge any attributes appropriately. We also need to wait until
17400 linkage is set. */
17419 /* Clobbering an empty base is harmful if it overlays real data. */
17421 /* We can't clobber safely for an implicitly-defined default constructor
17422 because part of the initialization might happen before we enter the
17423 constructor, via AGGR_INIT_ZERO_FIRST (c++/68006). */
17438 }
17441 /* Like start_preparsed_function, except that instead of a
17442 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
17444 Returns true on success. If the DECLARATOR is not suitable
17445 for a function, we return false, which tells the parser to
17446 skip the entire function. */
17448 bool
17451 tree attrs)
17452 {
17453 tree decl1;
17461 /* main must return int. grokfndecl should have corrected it
17462 (and issued a diagnostic) if the user got it wrong. */
17464 integer_type_node));
17467 }
17468 \f
17469 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
17470 FN. */
17472 static bool
17474 {
17476 && !processing_template_decl
17477 /* We insert the EH_SPEC_BLOCK only in the original
17478 function; then, it is copied automatically to the
17479 clones. */
17481 /* Implicitly-generated constructors and destructors have
17482 exception specifications. However, those specifications
17483 are the union of the possible exceptions specified by the
17484 constructors/destructors for bases and members, so no
17485 unallowed exception will ever reach this function. By
17486 not creating the EH_SPEC_BLOCK we save a little memory,
17487 and we avoid spurious warnings about unreachable
17488 code. */
17491 }
17493 /* Helper function to push ARGS into the current lexical scope. DECL
17494 is the function declaration. NONPARMS is used to handle enum
17495 constants. */
17497 void
17499 {
17500 /* If we're doing semantic analysis, then we'll call pushdecl
17501 for each of these. We must do them in reverse order so that
17502 they end in the correct forward order. */
17505 tree next;
17507 {
17512 {
17513 /* If we find an enum constant or a type tag, put it aside for
17514 the moment. */
17517 }
17518 }
17520 /* Get the decls in their original chain order and record in the
17521 function. This is all and only the PARM_DECLs that were
17522 pushed into scope by the loop above. */
17524 }
17526 /* Store the parameter declarations into the current function declaration.
17527 This is called after parsing the parameter declarations, before
17528 digesting the body of the function.
17530 Also install to binding contour return value identifier, if any. */
17532 static void
17534 {
17537 /* This is a chain of any other decls that came in among the parm
17538 declarations. If a parm is declared with enum {foo, bar} x;
17539 then CONST_DECLs for foo and bar are put here. */
17543 {
17544 /* This case is when the function was defined with an ANSI prototype.
17545 The parms already have decls, so we need not do anything here
17546 except record them as in effect
17547 and complain if any redundant old-style parm decls were written. */
17551 /* Must clear this because it might contain TYPE_DECLs declared
17552 at class level. */
17556 }
17557 else
17560 /* Now store the final chain of decls for the arguments
17561 as the decl-chain of the current lexical scope.
17562 Put the enumerators in as well, at the front so that
17563 DECL_ARGUMENTS is not modified. */
17568 }
17570 \f
17571 /* Set the return value of the [cd]tor if the ABI wants that. */
17573 void
17575 {
17577 {
17578 /* Return the address of the object. */
17586 }
17587 }
17589 /* Do all the processing for the beginning of a destructor; set up the
17590 vtable pointers and cleanups for bases and members. */
17592 static void
17594 {
17595 tree compound_stmt;
17597 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
17598 issued an error message. We still want to try to process the
17599 body of the function, but initialize_vtbl_ptrs will crash if
17600 TYPE_BINFO is NULL. */
17602 {
17604 /* Make all virtual function table pointers in non-virtual base
17605 classes point to CURRENT_CLASS_TYPE's virtual function
17606 tables. */
17611 /* Clobbering an empty base is harmful if it overlays real data. */
17613 {
17617 {
17619 tree ref
17626 tf_warning_or_error);
17627 /* If the vptr is shared with some virtual nearly empty base,
17628 don't clear it if not in charge, the dtor of the virtual
17629 nearly empty base will do that later. */
17631 {
17634 {
17636 {
17638 tf_warning_or_error);
17641 }
17643 }
17644 }
17646 }
17647 else
17649 }
17651 /* And insert cleanups for our bases and members so that they
17652 will be properly destroyed if we throw. */
17654 }
17655 }
17657 /* Do the necessary processing for the beginning of a function body, which
17658 in this case includes member-initializers, but not the catch clauses of
17659 a function-try-block. Currently, this means opening a binding level
17660 for the member-initializers (in a ctor), member cleanups (in a dtor),
17661 and capture proxies (in a lambda operator()). */
17663 tree
17665 {
17671 else
17672 /* Always keep the BLOCK node associated with the outermost pair of
17673 curly braces of a function. These are needed for correct
17674 operation of dwarfout.c. */
17685 }
17687 /* Do the processing for the end of a function body. Currently, this means
17688 closing out the cleanups for fully-constructed bases and members, and in
17689 the case of the destructor, deleting the object if desired. Again, this
17690 is only meaningful for [cd]tors, since they are the only functions where
17691 there is a significant distinction between the main body and any
17692 function catch clauses. Handling, say, main() return semantics here
17693 would be wrong, as flowing off the end of a function catch clause for
17694 main() would also need to return 0. */
17696 void
17698 {
17702 /* Close the block. */
17710 }
17712 /* Given a function, returns the BLOCK corresponding to the outermost level
17713 of curly braces, skipping the artificial block created for constructor
17714 initializers. */
17716 tree
17718 {
17728 }
17730 /* If FNDECL is a class's key method, add the class to the list of
17731 keyed classes that should be emitted. */
17733 static void
17735 {
17739 {
17743 }
17744 }
17746 /* Attempt to add a fix-it hint to RICHLOC suggesting the insertion
17747 of "return *this;" immediately before its location, using FNDECL's
17748 first statement (if any) to give the indentation, if appropriate. */
17750 static void
17752 {
17759 indent);
17760 }
17762 /* This function carries out the subset of finish_function operations needed
17763 to emit the compiler-generated outlined helper functions used by the
17764 coroutines implementation. */
17766 static void
17768 {
17769 /* This is a partial set of the operations done by finish_function()
17770 plus emitting the result. */
17780 /* We must start each function with a clear fold cache. */
17785 /* This function has coroutine IFNs that we should handle in middle
17786 end lowering. */
17790 }
17792 /* Finish up a function declaration and compile that function
17793 all the way to assembler language output. The free the storage
17794 for the function definition. INLINE_P is TRUE if we just
17795 finished processing the body of an in-class inline function
17796 definition. (This processing will have taken place after the
17797 class definition is complete.) */
17799 tree
17801 {
17806 && !processing_template_decl
17810 /* When we get some parse errors, we can end up without a
17811 current_function_decl, so cope. */
17825 /* TREE_READONLY (fndecl) = 1;
17826 This caused &foo to be of type ptr-to-const-function
17827 which then got a warning when stored in a ptr-to-function variable. */
17830 /* The current function is being defined, so its DECL_INITIAL should
17831 be set, and unless there's a multiple definition, it should be
17832 error_mark_node. */
17836 {
17837 /* Only try to emit the coroutine outlined helper functions if the
17838 transforms succeeded. Otherwise, treat errors in the same way as
17839 a regular function. */
17842 /* We should handle coroutine IFNs in middle end lowering. */
17845 /* Do not try to process the ramp's EH unless outlining succeeded. */
17849 current_eh_spec_block);
17850 }
17851 else
17852 /* For a cloned function, we've already got all the code we need;
17853 there's no need to add any extra bits. */
17855 {
17856 /* Make it so that `main' always returns 0 by default. */
17863 current_eh_spec_block);
17864 }
17866 /* If we're saving up tree structure, tie off the function now. */
17871 /* If this function can't throw any exceptions, remember that. */
17874 && !flag_non_call_exceptions
17879 /* This must come after expand_function_end because cleanups might
17880 have declarations (from inline functions) that need to go into
17881 this function's blocks. */
17883 /* If the current binding level isn't the outermost binding level
17884 for this function, either there is a bug, or we have experienced
17885 syntax errors and the statement tree is malformed. */
17887 {
17888 /* Make sure we have already experienced errors. */
17891 /* Throw away the broken statement tree and extra binding
17892 levels. */
17896 {
17899 else
17901 }
17902 }
17905 /* Statements should always be full-expressions at the outermost set
17906 of curly braces for a function. */
17909 /* If there are no return statements in a function with auto return type,
17910 the return type is void. But if the declared type is something like
17911 auto*, this is an error. */
17914 {
17916 && !current_function_returns_value
17918 {
17919 /* We haven't applied return type deduction because we haven't
17920 seen any return statements. Do that now. */
17924 adc_return_type);
17928 }
17931 {
17936 }
17937 }
17939 /* Remember that we were in class scope. */
17944 {
17948 }
17950 // If this is a concept, check that the definition is reasonable.
17959 /* Complain if there's just no return statement. */
17966 /* Don't complain if we abort or throw. */
17967 && !current_function_returns_abnormally
17968 /* Don't complain if there's an infinite loop. */
17969 && !current_function_infinite_loop
17970 /* Don't complain if we are declared noreturn. */
17974 /* Structor return values (if any) are set by the compiler. */
17978 {
17980 /* Potentially add a "return *this;" fix-it hint for
17981 assignment operators. */
17983 {
17986 && current_class_ref
17987 && same_type_ignoring_top_level_qualifiers_p
17993 }
17999 "no return statement in function returning "
18002 }
18004 /* Lambda closure members are implicitly constexpr if possible. */
18008 = ((processing_template_decl
18012 /* Save constexpr function body before it gets munged by
18013 the NRV transformation. */
18016 /* Invoke the pre-genericize plugin before we start munging things. */
18020 /* Perform delayed folding before NRV transformation. */
18026 /* Set up the named return value optimization, if we can. Candidate
18027 variables are selected in check_return_expr. */
18029 {
18031 tree outer;
18034 /* This is only worth doing for fns that return in memory--and
18035 simpler, since we don't have to worry about promoted modes. */
18037 /* Only allow this for variables declared in the outer scope of
18038 the function so we know that their lifetime always ends with a
18039 return; see g++.dg/opt/nrv6.C. We could be more flexible if
18040 we were to do this optimization in tree-ssa. */
18046 }
18048 /* Must mark the RESULT_DECL as being in this function. */
18051 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
18052 to the FUNCTION_DECL node itself. */
18055 /* Store the end of the function, so that we get good line number
18056 info for the epilogue. */
18059 /* Complain about parameters that are only set, but never otherwise used. */
18061 && !processing_template_decl
18064 {
18065 tree decl;
18068 decl;
18082 OPT_Wunused_but_set_parameter,
18085 }
18087 /* Complain about locally defined typedefs that are not used in this
18088 function. */
18091 /* Possibly warn about unused parameters. */
18093 && !processing_template_decl
18097 /* Genericize before inlining. */
18103 /* Emit the resumer and destroyer functions now, providing that we have
18104 not encountered some fatal error. */
18106 {
18109 }
18111 cleanup:
18112 /* We're leaving the context of this function, so zap cfun. It's still in
18113 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
18117 /* If this is an in-class inline definition, we may have to pop the
18118 bindings for the template parameters that we added in
18119 maybe_begin_member_template_processing when start_function was
18120 called. */
18124 /* Leave the scope of the class. */
18130 /* Clean up. */
18135 }
18136 \f
18137 /* Create the FUNCTION_DECL for a function definition.
18138 DECLSPECS and DECLARATOR are the parts of the declaration;
18139 they describe the return type and the name of the function,
18140 but twisted together in a fashion that parallels the syntax of C.
18142 This function creates a binding context for the function body
18143 as well as setting up the FUNCTION_DECL in current_function_decl.
18145 Returns a FUNCTION_DECL on success.
18147 If the DECLARATOR is not suitable for a function (it defines a datum
18148 instead), we return 0, which tells yyparse to report a parse error.
18150 May return void_type_node indicating that this method is actually
18151 a friend. See grokfield for more details.
18153 Came here with a `.pushlevel' .
18155 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
18156 CHANGES TO CODE IN `grokfield'. */
18158 tree
18161 {
18171 /* Pass friends other than inline friend functions back. */
18176 {
18181 }
18185 /* p1779 ABI-Isolation makes inline not a default for in-class
18186 definitions in named module purview. If the user explicitly
18187 made it inline, grokdeclarator will already have done the right
18188 things. */
18190 || flag_module_implicit_inline
18191 /* Lambda's operator function remains inline. */
18193 /* If the user explicitly asked for this to be inline, we don't
18194 need to do more, but more importantly we want to warn if we
18195 can't inline it. */
18197 {
18201 /* It's ok if we can't inline this. */
18203 }
18205 /* We process method specializations in finish_struct_1. */
18207 {
18208 /* Avoid calling decl_spec_seq... until we have to. */
18213 }
18216 {
18219 }
18225 }
18226 \f
18228 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
18229 we can lay it out later, when and if its type becomes complete.
18231 Also handle constexpr variables where the initializer involves
18232 an unlowered PTRMEM_CST because the class isn't complete yet. */
18234 void
18236 {
18239 /* Keep track of variables with incomplete types. */
18242 {
18250 /* RTTI TD entries are created while defining the type_info. */
18253 {
18256 }
18260 {
18261 /* When the outermost open class is complete we can resolve any
18262 pointers-to-members. */
18266 }
18267 }
18268 }
18270 /* Called when a class type (given by TYPE) is defined. If there are
18271 any existing VAR_DECLs whose type has been completed by this
18272 declaration, update them now. */
18274 void
18276 {
18281 {
18283 {
18290 {
18291 /* Complete the type of the variable. */
18296 }
18298 /* Remove this entry from the list. */
18300 }
18301 else
18302 ix++;
18303 }
18304 }
18306 /* If DECL is of a type which needs a cleanup, build and return an
18307 expression to perform that cleanup here. Return NULL_TREE if no
18308 cleanup need be done. DECL can also be a _REF when called from
18309 split_nonconstant_init_1. */
18311 tree
18313 {
18314 tree type;
18315 tree attr;
18316 tree cleanup;
18318 /* Assume no cleanup is required. */
18324 /* Handle "__attribute__((cleanup))". We run the cleanup function
18325 before the destructor since the destructor is what actually
18326 terminates the lifetime of the object. */
18329 else
18332 {
18333 tree id;
18334 tree fn;
18335 tree arg;
18337 /* Get the name specified by the user for the cleanup function. */
18339 /* Look up the name to find the cleanup function to call. It is
18340 important to use lookup_name here because that is what is
18341 used in c-common.cc:handle_cleanup_attribute when performing
18342 initial checks on the attribute. Note that those checks
18343 include ensuring that the function found is not an overloaded
18344 function, or an object with an overloaded call operator,
18345 etc.; we can rely on the fact that the function found is an
18346 ordinary FUNCTION_DECL. */
18354 }
18355 /* Handle ordinary C++ destructors. */
18358 {
18360 tree addr;
18361 tree call;
18365 else
18379 else
18381 }
18383 /* build_delete sets the location of the destructor call to the
18384 current location, even though the destructor is going to be
18385 called later, at the end of the current scope. This can lead to
18386 a "jumpy" behavior for users of debuggers when they step around
18387 the end of the block. So let's unset the location of the
18388 destructor call instead. */
18396 /* Treat objects with destructors as used; the destructor may do
18397 something substantive. */
18406 }
18408 \f
18409 /* Return the FUNCTION_TYPE that corresponds to MEMFNTYPE, which can be a
18410 FUNCTION_DECL, METHOD_TYPE, FUNCTION_TYPE, pointer or reference to
18411 METHOD_TYPE or FUNCTION_TYPE, or pointer to member function. */
18413 tree
18415 {
18416 tree fntype;
18417 tree args;
18430 fntype = (cp_build_type_attribute_variant
18434 }
18436 /* DECL was originally constructed as a non-static member function,
18437 but turned out to be static. Update it accordingly. */
18439 void
18441 {
18454 }
18456 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
18457 one of the language-independent trees. */
18459 enum cp_tree_node_structure_enum
18461 {
18463 {
18481 }
18482 }
18484 bool
18486 {
18487 /* A missing noreturn is ok for the `main' function. */
18489 }
18491 /* Return the decl used to identify the COMDAT group into which DECL should
18492 be placed. */
18494 tree
18496 {
18497 /* Virtual tables, construction virtual tables, and virtual table
18498 tables all go in a single COMDAT group, named after the primary
18499 virtual table. */
18502 /* For all other DECLs, the COMDAT group is the mangled name of the
18503 declaration itself. */
18504 else
18505 {
18507 {
18508 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
18509 into the same section as the target function. In that case
18510 we must return target's name. */
18516 else
18518 }
18519 }
18522 }
18524 /* Returns the return type for FN as written by the user, which may include
18525 a placeholder for a deduced return type. */
18527 tree
18529 {
18535 }
18537 /* Returns true iff DECL is a variable or function declared with an auto type
18538 that has not yet been deduced to a real type. */
18540 bool
18542 {
18549 }
18551 /* Complain if DECL has an undeduced return type. */
18553 bool
18555 {
18557 {
18564 }
18566 }
18568 /* Create a representation of the explicit-specifier with
18569 constant-expression of EXPR. COMPLAIN is as for tsubst. */
18571 tree
18573 {
18578 /* Wait for instantiation, tsubst_function_decl will handle it. */
18585 }