| blob | 375385e0013348e473283eef7ee19d7b6d408266 |
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 };
100 static tree check_special_function_return_type
109 /* The following symbols are subsumed in the cp_global_trees array, and
110 listed here individually for documentation purposes.
112 C++ extensions
113 tree wchar_decl_node;
115 tree vtable_entry_type;
116 tree delta_type_node;
117 tree __t_desc_type_node;
119 tree class_type_node;
120 tree unknown_type_node;
122 Array type `vtable_entry_type[]'
124 tree vtbl_type_node;
125 tree vtbl_ptr_type_node;
127 Namespaces,
129 tree std_node;
130 tree abi_node;
132 A FUNCTION_DECL which can call `abort'. Not necessarily the
133 one that the user will declare, but sufficient to be called
134 by routines that want to abort the program.
136 tree abort_fndecl;
138 Used by RTTI
139 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
140 tree tinfo_var_id; */
144 /* A list of objects which have constructors or destructors
145 which reside in namespace scope. The decl is stored in
146 the TREE_VALUE slot and the initializer is stored
147 in the TREE_PURPOSE slot. */
148 tree static_aggregates;
150 /* Like static_aggregates, but for thread_local variables. */
151 tree tls_aggregates;
153 /* A hash-map mapping from variable decls to the dynamic initializer for
154 the decl. This is currently only used by OpenMP. */
157 /* -- end of C++ */
159 /* A node for the integer constant 2. */
161 tree integer_two_node;
163 /* vector of static decls. */
166 /* vector of keyed classes. */
169 /* Used only for jumps to as-yet undefined labels, since jumps to
170 defined labels can have their validity checked immediately. */
174 /* The binding level to which this entry is *currently* attached.
175 This is initially the binding level in which the goto appeared,
176 but is modified as scopes are closed. */
178 /* The head of the names list that was current when the goto appeared,
179 or the inner scope popped. These are the decls that will *not* be
180 skipped when jumping to the label. */
181 tree names_in_scope;
182 /* The location of the goto, for error reporting. */
183 location_t o_goto_locus;
184 /* True if an OpenMP structured block scope has been closed since
185 the goto appeared. This means that the branch from the label will
186 illegally exit an OpenMP scope. */
188 };
190 /* A list of all LABEL_DECLs in the function that have names. Here so
191 we can clear out their names' definitions at the end of the
192 function, and so we can check the validity of jumps to these labels. */
202 /* The binding level to which the label is *currently* attached.
203 This is initially set to the binding level in which the label
204 is defined, but is modified as scopes are closed. */
207 /* The head of the names list that was current when the label was
208 defined, or the inner scope popped. These are the decls that will
209 be skipped when jumping to the label. */
210 tree names_in_scope;
212 /* A vector of all decls from all binding levels that would be
213 crossed by a backward branch to the label. */
216 /* A list of uses of the label, before the label is defined. */
219 /* The following bits are set after the label is defined, and are
220 updated as scopes are popped. They indicate that a jump to the
221 label will illegally enter a scope of the given flavor. */
228 };
230 #define named_labels cp_function_chain->x_named_labels
231 \f
232 /* The number of function bodies which we are currently processing.
233 (Zero if we are at namespace scope, one inside the body of a
234 function, two inside the body of a function in a local class, etc.) */
237 /* Whether the exception-specifier is part of a function type (i.e. C++17). */
240 /* States indicating how grokdeclarator() should handle declspecs marked
241 with __attribute__((deprecated)). An object declared as
242 __attribute__((deprecated)) suppresses warnings of uses of other
243 deprecated items. */
246 \f
247 /* A list of VAR_DECLs whose type was incomplete at the time the
248 variable was declared. */
251 tree decl;
252 tree incomplete_type;
253 };
257 \f
258 /* Returns the kind of template specialization we are currently
259 processing, given that it's declaration contained N_CLASS_SCOPES
260 explicit scope qualifications. */
262 tmpl_spec_kind
264 {
270 /* Scan through the template parameter scopes. */
274 {
275 /* If we see a specialization scope inside a parameter scope,
276 then something is wrong. That corresponds to a declaration
277 like:
279 template <class T> template <> ...
281 which is always invalid since [temp.expl.spec] forbids the
282 specialization of a class member template if the enclosing
283 class templates are not explicitly specialized as well. */
285 {
288 else
290 }
295 }
297 /* Handle explicit instantiations. */
299 {
301 /* We've seen a template parameter list during an explicit
302 instantiation. For example:
304 template <class T> template void f(int);
306 This is erroneous. */
308 else
310 }
313 /* We've not seen enough template headers to match all the
314 specialized classes present. For example:
316 template <class T> void R<T>::S<T>::f(int);
318 This is invalid; there needs to be one set of template
319 parameters for each class. */
322 /* We're processing a non-template declaration (even though it may
323 be a member of a template class.) For example:
325 template <class T> void S<T>::f(int);
327 The `class T' matches the `S<T>', leaving no template headers
328 corresponding to the `f'. */
331 /* We've got too many template headers. For example:
333 template <> template <class T> void f (T);
335 There need to be more enclosing classes. */
337 else
338 /* This must be a template. It's of the form:
340 template <class T> template <class U> void S<T>::f(U);
342 This is a specialization if the innermost level was a
343 specialization; otherwise it's just a definition of the
344 template. */
346 }
348 /* Exit the current scope. */
350 void
352 {
354 }
356 /* When a label goes out of scope, check to see if that label was used
357 in a valid manner, and issue any appropriate warnings or errors. */
359 static void
361 {
363 {
365 {
366 location_t location;
370 /* FIXME want (LOCATION_FILE (input_location), (line)0) */
371 /* Avoid crashing later. */
373 }
374 else
376 }
377 }
379 /* Helper function to sort named label entries in a vector by DECL_UID. */
381 static int
383 {
387 /* DECL_UIDs can never be equal. */
389 }
391 /* At the end of a function, all labels declared within the function
392 go out of scope. BLOCK is the top-level block for the
393 function. */
395 static void
397 {
401 /* We need to add the labels to the block chain, so debug
402 information is emitted. But, we want the order to be stable so
403 need to sort them first. Otherwise the debug output could be
404 randomly ordered. I guess it's mostly stable, unless the hash
405 table implementation changes. */
410 {
417 }
422 {
429 }
430 }
432 /* At the end of a block with local labels, restore the outer definition. */
434 static void
436 {
444 else
445 {
448 }
450 }
452 /* The following two routines are used to interface to Objective-C++.
453 The binding level is purposely treated as an opaque type. */
457 {
459 }
461 /* The following routine is used by the NeXT-style SJLJ exceptions;
462 variables get marked 'volatile' so as to not be clobbered by
463 _setjmp()/_longjmp() calls. All variables in the current scope,
464 as well as parent scopes up to (but not including) ENCLOSING_BLK
465 shall be thusly marked. */
467 void
469 {
475 {
476 tree decl;
481 /* Do not climb up past the current function. */
484 }
485 }
487 /* True if B is the level for the condition of a constexpr if. */
489 static bool
491 {
495 }
497 /* True if B is the level for the condition of a consteval if. */
499 static bool
501 {
505 }
507 /* Update data for defined and undefined labels when leaving a scope. */
509 int
511 {
516 {
517 tree decl;
519 /* ENT->NAMES_IN_SCOPE may contain a mixture of DECLs and
520 TREE_LISTs representing OVERLOADs, so be careful. */
530 {
551 }
552 }
554 {
559 {
564 }
565 }
568 }
570 /* Saved errorcount to avoid -Wunused-but-set-{parameter,variable} warnings
571 when errors were reported, except for -Werror-unused-but-set-*. */
574 /* Exit a binding level.
575 Pop the level off, and restore the state of the identifier-decl mappings
576 that were in effect when this level was entered.
578 If KEEP == 1, this level had explicit declarations, so
579 and create a "block" (a BLOCK node) for the level
580 to record its declarations and subblocks for symbol table output.
582 If FUNCTIONBODY is nonzero, this level is the body of a function,
583 so create a block as if KEEP were set and also clear out all
584 label names.
586 If REVERSE is nonzero, reverse the order of decls before putting
587 them into the BLOCK. */
589 tree
591 {
592 tree link;
593 /* The chain of decls was accumulated in reverse order.
594 Put it into forward order, just for cleanliness. */
595 tree decls;
596 tree subblocks;
597 tree block;
598 tree decl;
599 scope_kind kind;
602 restart:
615 /* We used to use KEEP == 2 to indicate that the new block should go
616 at the beginning of the list of blocks at this binding level,
617 rather than the end. This hack is no longer used. */
623 /* Any uses of undefined labels, and any defined labels, now operate
624 under constraints of next binding contour. */
629 /* Get the decls in the order they were written.
630 Usually current_binding_level->names is in reverse order.
631 But parameter decls were previously put in forward order. */
635 {
638 }
640 /* If there were any declarations or structure tags in that level,
641 or if this level is a function body,
642 create a BLOCK to record them for the life of this function. */
644 /* Avoid function body block if possible. */
650 {
653 }
655 /* In each subblock, record that this is its superior. */
660 /* Before we remove the declarations first check for unused variables. */
665 {
666 /* There are cases where D itself is a TREE_LIST. See in
667 push_local_binding where the list of decls returned by
668 getdecls is built. */
675 /* For structured bindings, consider only real variables, not
676 subobjects. */
684 {
686 {
689 OPT_Wunused_variable,
691 else
694 }
696 // For -Wunused-but-set-variable leave references alone.
699 {
704 else
706 OPT_Wunused_but_set_variable,
709 }
710 }
711 }
713 /* Remove declarations for all the DECLs in this level. */
715 {
716 tree name;
718 {
722 }
723 else
724 {
727 }
729 /* Remove the binding. */
732 else
734 }
736 /* Restore the IDENTIFIER_TYPE_VALUEs. */
741 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
742 list if a `using' declaration put them there. The debugging
743 back ends won't understand OVERLOAD, so we remove them here.
744 Because the BLOCK_VARS are (temporarily) shared with
745 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
746 popped all the bindings. Also remove undeduced 'auto' decls,
747 which LTO doesn't understand, and can't have been used by anything. */
749 {
753 {
755 || (!processing_template_decl
758 else
760 }
761 }
763 /* If the level being exited is the top level of a function,
764 check over all the labels. */
766 {
768 {
769 /* Since this is the top level block of a function, the vars are
770 the function's parameters. Don't leave them in the BLOCK
771 because they are found in the FUNCTION_DECL instead. */
774 }
775 else
777 }
781 {
782 tree stmt;
784 /* If this is a temporary binding created for a cleanup, then we'll
785 have pushed a statement list level. Pop that, create a new
786 BIND_EXPR for the block, and insert it into the stream. */
790 }
794 {
795 /* The current function is being defined, so its DECL_INITIAL
796 should be error_mark_node. */
800 {
802 {
805 }
806 else
808 }
809 }
811 current_binding_level->blocks
814 /* If we did not make a block for the level just exited,
815 any blocks made for inner levels
816 (since they cannot be recorded as subblocks in that level)
817 must be carried forward so they will later become subblocks
818 of something else. */
820 current_binding_level->blocks
823 /* Each and every BLOCK node created here in `poplevel' is important
824 (e.g. for proper debugging information) so if we created one
825 earlier, mark it as "used". */
829 /* All temporary bindings created for cleanups are popped silently. */
834 }
836 /* Call wrapup_globals_declarations for the globals in NAMESPACE. */
837 /* Diagnose odr-used extern inline variables without definitions
838 in the current TU. */
840 int
842 {
844 {
846 {
856 OPT_Wunused_function,
865 }
867 /* Clear out the list, so we don't rescan next time. */
870 /* Write out any globals that need to be output. */
873 }
875 }
876 \f
877 /* In C++, you don't have to write `struct S' to refer to `S'; you
878 can just use `S'. We accomplish this by creating a TYPE_DECL as
879 if the user had written `typedef struct S S'. Create and return
880 the TYPE_DECL for TYPE. */
882 tree
884 {
885 tree decl;
889 /* There are other implicit type declarations, like the one *within*
890 a class that allows you to write `S::S'. We must distinguish
891 amongst these. */
897 }
899 /* Function-scope local entities that need discriminators. Each entry
900 is a {decl,name} pair. VAR_DECLs for anon unions get their name
901 smashed, so we cannot rely on DECL_NAME. */
905 /* Determine the mangling discriminator of local DECL. There are
906 generally very few of these in any particular function. */
908 void
910 {
919 {
927 {
933 /* Replace the saved decl. */
937 }
938 }
941 {
945 }
946 }
948 \f
950 /* Returns true if functions FN1 and FN2 have equivalent trailing
951 requires clauses. */
953 static bool
955 {
956 /* In the concepts TS, the combined constraints are compared. */
960 {
966 }
968 /* Compare only trailing requirements. */
974 /* Substitution is needed when friends are involved. */
979 }
981 /* Subroutine of duplicate_decls: return truthvalue of whether
982 or not types of these decls match.
984 For C++, we must compare the parameter list so that `int' can match
985 `int&' in a parameter position, but `int&' is not confused with
986 `const int&'. */
988 int
990 {
997 /* If the two DECLs are not even the same kind of thing, we're not
998 interested in their types. */
1004 {
1005 /* Specializations of different templates are different functions
1006 even if they have the same type. */
1021 /* A new declaration doesn't match a built-in one unless it
1022 is also extern "C". */
1032 /* A declaration with deduced return type should use its pre-deduction
1033 type for declaration matching. */
1041 {
1044 {
1048 }
1049 else
1050 types_match =
1056 }
1057 else
1060 /* Two function declarations match if either has a requires-clause
1061 then both have a requires-clause and their constraints-expressions
1062 are equivalent. */
1066 /* The decls dont match if they correspond to two different versions
1067 of the same function. Disallow extern "C" functions to be
1068 versions for now. */
1072 && record_versions
1077 }
1079 {
1089 /* Two template types match if they are the same. Otherwise, compare
1090 the underlying declarations. */
1093 else
1095 }
1096 else
1097 {
1098 /* Need to check scope for variable declaration (VAR_DECL).
1099 For typedef (TYPE_DECL), scope is ignored. */
1102 /* [dcl.link]
1103 Two declarations for an object with C language linkage
1104 with the same name (ignoring the namespace that qualify
1105 it) that appear in different namespace scopes refer to
1106 the same object. */
1116 else
1119 COMPARE_REDECLARATION);
1120 }
1123 }
1125 /* Mark DECL as versioned if it isn't already. */
1127 static void
1129 {
1131 {
1133 /* If DECL_ASSEMBLER_NAME has already been set, re-mangle
1134 to include the version marker. */
1137 }
1138 }
1140 /* NEWDECL and OLDDECL have identical signatures. If they are
1141 different versions adjust them and return true.
1142 If RECORD is set to true, record function versions. */
1144 bool
1146 {
1152 {
1155 }
1159 {
1160 /* Unfortunately, we can get here before pushdecl naturally calls
1161 push_local_extern_decl_alias, so we need to call it directly. */
1166 }
1172 }
1174 /* If NEWDECL is `static' and an `extern' was seen previously,
1175 warn about it. OLDDECL is the previous declaration.
1177 Note that this does not apply to the C++ case of declaring
1178 a variable `extern const' and then later `const'.
1180 Don't complain about built-in functions, since they are beyond
1181 the user's control. */
1183 void
1185 {
1192 /* Don't get confused by static member functions; that's a different
1193 use of `static'. */
1198 /* If the old declaration was `static', or the new one isn't, then
1199 everything is OK. */
1203 /* It's OK to declare a builtin function as `static'. */
1208 auto_diagnostic_group d;
1213 }
1215 /* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1216 function templates. If their exception specifications do not
1217 match, issue a diagnostic. */
1219 static void
1221 tree old_decl)
1222 {
1226 /* Two default specs are equivalent, don't force evaluation. */
1232 {
1235 }
1239 /* [except.spec]
1241 If any declaration of a function has an exception-specification,
1242 all declarations, including the definition and an explicit
1243 specialization, of that function shall have an
1244 exception-specification with the same set of type-ids. */
1248 {
1253 auto_diagnostic_group d;
1257 /* We used to silently permit mismatched eh specs with
1258 -fno-exceptions, so make them a pedwarn now. */
1260 else
1265 }
1266 }
1268 /* Return true if OLD_DECL and NEW_DECL agree on constexprness.
1269 Otherwise issue diagnostics. */
1271 static bool
1273 {
1281 {
1287 }
1289 {
1290 /* With -fimplicit-constexpr, ignore changes in the constexpr
1291 keyword. */
1297 {
1298 /* Hide a built-in declaration. */
1304 }
1305 /* 7.1.5 [dcl.constexpr]
1306 Note: An explicit specialization can differ from the template
1307 declaration with respect to the constexpr specifier. */
1317 "redeclaration %qD differs in %qs "
1319 kind);
1323 }
1325 }
1327 // If OLDDECL and NEWDECL are concept declarations with the same type
1328 // (i.e., and template parameters), but different requirements,
1329 // emit diagnostics and return true. Otherwise, return false.
1332 {
1344 {
1349 {
1352 }
1353 }
1355 }
1357 /* DECL is a redeclaration of a function or function template. If
1358 it does have default arguments issue a diagnostic. Note: this
1359 function is used to enforce the requirements in C++11 8.3.6 about
1360 no default arguments in redeclarations. */
1362 static void
1364 {
1370 {
1372 "redeclaration of %q#D may not have default "
1375 }
1376 }
1378 /* NEWDECL is a redeclaration of a function or function template OLDDECL,
1379 in any case represented as FUNCTION_DECLs (the DECL_TEMPLATE_RESULTs of
1380 the TEMPLATE_DECLs in case of function templates). This function is used
1381 to enforce the final part of C++17 11.3.6/4, about a single declaration:
1382 "If a friend declaration specifies a default argument expression, that
1383 declaration shall be a definition and shall be the only declaration of
1384 the function or function template in the translation unit." */
1386 static void
1388 {
1398 {
1399 auto_diagnostic_group d;
1401 "friend declaration of %q#D specifies default "
1406 }
1407 }
1409 /* Merge tree bits that correspond to attributes noreturn, nothrow,
1410 const, malloc, and pure from NEWDECL with those of OLDDECL. */
1412 static void
1414 {
1427 }
1429 #define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn) \
1431 DECL_ATTRIBUTES (fn)))
1433 /* A subroutine of duplicate_decls. Emits a diagnostic when newdecl
1434 ambiguates olddecl. Returns true if an error occurs. */
1436 static bool
1438 {
1442 /* Function template declarations can be differentiated by parameter
1443 and return type. */
1448 {
1449 /* ... and also by their template-heads and requires-clauses. */
1452 {
1457 }
1459 /* FIXME: The types are the same but the are differences
1460 in either the template heads or function requirements.
1461 We should be able to diagnose a set of common errors
1462 stemming from these declarations. For example:
1464 template<typename T> requires C void f(...);
1465 template<typename T> void f(...) requires C;
1467 These are functionally equivalent but not equivalent. */
1468 }
1471 }
1473 /* OLD_PARMS is the innermost set of template parameters for some template
1474 declaration, and NEW_PARMS is the corresponding set of template parameters
1475 for a redeclaration of that template. Merge the default arguments within
1476 these two sets of parameters. CLASS_P is true iff the template in
1477 question is a class template. */
1479 bool
1481 {
1485 {
1491 {
1492 auto_diagnostic_group d;
1497 }
1499 /* Update the previous template parameters (which are the ones
1500 that will really count) with the new default value. */
1503 /* Update the new parameters, too; they'll be used as the
1504 parameters for any members. */
1506 }
1508 }
1510 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1511 If the redeclaration is invalid, a diagnostic is issued, and the
1512 error_mark_node is returned. Otherwise, OLDDECL is returned.
1514 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1515 returned.
1517 HIDING is true if the new decl is being hidden. WAS_HIDDEN is true
1518 if the old decl was hidden.
1520 Hidden decls can be anticipated builtins, injected friends, or
1521 (coming soon) injected from a local-extern decl. */
1523 tree
1525 {
1529 tree new_template_info;
1538 /* If either the type of the new decl or the type of the old decl is an
1539 error_mark_node, then that implies that we have already issued an
1540 error (earlier) for some bogus type specification, and in that case,
1541 it is rather pointless to harass the user with yet more error message
1542 about the same declaration, so just pretend the types match here. */
1547 /* Check for redeclaration and other discrepancies. */
1550 {
1552 {
1553 /* Avoid warnings redeclaring built-ins which have not been
1554 explicitly declared. */
1556 {
1560 OPT_Wbuiltin_declaration_mismatch,
1562 newdecl);
1564 }
1566 /* If you declare a built-in or predefined function name as static,
1567 the old definition is overridden, but optionally warn this was a
1568 bad choice of name. */
1570 {
1572 OPT_Wshadow,
1576 /* Discard the old built-in function. */
1578 }
1579 /* If the built-in is not ansi, then programs can override
1580 it even globally without an error. */
1585 else
1587 "declaration of %q#D conflicts with built-in "
1590 }
1592 {
1593 /* Avoid warnings redeclaring built-ins which have not been
1594 explicitly declared. */
1596 {
1599 /* A new declaration doesn't match a built-in one unless it
1600 is also extern "C". */
1610 {
1613 /* FILE, tm types are not known at the time
1614 we create the builtins. */
1620 {
1627 {
1637 }
1639 }
1643 next_arg:;
1644 }
1647 OPT_Wbuiltin_declaration_mismatch,
1648 "declaration of %q#D conflicts with built-in "
1650 }
1655 {
1656 /* Don't really override olddecl for __* prefixed builtins
1657 except for __[^b]*_chk, the compiler might be using those
1658 explicitly. */
1660 {
1671 {
1673 {
1675 "definition of %q#D ambiguates built-in "
1678 }
1679 auto_diagnostic_group d;
1681 "new declaration %q#D ambiguates built-in"
1687 }
1688 }
1690 /* A near match; override the builtin. */
1694 OPT_Wbuiltin_declaration_mismatch,
1695 "new declaration %q#D ambiguates built-in "
1697 else
1702 }
1703 else
1704 /* Discard the old built-in function. */
1707 /* Replace the old RTL to avoid problems with inlining. */
1709 }
1710 else
1711 {
1712 /* Even if the types match, prefer the new declarations type
1713 for built-ins which have not been explicitly declared,
1714 for exception lists, etc... */
1721 }
1723 /* If a function is explicitly declared "throw ()", propagate that to
1724 the corresponding builtin. */
1726 && was_hidden
1729 {
1734 }
1736 /* Whether or not the builtin can throw exceptions has no
1737 bearing on this declarator. */
1741 {
1742 /* If a builtin function is redeclared as `static', merge
1743 the declarations, but make the original one static. */
1747 /* Make the old declaration consistent with the new one so
1748 that all remnants of the builtin-ness of this function
1749 will be banished. */
1752 }
1753 }
1755 {
1756 /* C++ Standard, 3.3, clause 4:
1757 "[Note: a namespace name or a class template name must be unique
1758 in its declarative region (7.3.2, clause 14). ]" */
1779 {
1780 /* One is a function and the other is a template
1781 function. */
1785 /* There can only be one! */
1789 "literal operator %q#D conflicts with"
1793 "raw literal operator %q#D conflicts with"
1795 else
1800 }
1806 /* One is an implicit typedef, that's ok. */
1813 }
1815 {
1817 /* These are certainly not duplicate declarations; they're
1818 from different scopes. */
1822 {
1826 /* The name of a class template may not be declared to refer to
1827 any other template, class, function, object, namespace, value,
1828 or type in the same scope. */
1831 {
1837 }
1841 {
1845 }
1849 }
1851 {
1853 {
1856 newdecl);
1860 }
1861 /* For function versions, params and types match, but they
1862 are not ambiguous. */
1865 // The functions have the same parameter types.
1868 // And the same constraints.
1870 {
1876 }
1877 else
1879 }
1880 else
1881 {
1886 }
1887 }
1890 {
1891 /* OMP UDRs are never duplicates. */
1898 }
1908 /* It's OK to have a template specialization and a non-template
1909 with the same type, or to have specializations of two
1910 different templates with the same type. Note that if one is a
1911 specialization, and the other is an instantiation of the same
1912 template, that we do not exit at this point. That situation
1913 can occur if we instantiate a template class, and then
1914 specialize one of its methods. This situation is valid, but
1915 the declarations must be merged in the usual way. */
1922 /* One of the declarations is a template instantiation, and the
1923 other is not a template at all. That's OK. */
1926 {
1927 /* In [namespace.alias] we have:
1929 In a declarative region, a namespace-alias-definition can be
1930 used to redefine a namespace-alias declared in that declarative
1931 region to refer only to the namespace to which it already
1932 refers.
1934 Therefore, if we encounter a second alias directive for the same
1935 alias, we can just ignore the second directive. */
1941 /* Leave it to update_binding to merge or report error. */
1943 }
1944 else
1945 {
1948 {
1949 auto_diagnostic_group d;
1957 }
1962 {
1963 /* Prototype decl follows defn w/o prototype. */
1964 auto_diagnostic_group d;
1969 }
1972 {
1973 /* [dcl.link]
1974 If two declarations of the same function or object
1975 specify different linkage-specifications ..., the program
1976 is ill-formed.... Except for functions with C++ linkage,
1977 a function declaration without a linkage specification
1978 shall not precede the first linkage specification for
1979 that function. A function can be declared without a
1980 linkage specification after an explicit linkage
1981 specification has been seen; the linkage explicitly
1982 specified in the earlier declaration is not affected by
1983 such a function declaration.
1985 DR 563 raises the question why the restrictions on
1986 functions should not also apply to objects. Older
1987 versions of G++ silently ignore the linkage-specification
1988 for this example:
1990 namespace N {
1991 extern int i;
1992 extern "C" int i;
1993 }
1995 which is clearly wrong. Therefore, we now treat objects
1996 like functions. */
1998 {
1999 /* There is no explicit linkage-specification, so we use
2000 the linkage from the previous declaration. */
2003 }
2004 else
2005 {
2006 auto_diagnostic_group d;
2013 }
2014 }
2017 ;
2019 {
2020 /* Note: free functions, as TEMPLATE_DECLs, are handled below. */
2023 as FUNCTION_DECLs. */
2025 /* C++11 8.3.6/6.
2026 Default arguments for a member function of a class
2027 template shall be specified on the initial declaration
2028 of the member function within the class template. */
2030 {
2035 {
2039 tree old_parms
2043 }
2044 }
2045 else
2046 {
2054 {
2057 {
2058 auto_diagnostic_group d;
2060 "default argument given for parameter "
2064 olddecl);
2065 }
2066 else
2067 {
2068 auto_diagnostic_group d;
2070 "default argument given for parameter %d "
2074 olddecl);
2075 }
2076 }
2078 /* C++17 11.3.6/4: "If a friend declaration specifies a default
2079 argument expression, that declaration... shall be the only
2080 declaration of the function or function template in the
2081 translation unit." */
2083 }
2084 }
2085 }
2087 /* Do not merge an implicit typedef with an explicit one. In:
2089 class A;
2090 ...
2091 typedef class A A __attribute__ ((foo));
2093 the attribute should apply only to the typedef. */
2109 {
2111 {
2114 else
2116 }
2117 else
2118 {
2120 {
2125 }
2129 {
2132 }
2133 }
2134 }
2136 /* We have committed to returning OLDDECL at this point. */
2138 /* If new decl is `static' and an `extern' was seen previously,
2139 warn about it. */
2142 /* True to merge attributes between the declarations, false to
2143 set OLDDECL's attributes to those of NEWDECL (for template
2144 explicit specializations that specify their own attributes
2145 independent of those specified for the primary template). */
2151 {
2153 {
2159 /* [dcl.attr.noreturn]: The first declaration of a function shall
2160 specify the noreturn attribute if any declaration of that function
2161 specifies the noreturn attribute. */
2162 tree a;
2165 /* This applies to [[noreturn]] only, not its GNU variants. */
2169 {
2173 }
2174 }
2176 /* Now that functions must hold information normally held
2177 by field decls, there is extra work to do so that
2178 declaration information does not get destroyed during
2179 definition. */
2199 /* Optionally warn about more than one declaration for the same
2200 name, but don't warn about a function declaration followed by a
2201 definition. */
2204 /* Don't warn about extern decl followed by definition. */
2206 /* Don't warn if at least one is/was hidden. */
2208 /* Don't warn about declaration followed by specialization. */
2211 {
2212 auto_diagnostic_group d;
2214 OPT_Wredundant_decls,
2216 newdecl))
2219 }
2221 /* [dcl.fct.def.delete] A deleted definition of a function shall be the
2222 first declaration of the function or, for an explicit specialization
2223 of a function template, the first declaration of that
2224 specialization. */
2227 {
2229 {
2230 auto_diagnostic_group d;
2235 }
2237 }
2238 }
2240 /* Deal with C++: must preserve virtual function table size. */
2242 {
2252 }
2254 /* Copy all the DECL_... slots specified in the new decl except for
2255 any that we copy here from the old type. */
2259 else
2263 {
2268 /* The new decl should not already have gathered any
2269 specializations. */
2276 {
2279 {
2280 /* Per C++11 8.3.6/4, default arguments cannot be added in
2281 later declarations of a function template. */
2283 /* C++17 11.3.6/4: "If a friend declaration specifies a default
2284 argument expression, that declaration... shall be the only
2285 declaration of the function or function template in the
2286 translation unit." */
2287 check_no_redeclaration_friend_default_args
2294 }
2302 {
2305 else
2317 }
2318 else
2319 {
2327 }
2328 }
2330 /* If the new declaration is a definition, update the file and
2331 line information on the declaration, and also make
2332 the old declaration the same definition. */
2334 {
2340 {
2341 tree parm;
2347 }
2348 }
2351 }
2354 {
2358 /* Automatically handles default parameters. */
2360 tree newtype;
2362 /* For typedefs use the old type, as the new type's DECL_NAME points
2363 at newdecl, which will be ggc_freed. */
2365 {
2366 /* But NEWTYPE might have an attribute, honor that. */
2371 {
2375 }
2377 /* And remove the new type from the variants list. */
2379 {
2382 {
2384 /* If remove is the main variant, no need to remove that
2385 from the list. One of the DECL_ORIGINAL_TYPE
2386 variants, e.g. created for aligned attribute, might still
2387 refer to the newdecl TYPE_DECL though, so remove that one
2388 in that case. */
2394 {
2398 }
2399 }
2400 else
2404 {
2407 }
2408 }
2409 }
2412 else
2416 {
2418 /* For already initialized vars, TREE_READONLY could have been
2419 cleared in cp_finish_decl, because the var needs runtime
2420 initialization or destruction. Make sure not to set
2421 TREE_READONLY on it again. */
2438 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
2441 {
2442 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
2445 }
2446 }
2448 /* An explicit specialization of a function template or of a member
2449 function of a class template can be declared transaction_safe
2450 independently of whether the corresponding template entity is declared
2451 transaction_safe. */
2464 /* Lay the type out, unless already done. */
2478 /* Merge deprecatedness. */
2482 /* Merge unavailability. */
2486 /* Preserve function specific target and optimization options */
2488 {
2501 }
2502 else
2503 {
2504 /* Merge the const type qualifier. */
2507 /* Merge the volatile type qualifier. */
2510 }
2512 /* Merge the initialization information. */
2515 {
2519 {
2522 }
2523 }
2526 {
2539 else
2540 {
2541 /* Merge the noreturn bit. */
2547 }
2548 /* Keep the old RTL. */
2550 }
2553 {
2554 /* Keep the old RTL. We cannot keep the old RTL if the old
2555 declaration was for an incomplete object and the new
2556 declaration is not since many attributes of the RTL will
2557 change. */
2559 }
2560 }
2561 /* If cannot merge, then use the new type and qualifiers,
2562 and don't preserve the old rtl. */
2563 else
2564 {
2565 /* Clean out any memory we had of the old declaration. */
2575 }
2577 /* Merge the storage class information. */
2589 {
2591 /* This can happen if olddecl was brought in from the
2592 enclosing namespace via a using-decl. The new decl is
2593 then not a block-scope extern at all. */
2595 else
2596 {
2599 }
2600 }
2604 {
2616 {
2620 }
2623 {
2628 /* If the OLDDECL is an instantiation and/or specialization,
2629 then the NEWDECL must be too. But, it may not yet be marked
2630 as such if the caller has created NEWDECL, but has not yet
2631 figured out that it is a redeclaration. */
2638 }
2640 /* Don't really know how much of the language-specific
2641 values we should copy from old to new. */
2645 {
2648 {
2652 /* Remember the presence of explicit specialization args. */
2655 }
2657 }
2660 {
2661 /* Only functions have these fields. */
2666 /* DECL_THUNKS is only valid for virtual functions,
2667 otherwise it is a DECL_FRIEND_CONTEXT. */
2670 }
2672 {
2673 /* Only variables have this field. */
2676 }
2677 }
2680 {
2681 tree parm;
2683 /* Merge parameter attributes. */
2688 {
2692 }
2696 {
2697 /* If newdecl is not a specialization, then it is not a
2698 template-related function at all. And that means that we
2699 should have exited above, returning 0. */
2703 /* From [temp.expl.spec]:
2705 If a template, a member template or the member of a class
2706 template is explicitly specialized then that
2707 specialization shall be declared before the first use of
2708 that specialization that would cause an implicit
2709 instantiation to take place, in every translation unit in
2710 which such a use occurs. */
2712 olddecl);
2718 /* Don't propagate visibility from the template to the
2719 specialization here. We'll do that in determine_visibility if
2720 appropriate. */
2723 /* [temp.expl.spec/14] We don't inline explicit specialization
2724 just because the primary template says so. */
2734 }
2736 {
2737 /* Never inline re-defined extern inline functions.
2738 FIXME: this could be better handled by keeping both
2739 function as separate declarations. */
2741 }
2742 else
2743 {
2745 {
2749 }
2751 ;
2765 }
2767 /* Preserve abstractness on cloned [cd]tors. */
2770 /* Update newdecl's parms to point at olddecl. */
2776 {
2780 }
2782 {
2783 /* These need to be copied so that the names are available.
2784 Note that if the types do match, we'll preserve inline
2785 info and other bits, but if not, we won't. */
2788 }
2789 /* If redeclaring a builtin function, it stays built in
2790 if newdecl is a gnu_inline definition, or if newdecl is just
2791 a declaration. */
2794 {
2796 /* If we're keeping the built-in definition, keep the rtl,
2797 regardless of declaration matches. */
2800 {
2803 {
2804 /* A compatible prototype of these builtin functions
2805 is seen, assume the runtime implements it with
2806 the expected semantics. */
2808 {
2815 }
2816 }
2819 }
2820 }
2822 /* If defining a function declared with other language
2823 linkage, use the previously declared language linkage. */
2826 {
2828 /* Don't clear out the arguments if we're just redeclaring a
2829 function. */
2832 }
2833 }
2837 /* Now preserve various other info from the definition. */
2843 /* Warn about conflicting visibility specifications. */
2847 {
2848 auto_diagnostic_group d;
2850 "%qD: visibility attribute ignored because it "
2854 }
2855 /* Choose the declaration which specified visibility. */
2857 {
2860 }
2861 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
2862 so keep this behavior. */
2864 {
2867 }
2868 /* Likewise for DECL_ALIGN, DECL_USER_ALIGN and DECL_PACKED. */
2870 {
2873 }
2886 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
2887 with that from NEWDECL below. */
2889 {
2893 }
2895 /* Merge the USED information. */
2902 {
2907 }
2914 /* Merge the DECL_FUNCTION_VERSIONED information. newdecl will be copied
2915 to olddecl and deleted. */
2918 {
2919 /* Set the flag for newdecl so that it gets copied to olddecl. */
2921 /* newdecl will be purged after copying to olddecl and is no longer
2922 a version. */
2924 }
2927 {
2941 /* Preserve symtab node mapping. */
2945 /* If newdecl is a template instantiation, it is possible that
2946 the following sequence of events has occurred:
2948 o A friend function was declared in a class template. The
2949 class template was instantiated.
2951 o The instantiation of the friend declaration was
2952 recorded on the instantiation list, and is newdecl.
2954 o Later, however, instantiate_class_template called pushdecl
2955 on the newdecl to perform name injection. But, pushdecl in
2956 turn called duplicate_decls when it discovered that another
2957 declaration of a global function with the same name already
2958 existed.
2960 o Here, in duplicate_decls, we decided to clobber newdecl.
2962 If we're going to do that, we'd better make sure that
2963 olddecl, and not newdecl, is on the list of
2964 instantiations so that if we try to do the instantiation
2965 again we won't get the clobbered declaration. */
2967 new_template_info,
2968 olddecl);
2969 }
2970 else
2971 {
2979 {
2987 {
3000 }
3008 }
3009 }
3012 {
3016 {
3017 /* Merge the section attribute.
3018 We want to issue an error if the sections conflict but that must be
3019 done later in decl_attributes since we are called before attributes
3020 are assigned. */
3025 {
3029 else
3033 }
3034 }
3038 {
3042 }
3043 }
3047 /* NEWDECL contains the merged attribute lists.
3048 Update OLDDECL to be the same. */
3051 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
3052 so that encode_section_info has a chance to look at the new decl
3053 flags and attributes. */
3060 /* The NEWDECL will no longer be needed. Because every out-of-class
3061 declaration of a member results in a call to duplicate_decls,
3062 freeing these nodes represents in a significant savings.
3064 Before releasing the node, be sore to remove function from symbol
3065 table that might have been inserted there to record comdat group.
3066 Be sure to however do not free DECL_STRUCT_FUNCTION because this
3067 structure is shared in between newdecl and oldecl. */
3071 {
3075 }
3078 {
3079 tree clone;
3081 {
3084 }
3085 }
3087 /* Remove the associated constraints for newdecl, if any, before
3088 reclaiming memory. */
3095 }
3096 \f
3097 /* Return zero if the declaration NEWDECL is valid
3098 when the declaration OLDDECL (assumed to be for the same name)
3099 has already been seen.
3100 Otherwise return an error message format string with a %s
3101 where the identifier should go. */
3105 {
3107 {
3108 /* Because C++ can put things into name space for free,
3109 constructs like "typedef struct foo { ... } foo"
3110 would look like an erroneous redeclaration. */
3113 else
3115 }
3117 {
3118 /* If this is a pure function, its olddecl will actually be
3119 the original initialization to `0' (which we force to call
3120 abort()). Don't complain about redefinition in this case. */
3125 /* If both functions come from different namespaces, this is not
3126 a redeclaration - this is a conflict with a used function. */
3132 /* We'll complain about linkage mismatches in
3133 warn_extern_redeclared_static. */
3135 /* Defining the same name twice is no good. */
3138 {
3144 }
3147 {
3152 {
3156 else
3159 }
3160 }
3166 /* [class.compare.default]: A definition of a comparison operator as
3167 defaulted that appears in a class shall be the first declaration of
3168 that function. */
3174 check_abi_tag_redeclaration
3179 }
3181 {
3205 {
3210 {
3214 else
3217 }
3218 }
3224 /* Core issue #226 (C++11):
3226 If a friend function template declaration specifies a
3227 default template-argument, that declaration shall be a
3228 definition and shall be the only declaration of the
3229 function template in the translation unit. */
3240 }
3247 {
3248 /* Only variables can be thread-local, and all declarations must
3249 agree on this property. */
3253 else
3256 }
3258 {
3259 /* The objects have been declared at namespace scope. If either
3260 is a member of an anonymous union, then this is an invalid
3261 redeclaration. For example:
3263 int i;
3264 union { int i; };
3266 is invalid. */
3270 /* If at least one declaration is a reference, there is no
3271 conflict. For example:
3273 int i = 3;
3274 extern int i;
3276 is valid. */
3280 /* Static data member declared outside a class definition
3281 if the variable is defined within the class with constexpr
3282 specifier is declaration rather than definition (and
3283 deprecated). */
3289 {
3291 /* For now, only warn with explicit -Wdeprecated. */
3293 {
3294 auto_diagnostic_group d;
3296 "redundant redeclaration of %<constexpr%> "
3300 }
3302 }
3304 /* Reject two definitions. */
3306 }
3307 else
3308 {
3309 /* Objects declared with block scope: */
3310 /* Reject two definitions, and reject a definition
3311 together with an external reference. */
3315 }
3316 }
3317 \f
3319 /* Hash and equality functions for the named_label table. */
3321 hashval_t
3323 {
3325 }
3327 bool
3329 {
3331 }
3333 /* Look for a label named ID in the current function. If one cannot
3334 be found, create one. Return the named_label_entry, or NULL on
3335 failure. */
3339 {
3342 /* You can't use labels at global scope. */
3344 {
3347 }
3353 named_label_entry **slot
3358 {
3363 {
3367 }
3368 }
3370 /* We are making a new decl, create or reuse the named_label_entry */
3374 else
3375 {
3380 }
3382 /* Now create the LABEL_DECL. */
3388 {
3392 }
3397 }
3399 /* Wrapper for lookup_label_1. */
3401 tree
3403 {
3406 }
3408 tree
3410 {
3413 }
3415 /* Returns nonzero if it is ill-formed to jump past the declaration of
3416 DECL. Returns 2 if it's also a real problem. */
3418 static int
3420 {
3421 /* [stmt.dcl]/3: A program that jumps from a point where a local variable
3422 with automatic storage duration is not in scope to a point where it is
3423 in scope is ill-formed unless the variable has scalar type, class type
3424 with a trivial default constructor and a trivial destructor, a
3425 cv-qualified version of one of these types, or an array of one of the
3426 preceding types and is declared without an initializer (8.5). */
3441 }
3443 /* A subroutine of check_previous_goto_1 and check_goto to identify a branch
3444 to the user. */
3446 static bool
3448 diagnostic_t diag_kind)
3449 {
3450 bool complained
3457 }
3459 /* Check that a single previously seen jump to a newly defined label
3460 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
3461 the jump context; NAMES are the names in scope in LEVEL at the jump
3462 context; LOCUS is the source position of the jump or 0. Returns
3463 true if all is well. */
3465 static bool
3468 {
3476 {
3482 }
3485 {
3491 {
3497 {
3502 }
3504 {
3508 else
3510 " enters scope of %q#D, which has "
3512 }
3513 }
3521 {
3548 {
3552 }
3554 {
3558 }
3563 }
3566 {
3572 }
3573 }
3576 }
3578 static void
3580 {
3584 }
3586 static bool
3588 {
3590 }
3592 /* Check that a new jump to a label DECL is OK. Called by
3593 finish_goto_stmt. */
3595 void
3597 {
3598 /* We can't know where a computed goto is jumping.
3599 So we assume that it's OK. */
3603 /* We didn't record any information about this label when we created it,
3604 and there's not much point since it's trivial to analyze as a return. */
3609 named_label_entry **slot
3613 /* If the label hasn't been defined yet, defer checking. */
3615 {
3616 /* Don't bother creating another use if the last goto had the
3617 same data, and will therefore create the same set of errors. */
3622 named_label_use_entry *new_use
3632 }
3636 tree bad;
3642 {
3651 }
3654 {
3658 {
3659 /* Can't skip init of __exception_info. */
3661 {
3665 }
3669 }
3671 {
3675 else
3677 " enters scope of %q#D which has "
3679 }
3680 }
3683 {
3694 }
3697 {
3700 }
3703 {
3707 {
3709 {
3714 }
3718 }
3719 }
3720 }
3722 /* Check that a return is ok wrt OpenMP structured blocks.
3723 Called by finish_return_stmt. Returns true if all is well. */
3725 bool
3727 {
3730 {
3733 }
3737 }
3739 /* Define a label, specifying the location in the source file.
3740 Return the LABEL_DECL node for the label. */
3742 tree
3744 {
3747 /* After labels, make any new cleanups in the function go into their
3748 own new (temporary) binding contour. */
3758 {
3761 }
3762 else
3763 {
3764 /* Mark label as having been defined. */
3766 /* Say where in the source. */
3775 }
3778 }
3780 struct cp_switch
3781 {
3784 /* The SWITCH_STMT being built. */
3785 tree switch_stmt;
3786 /* A splay-tree mapping the low element of a case range to the high
3787 element, or NULL_TREE if there is no high element. Used to
3788 determine whether or not a new case label duplicates an old case
3789 label. We need a tree, rather than simply a hash table, because
3790 of the GNU case range extension. */
3791 splay_tree cases;
3792 /* Remember whether a default: case label has been seen. */
3794 /* Remember whether a BREAK_STMT has been seen in this SWITCH_STMT. */
3796 /* Set if inside of {FOR,DO,WHILE}_BODY nested inside of a switch,
3797 where BREAK_STMT doesn't belong to the SWITCH_STMT. */
3799 };
3801 /* A stack of the currently active switch statements. The innermost
3802 switch statement is on the top of the stack. There is no need to
3803 mark the stack for garbage collection because it is only active
3804 during the processing of the body of a function, and we never
3805 collect at that point. */
3809 /* Called right after a switch-statement condition is parsed.
3810 SWITCH_STMT is the switch statement being parsed. */
3812 void
3814 {
3824 }
3826 void
3828 {
3831 /* Emit warnings as needed. */
3834 const bool bool_cond_p
3840 bool_cond_p);
3842 /* For the benefit of block_may_fallthru remember if the switch body
3843 case labels cover all possible values and if there are break; stmts. */
3845 || (!processing_template_decl
3851 /* Now that we're done with the switch warnings, set the switch type
3852 to the type of the condition if the index type was of scoped enum type.
3853 (Such types don't participate in the integer promotions.) We do this
3854 because of bit-fields whose declared type is a scoped enum type:
3855 gimplification will use the lowered index type, but convert the
3856 case values to SWITCH_STMT_TYPE, which would have been the declared type
3857 and verify_gimple_switch doesn't accept that. */
3864 }
3866 /* Note that a BREAK_STMT is about to be added. If it is inside of
3867 a SWITCH_STMT and not inside of a loop body inside of it, note
3868 in switch_stack we've seen a BREAK_STMT. */
3870 void
3872 {
3875 }
3877 /* Note the start of processing of an iteration statement's body.
3878 The note_break_stmt function will do nothing while processing it.
3879 Return a flag that should be passed to note_iteration_stmt_body_end. */
3881 bool
3883 {
3889 }
3891 /* Note the end of processing of an iteration statement's body. */
3893 void
3895 {
3898 }
3900 /* Convert a case constant VALUE in a switch to the type TYPE of the switch
3901 condition. Note that if TYPE and VALUE are already integral we don't
3902 really do the conversion because the language-independent
3903 warning/optimization code will work better that way. */
3905 static tree
3907 {
3917 /* The constant-expression VALUE shall be a converted constant expression
3918 of the adjusted type of the switch condition, which doesn't allow
3919 narrowing conversions. */
3926 else
3927 /* The already integral case. */
3931 }
3933 /* Note that we've seen a definition of a case label, and complain if this
3934 is a bad place for one. */
3936 tree
3938 {
3941 tree type;
3947 {
3948 tree label;
3950 /* For templates, just add the case label; we'll do semantic
3951 analysis at instantiation-time. */
3954 }
3956 /* Find the condition on which this switch statement depends. */
3973 /* After labels, make any new cleanups in the function go into their
3974 own new (temporary) binding contour. */
3981 }
3982 \f
3984 tree scope;
3985 tree name;
3986 tree template_id;
3989 };
3992 {
3995 /* Hash a TYPENAME_TYPE. */
3997 static hashval_t
3999 {
4000 hashval_t hash;
4006 }
4008 /* Compare two TYPENAME_TYPEs. */
4010 static bool
4012 {
4018 }
4019 };
4021 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
4022 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
4024 Returns the new TYPENAME_TYPE. */
4028 tree
4031 {
4032 typename_info ti;
4047 /* See if we already have this type. */
4052 else
4053 {
4054 /* Build the TYPENAME_TYPE. */
4061 /* Build the corresponding TYPE_DECL. */
4068 /* Store it in the hash table. */
4071 /* TYPENAME_TYPEs must always be compared structurally, because
4072 they may or may not resolve down to another type depending on
4073 the currently open classes. */
4075 }
4078 }
4080 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
4081 provided to name the type. Returns an appropriate type, unless an
4082 error occurs, in which case error_mark_node is returned. If we
4083 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
4084 return that, rather than the _TYPE it corresponds to, in other
4085 cases we look through the type decl. If TF_ERROR is set, complain
4086 about errors, otherwise be quiet. */
4088 tree
4090 tsubst_flags_t complain)
4091 {
4092 tree fullname;
4093 tree t;
4102 {
4107 else
4108 /* Create a TEMPLATE_ID_EXPR for the type. */
4112 }
4119 {
4124 {
4128 }
4129 }
4131 {
4135 }
4137 {
4141 }
4148 {
4152 }
4154 /* When the CONTEXT is a dependent type, NAME could refer to a
4155 dependent base class of CONTEXT. But look inside it anyway
4156 if CONTEXT is a currently open scope, in case it refers to a
4157 member of the current instantiation or a non-dependent base;
4158 lookup will stop when we hit a dependent base. */
4160 /* We should only set WANT_TYPE when we're a nested typename type.
4161 Then we can give better diagnostics if we find a non-type. */
4163 else
4172 {
4174 {
4177 else
4180 }
4182 }
4184 /* Pull out the template from an injected-class-name (or multiple). */
4189 {
4191 {
4194 }
4196 }
4199 {
4204 }
4206 {
4209 /* The caller permits this typename-specifier to name a template
4211 else
4212 {
4217 }
4218 }
4228 {
4236 }
4244 }
4246 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
4247 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
4248 in which case error_mark_node is returned.
4250 If PARM_LIST is non-NULL, also make sure that the template parameter
4251 list of TEMPLATE_DECL matches.
4253 If COMPLAIN zero, don't complain about any errors that occur. */
4255 tree
4257 tsubst_flags_t complain)
4258 {
4267 {
4277 {
4281 }
4285 {
4287 {
4291 }
4293 }
4296 complain))
4300 }
4303 }
4305 /* Build an UNBOUND_CLASS_TEMPLATE. */
4307 tree
4309 {
4310 /* Build the UNBOUND_CLASS_TEMPLATE. */
4316 /* Build the corresponding TEMPLATE_DECL. */
4325 }
4327 \f
4329 /* Push the declarations of builtin types into the global namespace.
4330 RID_INDEX is the index of the builtin type in the array
4331 RID_POINTERS. NAME is the name used when looking up the builtin
4332 type. TYPE is the _TYPE node for the builtin type.
4334 The calls to set_global_binding below should be
4335 eliminated. Built-in types should not be looked up name; their
4336 names are keywords that the parser can recognize. However, there
4337 is code in c-common.cc that uses identifier_global_value to look up
4338 built-in types by name. */
4340 void
4343 tree type)
4344 {
4348 {
4354 }
4359 {
4365 }
4368 {
4372 }
4373 }
4375 /* Push a type into the namespace so that the back ends ignore it. */
4377 static void
4379 {
4382 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
4389 }
4391 /* Create all the predefined identifiers. */
4393 static void
4395 {
4396 struct predefined_identifier
4397 {
4401 };
4403 /* A table of identifiers to create at startup. */
4407 /* Some of these names have a trailing space so that it is
4408 impossible for them to conflict with names written by users. */
4425 /* The demangler expects anonymous namespaces to be called
4426 something starting with '_GLOBAL__N_'. It no longer needs
4427 to be unique to the TU. */
4457 };
4461 {
4463 /* Some of these identifiers already have a special kind. */
4466 }
4467 }
4469 /* Create the predefined scalar types of C,
4470 and some nodes representing standard constants (0, 1, (void *)0).
4471 Initialize the global binding level.
4472 Make definitions for built-in primitive functions. */
4474 void
4476 {
4477 tree void_ftype;
4478 tree void_ftype_ptr;
4480 /* Create all the identifiers we need. */
4483 /* Create the global variables. */
4488 /* Enter the global namespace. */
4491 void_type_node);
4496 /* Remember whether we want the empty class passing ABI change warning
4497 in this TU. */
4500 debug_hooks->register_main_translation_unit
4508 /* Initially, C. */
4511 /* Create the `std' namespace. */
4521 tree decl
4534 NULL_TREE);
4535 decl
4537 bool_vaftype,
4538 CP_BUILT_IN_IS_CORRESPONDING_MEMBER,
4542 decl
4544 bool_vaftype,
4545 CP_BUILT_IN_IS_POINTER_INTERCONVERTIBLE_WITH_CLASS,
4551 /* Guess at the initial static decls size. */
4554 /* ... and keyed classes. */
4566 NULL_TREE);
4568 #if 0
4570 #endif
4579 void_ftype_ptr
4582 /* Create the conversion operator marker. This operator's DECL_NAME
4583 is in the identifier table, so we can use identifier equality to
4584 find it. */
4586 void_ftype);
4588 /* C++ extensions */
4593 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
4596 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
4597 result. */
4604 /* Used when parsing to distinguish parameter-lists () and (void). */
4607 {
4608 /* Make sure we get a unique function type, so we can give
4609 its pointer type a name. (This wins for gdb.) */
4616 }
4619 vtbl_type_node
4635 /* Now, C++. */
4640 {
4642 aligned_new_threshold);
4644 }
4650 {
4653 tree ptr_ftype_sizetype;
4654 tree new_eh_spec;
4656 ptr_ftype_sizetype
4659 {
4660 tree bad_alloc_id;
4661 tree bad_alloc_type_node;
4662 tree bad_alloc_decl;
4668 bad_alloc_decl
4673 new_eh_spec
4675 }
4676 else
4679 /* Ensure attribs.cc is initialized. */
4683 NULL_TREE);
4686 extvisattr);
4706 {
4707 /* Also push the sized deallocation variants:
4708 void operator delete(void*, std::size_t) throw();
4709 void operator delete[](void*, std::size_t) throw(); */
4710 tree void_ftype_ptr_size
4714 extvisattr);
4722 }
4725 {
4732 /* operator new (size_t, align_val_t); */
4746 /* operator delete (void *, align_val_t); */
4759 {
4760 /* operator delete (void *, size_t, align_val_t); */
4763 NULL_TREE);
4772 }
4773 }
4785 }
4790 abort_fndecl
4794 /* If no definition is available, resolve references to NULL. */
4797 /* Perform other language dependent initializations. */
4811 /* Show we use EH for cleanups. */
4815 /* Check that the hardware interference sizes are at least
4816 alignof(max_align_t), as required by the standard. */
4819 {
4825 "%<--param destructive-interference-size=%d%> "
4828 }
4833 /* else leave it unset. */
4836 {
4843 "%<--param constructive-interference-size=%d%> "
4846 }
4851 }
4853 /* Enter an abi node in global-module context. returns a cookie to
4854 give to pop_abi_namespace. */
4856 unsigned
4858 {
4864 }
4866 /* Pop an abi namespace, FLAGS is the cookie push_abi_namespace gave
4867 you. */
4869 void
4871 {
4875 }
4877 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give
4878 the decl, LOC is the location to give the decl, NAME is the
4879 initialization string and TYPE_DEP indicates whether NAME depended
4880 on the type of the function. We make use of that to detect
4881 __PRETTY_FUNCTION__ inside a template fn. This is being done lazily
4882 at the point of first use, so we mustn't push the decl now. */
4884 static tree
4886 {
4891 {
4898 {
4899 /* __FUNCTION__ */
4902 }
4903 else
4904 {
4905 /* __PRETTY_FUNCTION__ */
4908 }
4915 }
4922 else
4936 /* For decl_constant_var_p. */
4940 {
4945 }
4946 else
4947 {
4950 }
4953 }
4955 /* Install DECL as a builtin function at current global scope. Return
4956 the new decl (if we found an existing version). Also installs it
4957 into ::std, if it's not '_*'. */
4959 tree
4961 {
4966 /* Runtime library routines are, by definition, available in an
4967 external shared object. */
4975 /* In the user's namespace, it must be declared before use. */
4981 /* Treat __*_chk fortification functions as anticipated as well,
4982 unless they are __builtin_*_chk. */
4985 /* All builtins that don't begin with an '_' should additionally
4986 go in the 'std' namespace. */
4988 {
4995 }
5001 }
5003 /* Like cxx_builtin_function, but guarantee the function is added to the global
5004 scope. This is to allow function specific options to add new machine
5005 dependent builtins when the target ISA changes via attribute((target(...)))
5006 which saves space on program startup if the program does not use non-generic
5007 ISAs. */
5009 tree
5011 {
5017 }
5019 /* Implement LANG_HOOKS_SIMULATE_BUILTIN_FUNCTION_DECL. */
5021 tree
5023 {
5030 }
5032 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
5033 function. Not called directly. */
5035 static tree
5038 {
5046 /* Runtime library routines are, by definition, available in an
5047 external shared object. */
5052 }
5054 /* Returns the _DECL for a library function with C++ linkage. */
5056 static tree
5059 {
5064 }
5066 /* Like build_library_fn, but takes a C string instead of an
5067 IDENTIFIER_NODE. */
5069 tree
5071 {
5073 }
5075 /* Like build_cp_library_fn, but takes a C string instead of an
5076 IDENTIFIER_NODE. */
5078 tree
5080 {
5082 ecf_flags);
5083 }
5085 /* Like build_library_fn, but also pushes the function so that we will
5086 be able to find it via get_global_binding. Also, the function
5087 may throw exceptions listed in RAISES. */
5089 tree
5091 {
5097 }
5099 /* Like build_cp_library_fn, but also pushes the function so that it
5100 will be found by normal lookup. */
5102 static tree
5105 {
5112 }
5114 /* Like push_library_fn, but also note that this function throws
5115 and does not return. Used for __throw_foo and the like. */
5117 tree
5119 {
5122 }
5123 \f
5124 /* When we call finish_struct for an anonymous union, we create
5125 default copy constructors and such. But, an anonymous union
5126 shouldn't have such things; this function undoes the damage to the
5127 anonymous union type T.
5129 (The reason that we create the synthesized methods is that we don't
5130 distinguish `union { int i; }' from `typedef union { int i; } U'.
5131 The first is an anonymous union; the second is just an ordinary
5132 union type.) */
5134 void
5136 {
5137 /* Wipe out memory of synthesized methods. */
5145 /* Splice the implicitly generated functions out of TYPE_FIELDS and diagnose
5146 invalid members. */
5148 {
5151 else
5161 {
5162 /* We already complained about static data members in
5163 finish_static_data_member_decl. */
5165 {
5166 auto_diagnostic_group d;
5170 "only have public non-static data members"
5173 {
5176 {
5179 "this flexibility is deprecated and will be "
5181 }
5182 }
5183 }
5184 }
5185 }
5187 /* Splice all functions out of CLASSTYPE_MEMBER_VEC. */
5195 /* Wipe RTTI info. */
5198 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
5199 assignment operators (because they cannot have these methods themselves).
5200 For anonymous unions this is already checked because they are not allowed
5201 in any union, otherwise we have to check it. */
5203 {
5207 {
5209 /* Avoid ICE after error on anon-struct9.C. */
5211 }
5215 {
5218 {
5228 }
5229 }
5230 }
5231 }
5233 /* Warn for an attribute located at LOCATION that appertains to the
5234 class type CLASS_TYPE that has not been properly placed after its
5235 class-key, in it class-specifier. */
5237 void
5239 tree class_type)
5240 {
5243 auto_diagnostic_group d;
5245 "attribute ignored in declaration "
5250 }
5252 /* Returns the cv-qualifiers that apply to the type specified
5253 by the DECLSPECS. */
5255 static int
5257 {
5268 }
5270 /* Make sure that a declaration with no declarator is well-formed, i.e.
5271 just declares a tagged type or anonymous union.
5273 Returns the type declared; or NULL_TREE if none. */
5275 tree
5278 {
5281 /* If a class, struct, or enum type is declared by the DECLSPECS
5282 (i.e, if a class-specifier, enum-specifier, or non-typename
5283 elaborated-type-specifier appears in the DECLSPECS),
5284 DECLARED_TYPE is set to the corresponding type. */
5292 {
5298 }
5310 {
5312 "%<auto%> can only be specified for variables "
5315 }
5322 /* Check for an anonymous union. */
5325 {
5326 /* 7/3 In a simple-declaration, the optional init-declarator-list
5327 can be omitted only when declaring a class (clause 9) or
5328 enumeration (7.2), that is, when the decl-specifier-seq contains
5329 either a class-specifier, an elaborated-type-specifier with
5330 a class-key (9.1), or an enum-specifier. In these cases and
5331 whenever a class-specifier or enum-specifier is present in the
5332 decl-specifier-seq, the identifiers in these specifiers are among
5333 the names being declared by the declaration (as class-name,
5334 enum-names, or enumerators, depending on the syntax). In such
5335 cases, and except for the declaration of an unnamed bit-field (9.6),
5336 the decl-specifier-seq shall introduce one or more names into the
5337 program, or shall redeclare a name introduced by a previous
5338 declaration. [Example:
5339 enum { }; // ill-formed
5340 typedef class { }; // ill-formed
5341 --end example] */
5343 {
5347 }
5354 }
5356 else
5357 {
5365 && (!current_class_type
5374 "a storage class can only be specified for objects "
5378 "%<const%> can only be specified for objects and "
5382 "%<volatile%> can only be specified for objects and "
5386 "%<__restrict%> can only be specified for objects and "
5390 "%<__thread%> can only be specified for objects "
5404 }
5407 {
5408 location_t loc;
5411 /* For a non-template class, use the name location. */
5413 else
5414 /* For a template class (an explicit instantiation), use the
5415 current location. */
5419 /* [dcl.attr.grammar]/4:
5421 No attribute-specifier-seq shall appertain to an explicit
5422 instantiation. */
5423 {
5426 declared_type))
5428 "no attribute can be applied to "
5430 }
5431 else
5433 }
5436 }
5438 /* Called when a declaration is seen that contains no names to declare.
5439 If its type is a reference to a structure, union or enum inherited
5440 from a containing scope, shadow that tag name for the current scope
5441 with a forward reference.
5442 If its type defines a new named structure or union
5443 or defines an enum, it is valid but we need not do anything here.
5444 Otherwise, it is an error.
5446 C++: may have to grok the declspecs to learn about static,
5447 complain for anonymous unions.
5449 Returns the TYPE declared -- or NULL_TREE if none. */
5451 tree
5453 {
5463 /* This is where the variables in an anonymous union are
5464 declared. An anonymous union declaration looks like:
5465 union { ... } ;
5466 because there is no declarator after the union, the parser
5467 sends that declaration here. */
5469 {
5473 {
5477 }
5478 }
5481 }
5482 \f
5483 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
5485 tree
5489 {
5490 tree attrs;
5491 tree type;
5492 enum decl_context context
5498 {
5503 /* A template type parameter or other dependent type. */
5506 else
5508 }
5510 }
5512 /* Process a DECLARATOR for a function-scope or namespace-scope
5513 variable or function declaration.
5514 (Function definitions go through start_function; class member
5515 declarations appearing in the body of the class go through
5516 grokfield.) The DECL corresponding to the DECLARATOR is returned.
5517 If an error occurs, the error_mark_node is returned instead.
5519 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED is
5520 SD_INITIALIZED if an explicit initializer is present, or SD_DEFAULTED
5521 for an explicitly defaulted function, or SD_DELETED for an explicitly
5522 deleted function, but 0 (SD_UNINITIALIZED) if this is a variable
5523 implicitly initialized via a default constructor. It can also be
5524 SD_DECOMPOSITION which behaves much like SD_INITIALIZED, but we also
5525 mark the new decl as DECL_DECOMPOSITION_P.
5527 ATTRIBUTES and PREFIX_ATTRIBUTES are GNU attributes associated with this
5528 declaration.
5530 The scope represented by the context of the returned DECL is pushed
5531 (if it is not the global namespace) and is assigned to
5532 *PUSHED_SCOPE_P. The caller is then responsible for calling
5533 pop_scope on *PUSHED_SCOPE_P if it is set. */
5535 tree
5539 tree attributes,
5540 tree prefix_attributes,
5542 {
5543 tree decl;
5544 tree context;
5548 tree initial;
5568 {
5573 }
5575 /* Save the DECL_INITIAL value in case it gets clobbered to assist
5576 with attribute validation. */
5580 {
5584 decl);
5588 /* Tell 'cplus_decl_attributes' this is an initialized decl,
5589 even though we might not yet have the initializer expression. */
5592 }
5598 /* If this is a typedef that names the class for linkage purposes
5599 (7.1.3p8), apply any attributes directly to the type. */
5604 else
5607 /* Set attributes here so if duplicate decl, will have proper attributes. */
5610 /* Restore the original DECL_INITIAL that we may have clobbered earlier to
5611 assist with attribute validation. */
5614 /* Dllimported symbols cannot be defined. Static data members (which
5615 can be initialized in-class and dllimported) go through grokfield,
5616 not here, so we don't need to exclude those decls when checking for
5617 a definition. */
5619 {
5623 }
5625 /* If #pragma weak was used, mark the decl weak now. */
5637 {
5641 {
5651 {
5657 }
5658 else
5659 {
5664 {
5671 }
5672 /* Static data member are tricky; an in-class initialization
5673 still doesn't provide a definition, so the in-class
5674 declaration will have DECL_EXTERNAL set, but will have an
5675 initialization. Thus, duplicate_decls won't warn
5676 about this situation, and so we check here. */
5684 }
5685 }
5686 else
5687 {
5689 this_tmpl
5690 ? current_template_parms
5695 }
5697 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
5699 /* Do not mark DECL as an explicit specialization if it was not
5700 already marked as an instantiation; a declaration should
5701 never be marked as a specialization unless we know what
5702 template is being specialized. */
5704 {
5709 else
5712 /* [temp.expl.spec] An explicit specialization of a static data
5713 member of a template is a definition if the declaration
5714 includes an initializer; otherwise, it is a declaration.
5716 We check for processing_specialization so this only applies
5717 to the new specialization syntax. */
5720 }
5723 /* Aliases are definitions. */
5727 decl);
5728 }
5730 /* Create a DECL_LANG_SPECIFIC so that DECL_DECOMPOSITION_P works. */
5738 {
5739 /* A function-scope decl of some namespace-scope decl. */
5743 "block-scope extern declaration %q#D not permitted"
5745 }
5747 /* Enter this declaration into the symbol table. Don't push the plain
5748 VAR_DECL for a variable template. */
5762 /* But not templated variables. */
5764 {
5765 /* This is a const variable with implicit 'static'. Set
5766 DECL_THIS_STATIC so we can tell it from variables that are
5767 !TREE_PUBLIC because of the anonymous namespace. */
5770 }
5775 {
5779 "%qD declared %<thread_local%> in %qs function only "
5785 "%qD declared %<static%> in %qs function only available "
5789 else
5793 }
5799 }
5801 /* Process the declaration of a variable DECL. INITIALIZED is true
5802 iff DECL is explicitly initialized. (INITIALIZED is false if the
5803 variable is initialized via an implicitly-called constructor.)
5804 This function must be called for ordinary variables (including, for
5805 example, implicit instantiations of templates), but must not be
5806 called for template declarations. */
5808 void
5810 {
5820 bool aggregate_definition_p
5823 /* If an explicit initializer is present, or if this is a definition
5824 of an aggregate, then we need a complete type at this point.
5825 (Scalars are always complete types, so there is nothing to
5826 check.) This code just sets COMPLETE_P; errors (if necessary)
5827 are issued below. */
5829 && !complete_p
5831 {
5833 /* We will not yet have set TREE_READONLY on DECL if the type
5834 was "const", but incomplete, before this point. But, now, we
5835 have a complete type, so we can try again. */
5837 }
5840 /* Is it valid for this decl to have an initializer at all? */
5841 {
5842 /* Don't allow initializations for incomplete types except for
5843 arrays which might be completed by the initialization. */
5849 {
5852 }
5854 {
5857 /* else we already gave an error in start_decl. */
5858 }
5859 }
5861 {
5864 else
5865 {
5867 decl);
5868 /* Change the type so that assemble_variable will give
5869 DECL an rtl we can live with: (mem (const_int 0)). */
5871 }
5872 }
5874 /* Create a new scope to hold this declaration if necessary.
5875 Whether or not a new scope is necessary cannot be determined
5876 until after the type has been completed; if the type is a
5877 specialization of a class template it is not until after
5878 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
5879 will be set correctly. */
5881 }
5883 /* Given a parenthesized list of values INIT, create a CONSTRUCTOR to handle
5884 C++20 P0960. TYPE is the type of the object we're initializing. */
5886 tree
5888 {
5892 {
5893 /* If the list has a single element and it's a string literal,
5894 then it's the initializer for the array as a whole. */
5900 /* Handle non-standard extensions like compound literals. This also
5901 prevents triggering aggregate parenthesized-initialization in
5902 compiler-generated code for =default. */
5906 }
5912 }
5914 /* Handle initialization of references. DECL, TYPE, and INIT have the
5915 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
5916 but will be set to a new CLEANUP_STMT if a temporary is created
5917 that must be destroyed subsequently.
5919 Returns an initializer expression to use to initialize DECL, or
5920 NULL if the initialization can be performed statically.
5922 Quotes on semantics can be found in ARM 8.4.3. */
5924 static tree
5926 {
5928 {
5935 }
5939 {
5940 /* This handles (C++20 only) code like
5942 const A& r(1, 2, 3);
5944 where we treat the parenthesized list as a CONSTRUCTOR. */
5949 {
5950 /* We don't know yet if we should treat const A& r(1) as
5951 const A& r{1}. */
5953 {
5956 tf_warning_or_error);
5957 }
5958 /* If the list had more than one element, the code is ill-formed
5959 pre-C++20, so we can build a constructor right away. */
5960 else
5962 }
5963 else
5965 tf_warning_or_error);
5966 }
5970 /* Note: default conversion is only called in very special cases. */
5973 /* check_initializer handles this for non-reference variables, but for
5974 references we need to do it here or the initializer will get the
5975 incomplete array type and confuse later calls to
5976 cp_complete_array_type. */
5981 {
5985 }
5987 /* Convert INIT to the reference type TYPE. This may involve the
5988 creation of a temporary, whose lifetime must be the same as that
5989 of the reference. If so, a DECL_EXPR for the temporary will be
5990 added just after the DECL_EXPR for DECL. That's why we don't set
5991 DECL_INITIAL for local references (instead assigning to them
5992 explicitly); we need to allow the temporary to be initialized
5993 first. */
5995 tf_warning_or_error);
5996 }
5998 /* Designated initializers in arrays are not supported in GNU C++.
5999 The parser cannot detect this error since it does not know whether
6000 a given brace-enclosed initializer is for a class type or for an
6001 array. This function checks that CE does not use a designated
6002 initializer. If it does, an error is issued. Returns true if CE
6003 is valid, i.e., does not have a designated initializer. */
6005 bool
6008 {
6009 /* Designated initializers for array elements are not supported. */
6011 {
6012 /* The parser only allows identifiers as designated
6013 initializers. */
6015 {
6019 }
6021 {
6025 }
6033 {
6034 /* A C99 designator is OK if it matches the current index. */
6036 {
6039 }
6040 else
6042 }
6043 else
6049 }
6052 }
6054 /* When parsing `int a[] = {1, 2};' we don't know the size of the
6055 array until we finish parsing the initializer. If that's the
6056 situation we're in, update DECL accordingly. */
6058 static void
6060 {
6066 {
6067 /* do_default is really a C-ism to deal with tentative definitions.
6068 But let's leave it here to ease the eventual merge. */
6073 /* Check that there are no designated initializers in INIT, as
6074 those are not supported in GNU C++, and as the middle-end
6075 will crash if presented with a non-numeric designated
6076 initializer. */
6078 {
6081 HOST_WIDE_INT i;
6083 {
6088 /* If an un-designated initializer is type-dependent, we can't
6089 check brace elision yet. */
6093 }
6094 }
6098 else
6099 {
6101 do_default);
6103 {
6107 }
6109 {
6111 {
6114 }
6115 /* If a `static' var's size isn't known, make it extern as
6116 well as static, so it does not get allocated. If it's not
6117 `static', then don't mark it extern; finish_incomplete_decl
6118 will give it a default size and it will get allocated. */
6121 }
6123 {
6126 }
6127 }
6132 }
6133 }
6135 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
6136 any appropriate error messages regarding the layout. */
6138 static void
6140 {
6141 tree type;
6147 /* If we haven't already laid out this declaration, do so now.
6148 Note that we must not call complete type for an external object
6149 because it's type might involve templates that we are not
6150 supposed to instantiate yet. (And it's perfectly valid to say
6151 `extern X x' for some incomplete type `X'.) */
6160 {
6161 /* An automatic variable with an incomplete type: that is an error.
6162 Don't talk about array types here, since we took care of that
6163 message in grokdeclarator. */
6167 }
6168 #if 0
6169 /* Keep this code around in case we later want to control debug info
6170 based on whether a type is "used". (jason 1999-11-11) */
6173 /* Let debugger know it should output info for this type. */
6178 #endif
6183 {
6187 else
6188 {
6193 }
6194 }
6196 /* If the final element initializes a flexible array field, add the size of
6197 that initializer to DECL's size. */
6207 {
6210 {
6217 {
6223 }
6224 }
6225 }
6226 }
6228 /* If a local static variable is declared in an inline function, or if
6229 we have a weak definition, we must endeavor to create only one
6230 instance of the variable at link-time. */
6232 void
6234 {
6235 /* Don't mess with __FUNCTION__ and similar. */
6239 /* Static data in a function with comdat linkage also has comdat
6240 linkage. */
6245 {
6247 {
6248 /* With weak symbols, we simply make the variable COMDAT;
6249 that will cause copies in multiple translations units to
6250 be merged. */
6252 }
6253 else
6254 {
6257 {
6258 /* Without weak symbols, we can use COMMON to merge
6259 uninitialized variables. */
6262 }
6263 else
6264 {
6265 /* While for initialized variables, we must use internal
6266 linkage -- which means that multiple copies will not
6267 be merged. */
6274 "%q#D are wrong (you%'ll wind up with "
6276 else
6278 "static data %q#D are wrong (you%'ll wind "
6284 }
6285 }
6286 }
6287 }
6289 /* Issue an error message if DECL is an uninitialized const variable.
6290 CONSTEXPR_CONTEXT_P is true when the function is called in a constexpr
6291 context from potential_constant_expression. Returns true if all is well,
6292 false otherwise. */
6294 bool
6296 tsubst_flags_t complain)
6297 {
6300 /* ``Unless explicitly declared extern, a const object does not have
6301 external linkage and must be initialized. ($8.4; $12.1)'' ARM
6302 7.1.6 */
6306 /* C++20 permits trivial default initialization in constexpr
6307 context (P1331R2). */
6309 && (constexpr_context_p
6312 {
6320 {
6322 {
6326 }
6327 else
6328 {
6332 "uninitialized variable %qD in %<constexpr%> "
6334 else
6337 }
6338 }
6342 decl);
6345 {
6346 tree defaulted_ctor;
6353 "constructor is not user-provided because it is "
6356 "and the implicitly-defined constructor does not "
6358 }
6361 }
6364 }
6365 \f
6366 /* Structure holding the current initializer being processed by reshape_init.
6367 CUR is a pointer to the current element being processed, END is a pointer
6368 after the last element present in the initializer. */
6369 struct reshape_iter
6370 {
6373 };
6377 /* FIELD is an element of TYPE_FIELDS or NULL. In the former case, the value
6378 returned is the next FIELD_DECL (possibly FIELD itself) that can be
6379 initialized. If there are no more such fields, the return value
6380 will be NULL. */
6382 tree
6384 {
6389 /* In C++17, don't skip base class fields. */
6391 /* Don't skip vptr fields. We might see them when we're
6392 called from reduced_constant_expression_p. */
6397 }
6399 /* Return true for [dcl.init.list] direct-list-initialization from
6400 single element of enumeration with a fixed underlying type. */
6402 bool
6404 {
6411 /* DR 2374: The single element needs to be implicitly
6412 convertible to the underlying type of the enum. */
6419 }
6421 /* Subroutine of reshape_init_array and reshape_init_vector, which does
6422 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
6423 INTEGER_CST representing the size of the array minus one (the maximum index),
6424 or NULL_TREE if the array was declared without specifying the size. D is
6425 the iterator within the constructor. */
6427 static tree
6430 {
6431 tree new_init;
6436 /* The initializer for an array is always a CONSTRUCTOR. If this is the
6437 outermost CONSTRUCTOR and the element type is non-aggregate, we don't need
6438 to build a new one. But don't reuse if not complaining; if this is
6439 tentative, we might also reshape to another type (95319). */
6446 else
6450 {
6451 /* Minus 1 is used for zero sized arrays. */
6457 /* sizetype is sign extended, not zero extended. */
6458 else
6460 }
6462 /* Loop until there are no more initializers. */
6466 {
6467 tree elt_init;
6473 complain);
6478 {
6481 }
6482 else
6488 /* This can happen with an invalid initializer (c++/54501). */
6491 }
6494 }
6496 /* Subroutine of reshape_init_r, processes the initializers for arrays.
6497 Parameters are the same of reshape_init_r. */
6499 static tree
6501 tsubst_flags_t complain)
6502 {
6512 }
6514 /* Subroutine of reshape_init_r, processes the initializers for vectors.
6515 Parameters are the same of reshape_init_r. */
6517 static tree
6519 {
6525 {
6528 {
6533 }
6536 }
6538 /* For a vector, we initialize it as an array of the appropriate size. */
6544 }
6546 /* Subroutine of reshape_init_r, processes the initializers for classes
6547 or union. Parameters are the same of reshape_init_r. */
6549 static tree
6551 tsubst_flags_t complain)
6552 {
6553 tree field;
6554 tree new_init;
6558 /* The initializer for a class is always a CONSTRUCTOR. */
6565 {
6566 /* We get here from maybe_aggr_guide for C++20 class template argument
6567 deduction. In this case we need to look through the binfo because a
6568 template doesn't have base fields. */
6571 }
6574 else
6578 {
6579 /* [dcl.init.aggr]
6581 An initializer for an aggregate member that is an
6582 empty class shall have the form of an empty
6583 initializer-list {}. */
6585 {
6589 }
6591 }
6593 /* For C++20 CTAD, handle pack expansions in the base list. */
6596 /* Loop through the initializable fields, gathering initializers. */
6598 {
6599 tree field_init;
6602 /* Handle designated initializers, as an extension. */
6604 {
6609 {
6610 /* We already reshaped this. */
6612 {
6617 }
6618 }
6621 else
6622 {
6627 }
6630 /* Apparently the designator isn't for a member of this anonymous
6631 struct, so head back to the enclosing class. */
6635 {
6640 }
6642 /* If the element is an anonymous union object and the initializer
6643 list is a designated-initializer-list, the anonymous union object
6644 is initialized by the designated-initializer-list { D }, where D
6645 is the designated-initializer-clause naming a member of the
6646 anonymous union object. */
6649 {
6650 /* Find the anon aggr that is a direct member of TYPE. */
6652 {
6657 }
6659 /* Not found, e.g. FIELD is a member of a base class. */
6664 found:
6665 /* Now find the TYPE member with that anon aggr type. */
6672 }
6673 }
6675 /* If we processed all the member of the class, we are done. */
6682 /* Each non-trailing aggregate element that is a pack expansion is
6683 assumed to correspond to no elements of the initializer list. */
6688 complain);
6693 {
6694 /* This can happen with an invalid initializer for a flexible
6695 array member (c++/54441). */
6699 }
6703 /* [dcl.init.aggr]
6705 When a union is initialized with a brace-enclosed
6706 initializer, the braces shall only contain an
6707 initializer for the first member of the union. */
6711 continue_:
6713 {
6716 else
6718 }
6719 else
6721 }
6723 /* A trailing aggregate element that is a pack expansion is assumed to
6724 correspond to all remaining elements of the initializer list (if any). */
6726 {
6731 }
6734 }
6736 /* Subroutine of reshape_init_r. We're in a context where C99 initializer
6737 designators are not valid; either complain or return true to indicate
6738 that reshape_init_r should return error_mark_node. */
6740 static bool
6742 {
6744 {
6749 else
6751 }
6753 }
6755 /* Subroutine of reshape_init, which processes a single initializer (part of
6756 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
6757 iterator within the CONSTRUCTOR which points to the initializer to process.
6758 If this is the first initializer of the outermost CONSTRUCTOR node,
6759 FIRST_INITIALIZER_P is that CONSTRUCTOR; otherwise, it is NULL_TREE. */
6761 static tree
6763 tsubst_flags_t complain)
6764 {
6777 {
6778 /* A complex type can be initialized from one or two initializers,
6779 but braces are not elided. */
6782 {
6784 {
6787 else
6789 }
6790 }
6792 {
6800 }
6802 }
6804 /* A non-aggregate type is always initialized with a single
6805 initializer. */
6807 /* As is an array with dependent bound, which we can see
6808 during C++20 aggregate CTAD. */
6812 {
6813 /* It is invalid to initialize a non-aggregate type with a
6814 brace-enclosed initializer before C++0x.
6815 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
6816 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
6817 a CONSTRUCTOR (with a record type). */
6819 /* Don't complain about a capture-init. */
6822 {
6824 {
6826 {
6829 type);
6831 }
6834 && (BRACE_ENCLOSED_INITIALIZER_P
6836 {
6841 }
6842 }
6843 else
6845 }
6849 }
6851 /* "If T is a class type and the initializer list has a single element of
6852 type cv U, where U is T or a class derived from T, the object is
6853 initialized from that element." Even if T is an aggregate. */
6855 && first_initializer_p
6856 /* But not if it's a designated init. */
6860 {
6863 }
6865 /* [dcl.init.aggr]
6867 All implicit type conversions (clause _conv_) are considered when
6868 initializing the aggregate member with an initializer from an
6869 initializer-list. If the initializer can initialize a member,
6870 the member is initialized. Otherwise, if the member is itself a
6871 non-empty subaggregate, brace elision is assumed and the
6872 initializer is considered for the initialization of the first
6873 member of the subaggregate. */
6875 /* But don't try this for the first initializer, since that would be
6876 looking through the outermost braces; A a2 = { a1 }; is not a
6877 valid aggregate initialization. */
6878 && !first_initializer_p
6881 complain)))
6882 {
6885 }
6887 /* [dcl.init.string]
6889 A char array (whether plain char, signed char, or unsigned char)
6890 can be initialized by a string-literal (optionally enclosed in
6891 braces); a wchar_t array can be initialized by a wide
6892 string-literal (optionally enclosed in braces). */
6895 {
6898 reshape_iter stripd = {};
6900 /* Strip one level of braces if and only if they enclose a single
6901 element (as allowed by [dcl.init.string]). */
6905 {
6909 }
6911 /* If it's a string literal, then it's the initializer for the array
6912 as a whole. Otherwise, continue with normal initialization for
6913 array types (one value per array element). */
6915 {
6921 }
6922 }
6924 /* The following cases are about aggregates. If we are not within a full
6925 initializer already, and there is not a CONSTRUCTOR, it means that there
6926 is a missing set of braces (that is, we are processing the case for
6927 which reshape_init exists). */
6930 {
6932 {
6935 /* There is no need to call reshape_init for pointer-to-member
6936 function initializers, as they are always constructed correctly
6937 by the front end. Here we have e.g. {.__pfn=0B, .__delta=0},
6938 which is missing outermost braces. We should warn below, and
6940 /* For a nested compound literal, proceed to specialized routines,
6941 to handle initialization of arrays and similar. */
6944 /* A CONSTRUCTOR of the target's type is a previously
6945 digested initializer. */
6947 {
6950 }
6951 else
6952 {
6953 /* Something that hasn't been reshaped yet. */
6957 }
6958 }
6963 type);
6965 }
6967 /* Dispatch to specialized routines. */
6968 tree new_init;
6975 else
6983 }
6985 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
6986 brace-enclosed aggregate initializer.
6988 INIT is the CONSTRUCTOR containing the list of initializers describing
6989 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
6990 It may not presently match the shape of the TYPE; for example:
6992 struct S { int a; int b; };
6993 struct S a[] = { 1, 2, 3, 4 };
6995 Here INIT will hold a vector of four elements, rather than a
6996 vector of two elements, each itself a vector of two elements. This
6997 routine transforms INIT from the former form into the latter. The
6998 revised CONSTRUCTOR node is returned. */
7000 tree
7002 {
7004 reshape_iter d;
7005 tree new_init;
7011 /* An empty constructor does not need reshaping, and it is always a valid
7012 initializer. */
7016 /* Brace elision is not performed for a CONSTRUCTOR representing
7017 parenthesized aggregate initialization. */
7019 {
7021 /* If we're initializing a char array from a string-literal that is
7022 enclosed in braces, unwrap it here. */
7029 }
7031 /* Handle [dcl.init.list] direct-list-initialization from
7032 single element of enumeration with a fixed underlying type. */
7034 {
7038 {
7042 tf_warning_or_error);
7043 }
7044 else
7046 }
7048 /* Recurse on this CONSTRUCTOR. */
7056 /* Make sure all the element of the constructor were used. Otherwise,
7057 issue an error about exceeding initializers. */
7059 {
7063 }
7073 }
7075 /* Verify array initializer. Returns true if errors have been reported. */
7077 bool
7079 {
7082 /* Structured binding when initialized with an array type needs
7083 to have complete type. */
7088 {
7093 }
7095 /* The array type itself need not be complete, because the
7096 initializer may tell us how many elements are in the array.
7097 But, the elements of the array must be complete. */
7099 {
7103 else
7106 }
7112 /* A compound literal can't have variable size. */
7116 {
7119 }
7121 }
7123 /* Subroutine of check_initializer; args are passed down from that function.
7124 Set stmts_are_full_exprs_p to 1 across a call to build_aggr_init. */
7126 static tree
7129 {
7132 }
7134 /* Verify INIT (the initializer for DECL), and record the
7135 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
7136 grok_reference_init.
7138 If the return value is non-NULL, it is an expression that must be
7139 evaluated dynamically to initialize DECL. */
7141 static tree
7143 {
7144 tree type;
7146 tree core_type;
7148 /* Things that are going to be initialized need to have complete
7149 type. */
7153 {
7154 /* A variable with DECL_HAS_VALUE_EXPR_P set is just a placeholder,
7155 it doesn't have storage to be initialized. */
7158 }
7161 /* We will have already complained. */
7165 {
7168 }
7170 {
7175 }
7176 else
7177 /* There is no way to make a variable-sized class type in GNU C++. */
7181 {
7184 {
7186 {
7189 }
7191 {
7193 "scalar object %qD requires one element in "
7197 }
7198 }
7199 }
7202 {
7209 }
7211 ;
7214 {
7216 {
7219 }
7222 tf_warning_or_error);
7223 /* Do not reshape constructors of vectors (they don't need to be
7224 reshaped. */
7226 {
7228 {
7230 tf_warning_or_error);
7232 }
7234 {
7235 /* Don't reshape if the class has constructors. */
7238 "in C++98 %qD must be initialized by "
7240 decl);
7241 }
7243 {
7246 }
7247 else
7248 {
7251 }
7252 }
7253 /* [dcl.init] "Otherwise, if the destination type is an array, the object
7254 is initialized as follows..." So handle things like
7256 int a[](1, 2, 3);
7258 which is permitted in C++20 by P0960. */
7268 {
7271 /* We get here with code like `int a (2);' */
7273 tf_warning_or_error);
7274 }
7276 /* If DECL has an array type without a specific bound, deduce the
7277 array size from the initializer. */
7291 {
7294 /* A constructor call is a non-trivial initializer even if
7295 it isn't explicitly written. */
7299 /* If this is a constexpr initializer, expand_default_init will
7300 have returned an INIT_EXPR rather than a CALL_EXPR. In that
7301 case, pull the initializer back out and pass it down into
7302 store_init_value. */
7304 {
7311 else
7313 }
7315 {
7316 /* In C++20, the call to build_aggr_init could have created
7317 an INIT_EXPR with a CONSTRUCTOR as the RHS to handle
7318 A(1, 2). */
7321 /* Avoid leaking TARGET_EXPR into template trees. */
7326 /* Don't call digest_init; it's unnecessary and will complain
7327 about aggregate initialization of non-aggregate classes. */
7329 }
7332 {
7333 /* Declared constexpr or constinit, but no suitable initializer;
7334 massage init appropriately so we can pass it into
7335 store_init_value for the error. */
7338 {
7343 }
7345 }
7346 else
7348 }
7351 {
7357 {
7362 }
7374 }
7375 }
7376 else
7377 {
7385 tf_warning_or_error);
7386 }
7392 {
7393 /* We might have set these in cp_finish_decl. */
7396 }
7401 {
7409 else
7413 {
7417 }
7419 }
7422 }
7424 /* If DECL is not a local variable, give it RTL. */
7426 static void
7428 {
7432 /* Set the DECL_ASSEMBLER_NAME for the object. */
7434 {
7435 /* The `register' keyword, when used together with an
7436 asm-specification, indicates that the variable should be
7437 placed in a particular register. */
7439 {
7442 }
7443 else
7444 {
7451 /* We have to propagate the name to the ns-alias.
7452 This is horrible, as we're affecting a
7453 possibly-shared decl. Again, a one-true-decl
7454 model breaks down. */
7457 }
7458 }
7460 /* Handle non-variables up front. */
7462 {
7465 }
7467 /* If we see a class member here, it should be a static data
7468 member. */
7470 {
7472 /* An in-class declaration of a static data member should be
7473 external; it is only a declaration, and not a definition. */
7477 }
7479 /* We don't create any RTL for local variables. */
7483 /* We defer emission of local statics until the corresponding
7484 DECL_EXPR is expanded. But with constexpr its function might never
7485 be expanded, so go ahead and tell cgraph about the variable now. */
7490 /* Defer template instantiations. */
7495 /* If we're not deferring, go ahead and assemble the variable. */
7498 }
7500 /* walk_tree helper for wrap_temporary_cleanups, below. */
7502 static tree
7504 {
7505 /* Stop at types or full-expression boundaries. */
7508 {
7511 }
7514 {
7520 {
7522 /* Tell honor_protect_cleanup_actions to handle this as a separate
7523 cleanup. */
7526 }
7527 }
7530 }
7532 /* We're initializing a local variable which has a cleanup GUARD. If there
7533 are any temporaries used in the initializer INIT of this variable, we
7534 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
7535 variable will be cleaned up properly if one of them throws.
7537 Unfortunately, there's no way to express this properly in terms of
7538 nesting, as the regions for the temporaries overlap the region for the
7539 variable itself; if there are two temporaries, the variable needs to be
7540 the first thing destroyed if either of them throws. However, we only
7541 want to run the variable's cleanup if it actually got constructed. So
7542 we need to guard the temporary cleanups with the variable's cleanup if
7543 they are run on the normal path, but not if they are run on the
7544 exceptional path. We implement this by telling
7545 honor_protect_cleanup_actions to strip the variable cleanup from the
7546 exceptional path.
7548 Another approach could be to make the variable cleanup region enclose
7549 initialization, but depend on a flag to indicate that the variable is
7550 initialized; that's effectively what we do for arrays. But the current
7551 approach works fine for non-arrays, and has no code overhead in the usual
7552 case where the temporary destructors are noexcept. */
7554 static void
7556 {
7558 {
7559 /* An array cleanup region already encloses any temporary cleanups,
7560 don't wrap it around them again. */
7563 }
7565 }
7567 /* Generate code to initialize DECL (a local variable). */
7569 static void
7571 {
7573 tree cleanup;
7581 {
7582 /* If we used it already as memory, it must stay in memory. */
7586 }
7591 /* Compute and store the initial value. */
7596 /* Generate a cleanup, if necessary. */
7599 /* Perform the initialization. */
7601 {
7606 {
7607 /* Stick simple initializers in DECL_INITIAL so that
7608 -Wno-init-self works (c++/34772). */
7612 {
7616 OPT_Winit_self,
7618 }
7619 }
7620 else
7621 {
7624 /* If we're only initializing a single object, guard the
7625 destructors of any temporaries used in its initializer with
7626 its destructor. */
7635 saved_stmts_are_full_exprs_p;
7636 }
7637 }
7639 /* Set this to 0 so we can tell whether an aggregate which was
7640 initialized was ever used. Don't do this if it has a
7641 destructor, so we don't complain about the 'resource
7642 allocation is initialization' idiom. Now set
7643 attribute((unused)) on types so decls of that type will be
7644 marked used. (see TREE_USED, above.) */
7646 && ! already_used
7655 }
7657 /* DECL is a VAR_DECL for a compiler-generated variable with static
7658 storage duration (like a virtual table) whose initializer is a
7659 compile-time constant. Initialize the variable and provide it to the
7660 back end. */
7662 void
7664 {
7665 tree init;
7671 /* Mark the decl as constexpr so that we can access its content
7672 at compile time. */
7679 }
7681 /* INIT is the initializer for a variable, as represented by the
7682 parser. Returns true iff INIT is value-dependent. */
7684 static bool
7686 {
7688 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
7691 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
7692 {
7705 }
7706 else
7707 /* It must be a simple expression, e.g., int i = 3; */
7711 }
7713 // Returns true if a DECL is VAR_DECL with the concept specifier.
7716 {
7718 // Not all variables have DECL_LANG_SPECIFIC.
7721 }
7723 /* A helper function to be called via walk_tree. If any label exists
7724 under *TP, it is (going to be) forced. Set has_forced_label_in_static. */
7726 static tree
7728 {
7734 }
7736 /* Return true if DECL has either a trivial destructor, or for C++20
7737 is constexpr and has a constexpr destructor. */
7739 static bool
7741 {
7747 }
7751 /* Helper function of omp_declare_variant_finalize. Finalize one
7752 "omp declare variant base" attribute. Return true if it should be
7753 removed. */
7755 static bool
7757 {
7759 {
7764 }
7769 {
7773 /* FIXME, adjusting simd args unimplemented. */
7775 }
7778 location_t varid_loc
7787 releasing_vec args;
7796 else
7801 {
7803 /* In C++20, we may need to perform ADL for a template
7804 name. */
7807 {
7809 {
7813 tf_warning_or_error);
7814 }
7815 else
7817 }
7819 {
7825 {
7829 tf_warning_or_error);
7830 }
7831 }
7832 }
7837 else
7847 {
7850 {
7854 }
7859 {
7862 }
7863 else
7864 {
7870 }
7871 }
7873 {
7876 }
7879 }
7881 /* Helper function, finish up "omp declare variant base" attribute
7882 now that there is a DECL. ATTR is the first "omp declare variant base"
7883 attribute. */
7885 void
7887 {
7897 {
7900 }
7902 {
7905 }
7907 {
7910 }
7912 {
7915 }
7917 {
7920 }
7921 /* This loop is like private_lookup_attribute, except that it works
7922 with tree * rather than tree, as we might want to remove the
7923 attributes that are diagnosed as errorneous. */
7925 {
7930 {
7932 {
7935 }
7936 }
7938 }
7939 }
7941 /* Finish processing of a declaration;
7942 install its line number and initial value.
7943 If the length of an array type is not known before,
7944 it must be determined now, from the initial value, or it is an error.
7946 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
7947 true, then INIT is an integral constant expression.
7949 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
7950 if the (init) syntax was used. */
7952 void
7955 {
7956 tree type;
7961 tree auto_node;
7966 {
7970 }
7973 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
7983 /* Warn about register storage specifiers except when in GNU global
7984 or local register variable extension. */
7986 {
7989 "ISO C++17 does not allow %<register%> storage "
7991 else
7994 }
7996 /* If a name was specified, get the string. */
8002 bool in_class_decl
8003 = (current_class_type
8014 {
8015 tree d_init;
8017 {
8021 {
8022 /* init is null because we're deferring instantiating the
8023 initializer until we need it. Well, we need it now. */
8026 }
8029 }
8032 {
8036 tf_warning_or_error);
8038 }
8048 /* The outer template arguments might be needed for satisfaction.
8049 (For function scope variables, do_auto_deduction will obtain the
8050 outer template arguments from current_function_decl.) */
8058 {
8063 }
8065 }
8068 {
8071 {
8074 }
8075 }
8085 {
8087 ? TCTX_THREAD_STORAGE
8090 }
8093 {
8094 tree clone;
8096 {
8097 /* FIXME check this is 1st decl. */
8102 {
8106 }
8108 }
8110 {
8113 else
8115 }
8116 }
8119 {
8121 /* If DECL is a reference, then we want to know whether init is a
8122 reference constant; init_const_expr_p as passed tells us whether
8123 it's an rvalue constant. */
8127 {
8128 /* Set these flags now for templates. We'll update the flags in
8129 store_init_value for instantiations. */
8132 /* FIXME setting TREE_CONSTANT on refs breaks the back end. */
8135 }
8136 }
8140 /* #pragma omp declare variant on methods handled in finish_struct
8141 instead. */
8149 {
8152 /* Add this declaration to the statement-tree. */
8159 {
8162 }
8164 /* Generally, initializers in templates are expanded when the
8165 template is instantiated. But, if DECL is a variable constant
8166 then it can be used in future constant expressions, so its value
8167 must be available. */
8174 {
8177 }
8183 {
8184 /* This variable seems to be a non-dependent constant, so process
8185 its initializer. If check_initializer returns non-null the
8186 initialization wasn't constant after all. */
8187 tree init_code;
8193 }
8194 else
8195 {
8197 /* Try to deduce array size. */
8199 /* And complain about multiple initializers. */
8203 tf_warning_or_error);
8204 }
8210 {
8213 }
8216 {
8219 }
8221 }
8223 /* Just store non-static data member initializers for later. */
8227 /* Take care of TYPE_DECLs up front. */
8229 {
8232 {
8236 }
8238 /* If we have installed this as the canonical typedef for this
8239 type, and that type has not been defined yet, delay emitting
8240 the debug information for it, as we will emit it later. */
8246 at_eof);
8248 }
8250 /* A reference will be modified here, as it is initialized. */
8254 {
8257 }
8259 /* This needs to happen before extend_ref_init_temps. */
8261 {
8265 }
8268 {
8270 /* [dcl.constinit]/1 "The constinit specifier shall be applied
8271 only to a declaration of a variable with static or thread storage
8272 duration." */
8275 {
8277 "%<constinit%> can only be applied to a variable with "
8280 }
8282 /* If this is a local variable that will need a mangled name,
8283 register it now. We must do this before processing the
8284 initializer for the variable, since the initialization might
8285 require a guard variable, and since the mangled name of the
8286 guard variable will depend on the mangled name of this
8287 variable. */
8291 {
8292 /* The variable holding an anonymous union will have had its
8293 discriminator set in finish_anon_union, after which it's
8294 NAME will have been cleared. */
8297 /* Normally has_forced_label_in_static is set during GIMPLE
8298 lowering, but [cd]tors are never actually compiled directly.
8299 We need to set this early so we can deal with the label
8300 address extension. */
8304 {
8307 }
8308 /* And make sure it's in the symbol table for
8309 c_parse_final_cleanups to find. */
8311 }
8313 /* Convert the initializer to the type of DECL, if we have not
8314 already initialized DECL. */
8316 /* If !DECL_EXTERNAL then DECL is being defined. In the
8317 case of a static data member initialized inside the
8318 class-specifier, there can be an initializer even if DECL
8319 is *not* defined. */
8321 {
8325 /* Handle:
8327 [dcl.init]
8329 The memory occupied by any object of static storage
8330 duration is zero-initialized at program startup before
8331 any other initialization takes place.
8333 We cannot create an appropriate initializer until after
8334 the type of DECL is finalized. If DECL_INITIAL is set,
8335 then the DECL is statically initialized, and any
8336 necessary zero-initialization has already been performed. */
8341 /* Remember that the initialization for this variable has
8342 taken place. */
8344 /* This declaration is the definition of this variable,
8345 unless we are initializing a static data member within
8346 the class specifier. */
8349 }
8350 /* If the variable has an array type, lay out the type, even if
8351 there is no initializer. It is valid to index through the
8352 array, and we must get TYPE_ALIGN set correctly on the array
8353 type. */
8360 /* So decl is a global variable or a static member of a
8361 non local class. Record the types it uses
8362 so that we can decide later to emit debug info for them. */
8364 }
8366 /* Add this declaration to the statement-tree. This needs to happen
8367 after the call to check_initializer so that the DECL_EXPR for a
8368 reference temp is added before the DECL_EXPR for the reference itself. */
8370 {
8371 /* If we're building a variable sized type, and we might be
8372 reachable other than via the top of the current binding
8373 level, then create a new BIND_EXPR so that we deallocate
8374 the object at the right time. */
8379 {
8380 tree bind;
8385 }
8387 }
8389 /* Let the middle end know about variables and functions -- but not
8390 static data members in uninstantiated class templates. */
8392 {
8394 {
8397 /* Check again now that we have an initializer. */
8399 /* A class-scope constexpr variable with an out-of-class declaration.
8400 C++17 makes them implicitly inline, but still force it out. */
8406 }
8409 /* With -fmerge-all-constants, gimplify_init_constructor
8410 might add TREE_STATIC to the variable. */
8412 {
8413 /* If a TREE_READONLY variable needs initialization
8414 at runtime, it is no longer readonly and we need to
8415 avoid MEM_READONLY_P being set on RTL created for it. */
8417 {
8421 }
8425 /* Likewise if it needs destruction. */
8428 }
8432 /* Check for abstractness of the type. */
8437 /* No initialization required. */
8438 ;
8440 {
8442 {
8444 {
8445 /* An out-of-class default definition is defined at
8446 the point where it is explicitly defaulted. */
8451 }
8452 else
8456 decl);
8457 }
8458 /* else no initialization required. */
8459 }
8463 {
8464 /* check_initializer will have done any constant initialization. */
8465 }
8466 /* A variable definition. */
8468 /* Initialize the local variable. */
8471 /* If a variable is defined, and then a subsequent
8472 definition with external linkage is encountered, we will
8473 get here twice for the same variable. We want to avoid
8474 calling expand_static_init more than once. For variables
8475 that are not static data members, we can call
8476 expand_static_init only when we actually process the
8477 initializer. It is not legal to redeclare a static data
8478 member, so this issue does not arise in that case. */
8481 }
8483 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
8484 reference, insert it in the statement-tree now. */
8486 {
8488 {
8490 /* As in initialize_local_var. */
8492 }
8494 }
8503 {
8509 {
8513 }
8518 {
8524 {
8527 {
8531 }
8532 }
8533 }
8534 }
8536 /* This is the last point we can lower alignment so give the target the
8537 chance to do so. */
8544 }
8546 /* For class TYPE return itself or some its bases that contain
8547 any direct non-static data members. Return error_mark_node if an
8548 error has been diagnosed. */
8550 static tree
8552 {
8562 {
8566 else
8571 }
8573 {
8581 }
8582 else
8592 {
8597 {
8599 {
8604 }
8608 {
8610 "classes %qT and %qT have non-static data "
8613 }
8614 else
8616 }
8617 }
8619 }
8621 /* Return std::tuple_size<TYPE>::value. */
8623 static tree
8625 {
8641 else
8643 }
8645 /* Return std::tuple_element<I,TYPE>::type. */
8647 static tree
8649 {
8657 tf_warning_or_error);
8660 }
8662 /* Return e.get<i>() or get<i>(e). */
8664 static tree
8666 {
8673 /* [The id-expression] e is an lvalue if the type of the entity e is an
8674 lvalue reference and an xvalue otherwise. */
8683 /* To use a member get, member lookup must find at least one
8684 declaration that is a function template
8685 whose first template parameter is a non-type parameter. */
8687 {
8690 {
8694 {
8697 }
8698 }
8699 }
8702 {
8707 }
8708 else
8709 {
8715 }
8716 }
8718 /* It's impossible to recover the decltype of a tuple decomposition variable
8719 based on the actual type of the variable, so store it in a hash table. */
8723 tree
8725 {
8727 }
8729 /* Mangle a decomposition declaration if needed. Arguments like
8730 in cp_finish_decomp. */
8732 void
8734 {
8738 {
8746 }
8747 }
8749 /* Finish a decomposition declaration. DECL is the underlying declaration
8750 "e", FIRST is the head of a chain of decls for the individual identifiers
8751 chained through DECL_CHAIN in reverse order and COUNT is the number of
8752 those decls. */
8754 void
8756 {
8758 {
8759 error_out:
8761 {
8764 {
8767 }
8769 }
8773 }
8777 /* This happens for range for when not in templates.
8778 Still add the DECL_VALUE_EXPRs for later processing. */
8779 || (!processing_template_decl
8781 {
8783 {
8785 {
8791 }
8795 }
8797 }
8803 {
8806 }
8812 {
8818 {
8820 type);
8822 }
8823 }
8828 {
8829 tree nelts;
8834 {
8837 }
8840 {
8841 cnt_mismatch:
8846 else
8855 }
8858 {
8866 NULL_TREE);
8869 }
8870 }
8871 /* 2 GNU extensions. */
8873 {
8879 {
8887 t);
8890 }
8891 }
8893 {
8895 {
8898 }
8903 {
8913 NULL_TREE);
8916 }
8917 }
8919 {
8921 {
8925 }
8927 {
8934 }
8940 {
8951 {
8955 }
8957 {
8961 }
8962 /* Save the decltype away before reference collapse. */
8968 {
8969 /* In this case the names are variables, not just proxies. */
8972 }
8974 {
8978 }
8979 }
8980 /* Ignore reads from the underlying decl performed during initialization
8981 of the individual variables. If those will be read, we'll mark
8982 the underlying decl as read at that point. */
8984 }
8986 {
8989 }
8991 {
8994 }
8996 {
8999 }
9004 type);
9005 else
9006 {
9011 {
9015 }
9021 else
9022 eltscnt++;
9027 {
9031 }
9038 else
9039 {
9041 NULL_TREE);
9047 {
9050 }
9051 i++;
9052 }
9053 }
9055 {
9058 {
9063 }
9064 }
9065 }
9067 /* Returns a declaration for a VAR_DECL as if:
9069 extern "C" TYPE NAME;
9071 had been seen. Used to create compiler-generated global
9072 variables. */
9074 static tree
9076 {
9083 /* If the user has explicitly declared this variable (perhaps
9084 because the code we are compiling is part of a low-level runtime
9085 library), then it is possible that our declaration will be merged
9086 with theirs by pushdecl. */
9092 }
9094 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
9095 if "__cxa_atexit" is not being used) corresponding to the function
9096 to be called when the program exits. */
9098 static tree
9100 {
9101 tree fn_type;
9104 {
9105 tree arg_type;
9108 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
9110 else
9111 /* The parameter to "atexit" is "void (*)(void)". */
9117 }
9120 }
9122 /* Returns a pointer to the `atexit' function. Note that if
9123 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
9124 `__cxa_atexit' function specified in the IA64 C++ ABI. */
9126 static tree
9128 {
9129 tree atexit_fndecl;
9130 tree fn_type;
9131 tree fn_ptr_type;
9140 {
9141 /* The declaration for `__cxa_atexit' is:
9143 int __cxa_atexit (void (*)(void *), void *, void *)
9145 We build up the argument types and then the function type
9146 itself. */
9150 /* First, build the pointer-to-function type for the first
9151 argument. */
9153 /* Then, build the rest of the argument types. */
9156 {
9159 }
9160 else
9161 {
9164 }
9165 /* And the final __cxa_atexit type. */
9168 NULL_TREE);
9169 /* ... which needs noexcept. */
9172 {
9180 }
9181 else
9182 {
9185 }
9186 }
9187 else
9188 {
9189 /* The declaration for `atexit' is:
9191 int atexit (void (*)());
9193 We build up the argument types and then the function type
9194 itself. */
9196 /* Build the final atexit type. */
9199 /* ... which needs noexcept. */
9202 }
9204 /* Now, build the function declaration. */
9209 /* Install as hidden builtin so we're (a) more relaxed about
9210 exception spec matching and (b) will not give a confusing location
9211 in diagnostic and (c) won't magically appear in user-visible name
9212 lookups. */
9221 }
9223 /* Like get_atexit_node, but for thread-local cleanups. */
9225 static tree
9227 {
9228 /* The declaration for `__cxa_thread_atexit' is:
9230 int __cxa_thread_atexit (void (*)(void *), void *, void *) */
9234 NULL_TREE);
9236 /* Now, build the function declaration. */
9240 }
9242 /* Returns the __dso_handle VAR_DECL. */
9244 static tree
9246 {
9250 /* Declare the variable. */
9252 ptr_type_node);
9254 #ifdef HAVE_GAS_HIDDEN
9256 {
9259 }
9260 #endif
9263 }
9265 /* Begin a new function with internal linkage whose job will be simply
9266 to destroy some particular variable. */
9270 static tree
9272 {
9277 /* No need to mangle this. */
9280 /* Build the name of the function. */
9282 /* Build the function declaration. */
9286 /* It's a function with internal linkage, generated by the
9287 compiler. */
9290 /* Make the function `inline' so that it is only emitted if it is
9291 actually needed. It is unlikely that it will be inlined, since
9292 it is only called via a function pointer, but we avoid unnecessary
9293 emissions this way. */
9297 {
9298 /* Build the parameter. */
9303 }
9311 }
9313 /* Finish the cleanup function begun by start_cleanup_fn. */
9315 static void
9317 {
9321 }
9323 /* Generate code to handle the destruction of DECL, an object with
9324 static storage duration. */
9326 tree
9328 {
9329 tree cleanup;
9330 tree addr;
9331 tree compound_stmt;
9332 tree fcall;
9333 tree type;
9336 tree atex_node;
9344 {
9347 }
9349 /* If we're using "__cxa_atexit" (or "__cxa_thread_atexit" or
9350 "__aeabi_atexit"), and DECL is a class object, we can just pass the
9351 destructor to "__cxa_atexit"; we don't have to build a temporary
9352 function to do the cleanup. */
9353 dso_parm = (flag_use_cxa_atexit
9358 {
9361 /* Make sure it is accessible. */
9363 tf_warning_or_error);
9364 }
9365 else
9366 {
9367 /* Call build_cleanup before we enter the anonymous function so
9368 that any access checks will be done relative to the current
9369 scope, rather than the scope of the anonymous function. */
9372 /* Now start the function. */
9375 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
9376 to the original function, rather than the anonymous one. That
9377 will make the back end think that nested functions are in use,
9378 which causes confusion. */
9383 /* Create the body of the anonymous function. */
9388 }
9390 /* Call atexit with the cleanup function. */
9396 else
9400 {
9401 /* We must convert CLEANUP to the type that "__cxa_atexit"
9402 expects. */
9404 /* "__cxa_atexit" will pass the address of DECL to the
9405 cleanup function. */
9408 /* The declared type of the parameter to "__cxa_atexit" is
9409 "void *". For plain "T*", we could just let the
9410 machinery in cp_build_function_call convert it -- but if the
9411 type is "cv-qualified T *", then we need to convert it
9412 before passing it in, to avoid spurious errors. */
9414 }
9415 else
9416 /* Since the cleanup functions we build ignore the address
9417 they're given, there's no reason to pass the actual address
9418 in, and, in general, it's cheaper to pass NULL than any
9419 other value. */
9424 tf_warning_or_error);
9426 /* Just pass NULL to the dso handle parm if we don't actually
9427 have a DSO handle on this target. */
9429 else
9433 {
9436 {
9439 }
9440 else
9441 {
9444 }
9445 }
9446 else
9447 {
9450 }
9453 }
9455 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
9456 is its initializer. Generate code to handle the construction
9457 and destruction of DECL. */
9459 static void
9461 {
9465 /* Some variables require no dynamic initialization. */
9467 {
9468 /* Make sure the destructor is callable. */
9472 }
9476 {
9481 else
9486 {
9490 }
9492 }
9495 {
9496 /* Emit code to perform this initialization but once. */
9501 /* We don't need thread-safety code for thread-local vars. */
9505 /* Emit code to perform this initialization but once. This code
9506 looks like:
9508 static <type> guard;
9509 if (!__atomic_load (guard.first_byte)) {
9510 if (__cxa_guard_acquire (&guard)) {
9511 bool flag = false;
9512 try {
9513 // Do initialization.
9514 flag = true; __cxa_guard_release (&guard);
9515 // Register variable for destruction at end of program.
9516 } catch {
9517 if (!flag) __cxa_guard_abort (&guard);
9518 }
9519 }
9520 }
9522 Note that the `flag' variable is only set to 1 *after* the
9523 initialization is complete. This ensures that an exception,
9524 thrown during the construction, will cause the variable to
9525 reinitialized when we pass through this code again, as per:
9527 [stmt.dcl]
9529 If the initialization exits by throwing an exception, the
9530 initialization is not complete, so it will be tried again
9531 the next time control enters the declaration.
9533 This process should be thread-safe, too; multiple threads
9534 should not be able to initialize the variable more than
9535 once. */
9537 /* Create the guard variable. */
9540 /* Begin the conditional initialization. */
9547 {
9560 acquire_fn = push_library_fn
9563 NULL_TREE),
9568 NULL_TREE);
9571 ECF_NOTHROW);
9578 inner_if_stmt);
9586 void_node,
9590 /* Do the initialization itself. */
9596 /* Use atexit to register a function for destroying this static
9597 variable. Do this before calling __cxa_guard_release. */
9601 guard_addr));
9602 }
9603 else
9604 {
9607 /* Use atexit to register a function for destroying this static
9608 variable. */
9610 }
9615 {
9619 }
9624 }
9627 else
9629 }
9631 \f
9632 /* Make TYPE a complete type based on INITIAL_VALUE.
9633 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
9634 2 if there was no information (in which case assume 0 if DO_DEFAULT),
9635 3 if the initializer list is empty (in pedantic mode). */
9637 int
9639 {
9643 /* Don't get confused by a CONSTRUCTOR for some other type. */
9650 {
9651 /* An array of character type can be initialized from a
9652 brace-enclosed string constant so call reshape_init to
9653 remove the optional braces from a braced string literal. */
9657 tf_warning_or_error);
9659 /* If any of the elements are parameter packs, we can't actually
9660 complete this type now because the array size is dependent. */
9665 }
9669 /* We can create the array before the element type is complete, which
9670 means that we didn't have these two bits set in the original type
9671 either. In completing the type, we are expected to propagate these
9672 bits. See also complete_type which does the same thing for arrays
9673 of fixed size. */
9676 {
9681 }
9684 }
9686 /* As above, but either give an error or reject zero-size arrays, depending
9687 on COMPLAIN. */
9689 int
9692 {
9695 /* In SFINAE context we can't be lenient about zero-size arrays. */
9702 {
9708 {
9711 }
9715 }
9717 }
9718 \f
9719 /* Return zero if something is declared to be a member of type
9720 CTYPE when in the context of CUR_TYPE. STRING is the error
9721 message to print in that case. Otherwise, quietly return 1. */
9723 static int
9725 {
9727 {
9730 else
9733 }
9735 }
9736 \f
9737 /* Subroutine of `grokdeclarator'. */
9739 /* Generate errors possibly applicable for a given set of specifiers.
9740 This is for ARM $7.1.2. */
9742 static void
9751 {
9753 {
9797 }
9801 && !flag_noexcept_type
9807 }
9809 /* DECL is a member function or static data member and is presently
9810 being defined. Check that the definition is taking place in a
9811 valid namespace. */
9813 static void
9815 {
9816 /* These checks only apply to member functions and static data
9817 members. */
9819 /* We check for problems with specializations in pt.cc in
9820 check_specialization_namespace, where we can issue better
9821 diagnostics. */
9824 /* We check this in check_explicit_instantiation_namespace. */
9827 /* [class.mfct]
9829 A member function definition that appears outside of the
9830 class definition shall appear in a namespace scope enclosing
9831 the class definition.
9833 [class.static.data]
9835 The definition for a static data member shall appear in a
9836 namespace scope enclosing the member's class definition. */
9840 }
9842 /* Build a PARM_DECL for the "this" parameter of FN. TYPE is the
9843 METHOD_TYPE for a non-static member function; QUALS are the
9844 cv-qualifiers that apply to the function. */
9846 tree
9848 {
9849 tree this_type;
9850 tree qual_type;
9851 tree parm;
9852 cp_cv_quals this_quals;
9855 {
9856 this_type
9859 }
9860 else
9862 /* The `this' parameter is implicitly `const'; it cannot be
9863 assigned to. */
9869 }
9871 /* DECL is a static member function. Complain if it was declared
9872 with function-cv-quals. */
9874 static void
9876 {
9879 decl);
9880 }
9882 // Check that FN takes no arguments and returns bool.
9883 static void
9885 {
9886 // A constraint is nullary.
9891 // The declared return type of the concept shall be bool, and
9892 // it shall not be deduced from it definition.
9900 }
9902 /* Helper function. Replace the temporary this parameter injected
9903 during cp_finish_omp_declare_simd with the real this parameter. */
9905 static tree
9907 {
9916 }
9918 /* CTYPE is class type, or null if non-class.
9919 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
9920 or METHOD_TYPE.
9921 DECLARATOR is the function's name.
9922 PARMS is a chain of PARM_DECLs for the function.
9923 VIRTUALP is truthvalue of whether the function is virtual or not.
9924 FLAGS are to be passed through to `grokclassfn'.
9925 QUALS are qualifiers indicating whether the function is `const'
9926 or `volatile'.
9927 RAISES is a list of exceptions that this function can raise.
9928 CHECK is 1 if we must find this method in CTYPE, 0 if we should
9929 not look, and -1 if we should not call `grokclassfn' at all.
9931 SFK is the kind of special function (if any) for the new function.
9933 Returns `NULL_TREE' if something goes wrong, after issuing
9934 applicable error messages. */
9936 static tree
9938 tree type,
9939 tree declarator,
9940 tree parms,
9941 tree orig_declarator,
9943 tree decl_reqs,
9946 cp_cv_quals quals,
9947 cp_ref_qualifier rqual,
9948 tree raises,
9954 special_function_kind sfk,
9958 tree in_namespace,
9960 location_t location)
9961 {
9962 tree decl;
9964 tree t;
9969 /* Was the concept specifier present? */
9972 /* Concept declarations must have a corresponding definition. */
9974 {
9977 }
9983 /* Set the constraints on the declaration. */
9985 {
9990 && (current_template_depth
9993 {
9995 /* If there are no template parameters, something must have
9996 gone wrong. */
9998 else
10000 }
10003 {
10006 }
10007 /* C++20 CA378: Remove non-templated constrained functions. */
10009 && (block_local
10010 || (!flag_concepts_ts
10011 && (!processing_template_decl
10013 {
10016 }
10018 }
10021 {
10026 /* Allocate space to hold the vptr bit if needed. */
10028 }
10034 /* Propagate volatile out from type to decl. */
10038 /* Setup decl according to sfk. */
10040 {
10053 }
10056 {
10060 orig_declarator);
10061 else
10062 {
10067 {
10068 /* Something like `template <class T> friend void f<T>()'. */
10070 "invalid use of template-id %qD in declaration "
10072 orig_declarator);
10074 }
10077 /* A friend declaration of the form friend void f<>(). Record
10078 the information in the TEMPLATE_ID_EXPR. */
10087 {
10089 "default arguments are not allowed in declaration "
10091 decl);
10093 }
10096 {
10098 "%<inline%> is not allowed in declaration of friend "
10100 decl);
10102 }
10103 }
10104 }
10106 /* C++17 11.3.6/4: "If a friend declaration specifies a default argument
10107 expression, that declaration shall be a definition..." */
10109 {
10113 {
10115 "friend declaration of %qD specifies default "
10118 }
10119 }
10121 /* If this decl has namespace scope, set that up. */
10126 else
10129 /* `main' and builtins have implicit 'C' linkage. */
10144 /* Should probably propagate const out from type to decl I bet (mrs). */
10146 {
10149 }
10158 {
10174 }
10176 /* Members of anonymous types and local classes have no linkage; make
10177 them internal. If a typedef is made later, this will be changed. */
10183 {
10184 /* [basic.link]: A name with no linkage (notably, the name of a class
10185 or enumeration declared in a local scope) shall not be used to
10186 declare an entity with linkage.
10188 DR 757 relaxes this restriction for C++0x. */
10190 }
10194 {
10197 }
10199 /* If the declaration was declared inline, mark it as such. */
10201 {
10205 }
10209 {
10212 }
10214 // If the concept declaration specifier was found, check
10215 // that the declaration satisfies the necessary requirements.
10217 {
10220 }
10224 {
10227 TYPE_UNQUALIFIED,
10228 REF_QUAL_NONE);
10231 {
10235 decl);
10237 }
10240 {
10244 decl);
10246 }
10247 }
10250 {
10254 {
10259 }
10262 {
10266 }
10270 }
10275 {
10279 /* [over.literal]/6: Literal operators shall not have C linkage. */
10281 {
10285 }
10288 {
10291 {
10294 }
10298 {
10302 }
10304 {
10308 }
10309 /* 17.6.3.3.5 */
10313 "literal operator suffixes not preceded by %<_%>"
10315 }
10316 else
10317 {
10320 }
10321 }
10324 /* Make the init_value nonzero so pushdecl knows this is not
10325 tentative. error_mark_node is replaced later with the BLOCK. */
10332 {
10333 /* Adjust "omp declare simd" attributes. */
10336 {
10337 tree attr;
10340 {
10345 {
10347 cl = c_omp_declare_simd_clauses_to_numbers
10351 else
10353 }
10354 }
10355 }
10356 }
10358 /* Caller will do the rest of this. */
10365 /* 12.4/3 */
10375 template_count,
10387 {
10390 }
10392 /* Check main's type after attributes have been applied. */
10394 {
10396 integer_type_node))
10397 {
10399 tree newtype;
10404 }
10407 }
10410 {
10412 (current_template_depth
10414 ? current_template_parms
10421 {
10422 tree ok;
10423 tree pushed_scope;
10426 /* Because grokfndecl is always supposed to return a
10427 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
10428 here. We depend on our callers to figure out that its
10429 really a template that's being returned. */
10434 {
10435 /* Remove the `this' parm added by grokclassfn. */
10438 }
10440 {
10443 }
10445 {
10450 }
10452 /* Since we've smashed OLD_DECL to its
10453 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
10457 /* Attempt to merge the declarations. This can fail, in
10458 the case of some invalid specialization declarations. */
10464 {
10468 }
10472 }
10473 }
10485 }
10487 /* decl is a FUNCTION_DECL.
10488 specifiers are the parsed virt-specifiers.
10490 Set flags to reflect the virt-specifiers.
10492 Returns decl. */
10494 static tree
10496 {
10504 }
10506 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
10507 the linkage that DECL will receive in the object file. */
10509 static void
10511 {
10512 /* A static data member always has static storage duration and
10513 external linkage. Note that static data members are forbidden in
10514 local classes -- the only situation in which a class has
10515 non-external linkage. */
10518 /* For non-template classes, static data members are always put
10519 out in exactly those files where they are defined, just as
10520 with ordinary namespace-scope variables. */
10523 }
10525 /* Create a VAR_DECL named NAME with the indicated TYPE.
10527 If SCOPE is non-NULL, it is the class type or namespace containing
10528 the variable. If SCOPE is NULL, the variable should is created in
10529 the innermost enclosing scope. */
10531 static tree
10533 tree name,
10534 tree orig_declarator,
10541 tree scope,
10542 location_t location)
10543 {
10544 tree decl;
10545 tree explicit_scope;
10552 /* Compute the scope in which to place the variable, but remember
10553 whether or not that scope was explicitly specified by the user. */
10556 {
10557 /* An explicit "extern" specifier indicates a namespace-scope
10558 variable. */
10563 }
10567 template, we need DECL_LANG_SPECIFIC. */
10569 /* Similarly for namespace-scope variables with language linkage
10570 other than C++. */
10573 /* Similarly for static data members. */
10575 /* Similarly for explicit specializations. */
10576 || (orig_declarator
10579 else
10584 else
10588 {
10591 }
10594 {
10596 /* This function is only called with out-of-class definitions. */
10599 }
10600 /* At top level, either `static' or no s.c. makes a definition
10601 (perhaps tentative), and absence of `static' makes it public. */
10603 {
10606 || ! constp
10607 || volatilep
10610 }
10611 /* Not at top level, only `static' makes a static definition. */
10612 else
10613 {
10616 }
10621 {
10623 {
10627 }
10630 }
10632 /* If the type of the decl has no linkage, make sure that we'll
10633 notice that in mark_used. */
10642 {
10643 /* [basic.link]: A name with no linkage (notably, the name of a class
10644 or enumeration declared in a local scope) shall not be used to
10645 declare an entity with linkage.
10647 DR 757 relaxes this restriction for C++0x. */
10650 }
10651 else
10660 /* Check that the variable can be safely declared as a concept.
10661 Note that this also forbids explicit specializations. */
10663 {
10665 {
10669 }
10671 {
10675 }
10676 else
10682 {
10685 }
10686 }
10689 {
10694 }
10696 // Handle explicit specializations and instantiations of variable templates.
10702 }
10704 /* Create and return a canonical pointer to member function type, for
10705 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
10707 tree
10709 {
10711 tree t;
10716 /* Make sure that we always have the unqualified pointer-to-member
10717 type first. */
10719 {
10722 }
10724 /* If a canonical type already exists for this type, use it. We use
10725 this method instead of type_hash_canon, because it only does a
10726 simple equality check on the list of field members. */
10734 /* Let the front end know this is a pointer to member function. */
10742 delta_type_node);
10749 /* Zap out the name so that the back end will give us the debugging
10750 information for this anonymous RECORD_TYPE. */
10753 /* Cache this pointer-to-member type so that we can find it again
10754 later. */
10763 }
10765 /* Create and return a pointer to data member type. */
10767 tree
10769 {
10771 {
10776 }
10777 else
10778 {
10781 }
10782 }
10784 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
10785 Check to see that the definition is valid. Issue appropriate error
10786 messages. */
10788 static void
10790 {
10791 /* Avoid redundant diagnostics on out-of-class definitions. */
10793 ;
10794 /* Can't check yet if we don't know the type. */
10796 ;
10797 /* If DECL is declared constexpr, we'll do the appropriate checks
10798 in check_initializer. Similarly for inline static data members. */
10802 ;
10804 {
10807 "in-class initialization of static data member %q#D of "
10811 "%<constexpr%> needed for in-class initialization of "
10813 else
10815 "in-class initialization of static data member %q#D of "
10817 }
10818 /* Motion 10 at San Diego: If a static const integral data member is
10819 initialized with an integral constant expression, the initializer
10820 may appear either in the declaration (within the class), or in
10821 the definition, but not both. If it appears in the class, the
10822 member is a member constant. The file-scope definition is always
10823 required. */
10826 "invalid in-class initialization of static data member "
10828 type);
10831 "ISO C++ forbids in-class initialization of non-const "
10833 decl);
10836 "ISO C++ forbids initialization of member constant "
10838 }
10840 /* *expr_p is part of the TYPE_SIZE of a variably-sized array. If any
10841 SAVE_EXPRs in *expr_p wrap expressions with side-effects, break those
10842 expressions out into temporary variables so that walk_tree doesn't
10843 step into them (c++/15764). */
10845 static tree
10847 {
10851 {
10857 }
10861 }
10863 /* Entry point for the above. */
10865 static void
10867 {
10869 /* Break out any function calls into temporary variables. */
10871 }
10873 /* Reduce a SIZEOF_EXPR to its value. */
10875 tree
10877 {
10878 tree r;
10887 else
10894 }
10896 /* Given the SIZE (i.e., number of elements) in an array, compute
10897 an appropriate index type for the array. If non-NULL, NAME is
10898 the name of the entity being declared. */
10900 static tree
10902 tsubst_flags_t complain)
10903 {
10907 /* The type of the index being computed. */
10908 tree itype;
10910 /* The original numeric size as seen in the source code before
10911 conversion to size_t. */
10917 {
10922 /* In C++98, we mark a non-constant array bound with a magic
10924 else
10925 {
10927 /* Pedantically a constant expression is required here and so
10928 __builtin_is_constant_evaluated () should fold to true if it
10929 is successfully folded into a constant. */
10935 }
10940 /* The array bound must be an integer type. */
10943 {
10949 else
10952 }
10953 }
10955 /* A type is dependent if it is...an array type constructed from any
10956 dependent type or whose size is specified by a constant expression
10957 that is value-dependent. */
10958 /* We can only call value_dependent_expression_p on integral constant
10959 expressions. */
10963 {
10964 /* Just build the index type and mark that it requires
10965 structural equality checks. */
10966 in_template:
10973 }
10976 {
10979 {
10983 else
10986 }
10988 /* We might have lost the TREE_CONSTANT flag e.g. when we are
10989 folding a conversion from a pointer to integral type. In that
10991 else
10992 /* Use the folded result for VLAs, too; it will have resolved
10993 SIZEOF_EXPR. */
10995 }
10997 /* Normally, the array-bound will be a constant. */
10999 {
11000 /* The size to use in diagnostics that reflects the constant
11001 size used in the source, rather than SIZE massaged above. */
11004 /* If the original size before conversion to size_t was signed
11005 and negative, convert it to ssizetype to restore the sign. */
11009 {
11012 /* Clear the overflow bit that may have been set as a result
11013 of the conversion from the sizetype of the new size to
11014 ssizetype. */
11016 }
11018 /* Verify that the array has a positive number of elements
11019 and issue the appropriate diagnostic if it doesn't. */
11021 {
11025 }
11026 /* As an extension we allow zero-sized arrays. */
11028 {
11030 /* We must fail if performing argument deduction (as
11031 indicated by the state of complain), so that
11032 another substitution can be found. */
11037 else
11040 }
11041 }
11043 /* We don't allow VLAs at non-function scopes, or during
11044 tentative template substitution. */
11047 {
11050 /* `(int) &fn' is not a valid array bound. */
11054 name);
11055 else
11058 }
11060 {
11064 else
11067 }
11069 {
11073 else
11076 }
11080 else
11081 {
11083 {
11084 /* A variable sized array. Arrange for the SAVE_EXPR on the inside
11085 of the MINUS_EXPR, which allows the -1 to get folded with the +1
11086 that happens when building TYPE_SIZE. */
11089 }
11091 /* Compute the index of the largest element in the array. It is
11092 one less than the number of elements in the array. We save
11093 and restore PROCESSING_TEMPLATE_DECL so that computations in
11094 cp_build_binary_op will be appropriately folded. */
11095 {
11096 processing_template_decl_sentinel s;
11098 MINUS_EXPR,
11101 complain),
11102 complain);
11104 }
11107 {
11110 {
11111 /* We have to add 1 -- in the ubsan routine we generate
11112 LE_EXPR rather than LT_EXPR. */
11117 }
11118 }
11119 /* Make sure that there was no overflow when creating to a signed
11120 index type. (For example, on a 32-bit machine, an array with
11121 size 2^32 - 1 is too big.) */
11124 {
11129 }
11130 }
11132 /* Create and return the appropriate index type. */
11135 /* If the index type were dependent, we would have returned early, so
11136 remember that it isn't. */
11140 }
11142 tree
11144 {
11146 }
11148 /* Returns the scope (if any) in which the entity declared by
11149 DECLARATOR will be located. If the entity was declared with an
11150 unqualified name, NULL_TREE is returned. */
11152 tree
11154 {
11158 /* If the declarator-id is a SCOPE_REF, the scope in which the
11159 declaration occurs is the first operand. */
11164 /* Otherwise, the declarator is not a qualified name; the entity will
11165 be declared in the current scope. */
11167 }
11169 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
11170 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
11171 with this type. */
11173 static tree
11175 {
11178 /* If things have already gone awry, bail now. */
11182 /* [dcl.type.class.deduct] prohibits forming an array of placeholder
11183 for a deduced class type. */
11185 {
11189 else
11192 }
11194 /* If there are some types which cannot be array elements,
11195 issue an error-message and return. */
11197 {
11201 else
11208 else
11215 else
11222 name);
11223 else
11229 }
11235 /* [dcl.array]
11237 The constant expressions that specify the bounds of the arrays
11238 can be omitted only for the first member of the sequence. */
11240 {
11244 name);
11245 else
11250 }
11252 /* Figure out the index type for the array. */
11254 {
11256 tf_warning_or_error);
11259 {
11262 }
11263 }
11266 }
11268 /* Returns the smallest location that is not UNKNOWN_LOCATION. */
11270 static location_t
11272 {
11278 }
11280 /* Returns the smallest location != UNKNOWN_LOCATION among the
11281 three stored in LOCATIONS[ds_const], LOCATIONS[ds_volatile],
11282 and LOCATIONS[ds_restrict]. */
11284 static location_t
11286 {
11299 }
11301 /* Returns the smallest among the latter and locations[ds_type_spec]. */
11303 static location_t
11305 {
11308 }
11310 static location_t
11312 {
11315 }
11317 /* Check that it's OK to declare a function with the indicated TYPE
11318 and TYPE_QUALS. SFK indicates the kind of special function (if any)
11319 that this function is. OPTYPE is the type given in a conversion
11320 operator declaration, or the class type for a constructor/destructor.
11321 Returns the actual return type of the function; that may be different
11322 than TYPE if an error occurs, or for certain special functions. */
11324 static tree
11326 tree type,
11327 tree optype,
11330 {
11332 {
11343 else
11355 /* We can't use the proper return type here because we run into
11356 problems with ambiguous bases and covariant returns. */
11359 else
11369 "qualifiers are not allowed on declaration of "
11381 "qualifiers are not allowed on declaration of "
11384 {
11388 }
11389 else
11399 }
11402 }
11404 /* A variable or data member (whose unqualified name is IDENTIFIER)
11405 has been declared with the indicated TYPE. If the TYPE is not
11406 acceptable, issue an error message and return a type to use for
11407 error-recovery purposes. */
11409 tree
11411 {
11413 {
11417 {
11420 identifier);
11421 }
11422 else
11425 }
11428 }
11430 /* Handle declaring DECL as an inline variable. */
11432 static void
11434 {
11437 {
11441 }
11446 {
11449 }
11450 }
11453 /* Assign a typedef-given name to a class or enumeration type declared
11454 as anonymous at first. This was split out of grokdeclarator
11455 because it is also used in libcc1. */
11457 void
11459 {
11462 /* Replace the anonymous decl with the real decl. Be careful not to
11463 rename other typedefs (such as the self-reference) of type. */
11469 /* If this is a typedef within a template class, the nested
11470 type is a (non-primary) template. The name for the
11471 template needs updating as well. */
11475 /* Adjust linkage now that we aren't unnamed anymore. */
11478 /* FIXME remangle member functions; member functions of a
11479 type with external linkage have external linkage. */
11481 /* Check that our job is done, and that it would fail if we
11482 attempted to do it again. */
11484 }
11486 /* Check that decltype(auto) was well-formed: only plain decltype(auto)
11487 is allowed. TYPE might contain a decltype(auto). Returns true if
11488 there was a problem, false otherwise. */
11490 static bool
11492 {
11494 {
11496 {
11498 {
11502 }
11504 {
11507 }
11508 }
11509 }
11511 }
11513 /* Given declspecs and a declarator (abstract or otherwise), determine
11514 the name and type of the object declared and construct a DECL node
11515 for it.
11517 DECLSPECS points to the representation of declaration-specifier
11518 sequence that precedes declarator.
11520 DECL_CONTEXT says which syntactic context this declaration is in:
11521 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
11522 FUNCDEF for a function definition. Like NORMAL but a few different
11523 error messages in each case. Return value may be zero meaning
11524 this definition is too screwy to try to parse.
11525 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
11526 handle member functions (which have FIELD context).
11527 Return value may be zero meaning this definition is too screwy to
11528 try to parse.
11529 PARM for a parameter declaration (either within a function prototype
11530 or before a function body). Make a PARM_DECL, or return void_type_node.
11531 TPARM for a template parameter declaration.
11532 CATCHPARM for a parameter declaration before a catch clause.
11533 TYPENAME if for a typename (in a cast or sizeof).
11534 Don't make a DECL node; just return the ..._TYPE node.
11535 FIELD for a struct or union field; make a FIELD_DECL.
11536 BITFIELD for a field with specified width.
11538 INITIALIZED is as for start_decl.
11540 ATTRLIST is a pointer to the list of attributes, which may be NULL
11541 if there are none; *ATTRLIST may be modified if attributes from inside
11542 the declarator should be applied to the declaration.
11544 When this function is called, scoping variables (such as
11545 CURRENT_CLASS_TYPE) should reflect the scope in which the
11546 declaration occurs, not the scope in which the new declaration will
11547 be placed. For example, on:
11549 void S::f() { ... }
11551 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
11552 should not be `S'.
11554 Returns a DECL (if a declarator is present), a TYPE (if there is no
11555 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
11556 error occurs. */
11558 tree
11564 {
11577 /* True if this declarator is a function definition. */
11581 #if 0
11582 /* See the code below that used this. */
11584 #endif
11586 /* Keep track of what sort of function is being processed
11587 so that we can warn about default return values, or explicit
11588 return values which do not match prescribed defaults. */
11594 /* cv-qualifiers that apply to the declarator, for a declaration of
11595 a member function. */
11597 /* virt-specifiers that apply to the declarator, for a declaration of
11598 a member function. */
11600 /* ref-qualifier that applies to the declarator, for a declaration of
11601 a member function. */
11603 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
11610 /* The unqualified name of the declarator; either an
11611 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
11612 tree unqualified_id;
11613 /* The class type, if any, in which this entity is located,
11614 or NULL_TREE if none. Note that this value may be different from
11615 the current class type; for example if an attempt is made to declare
11616 "A::f" inside "B", this value will be "A". */
11618 /* The NAMESPACE_DECL for the namespace in which this entity is
11619 located. If an unqualified name is used to declare the entity,
11620 this value will be NULL_TREE, even if the entity is located at
11621 namespace scope. */
11623 cp_storage_class storage_class;
11646 // Was concept_p specified? Note that ds_concept
11647 // implies ds_constexpr!
11669 location_t id_loc;
11670 location_t init_loc;
11672 {
11675 }
11676 else
11679 /* Look inside a declarator for the name being declared
11680 and get it as a string, for an error message. */
11682 id_declarator;
11684 {
11689 {
11693 {
11697 }
11701 {
11707 {
11712 {
11713 /* [dcl.meaning]
11715 A declarator-id shall not be qualified except
11716 for ...
11718 None of the cases are permitted in block
11719 scope. */
11722 decl);
11726 else
11730 }
11732 {
11735 {
11739 }
11741 && current_class_type
11743 current_class_type))
11744 {
11749 }
11750 }
11753 }
11755 {
11757 {
11759 {
11763 }
11766 {
11770 }
11777 }
11781 {
11787 }
11788 /* Fall through. */
11795 {
11797 dname);
11799 }
11802 else
11803 {
11810 else
11812 }
11817 }
11819 }
11836 }
11839 }
11841 /* [dcl.fct.edf]
11843 The declarator in a function-definition shall have the form
11844 D1 ( parameter-declaration-clause) ... */
11846 {
11849 }
11854 {
11857 }
11860 {
11863 {
11866 }
11869 {
11871 {
11874 }
11876 {
11879 }
11880 }
11881 }
11883 /* Anything declared one level down from the top level
11884 must be one of the parameters of a function
11885 (because the body is at least two levels down). */
11887 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
11888 by not allowing C++ class definitions to specify their parameters
11889 with xdecls (must be spec.d in the parmlist).
11891 Since we now wait to push a class scope until we are sure that
11892 we are in a legitimate method context, we must set oldcname
11893 explicitly (since current_class_name is not yet alive).
11895 We also want to avoid calling this a PARM if it is in a namespace. */
11898 {
11904 }
11910 {
11914 }
11917 {
11921 }
11924 {
11928 }
11931 {
11935 }
11938 {
11942 }
11944 /* [dcl.spec]/2 "At most one of the constexpr, consteval, and constinit
11945 keywords shall appear in a decl-specifier-seq." */
11947 {
11951 "can use at most one of the %<constinit%> and %<constexpr%> "
11954 }
11956 /* If there were multiple types specified in the decl-specifier-seq,
11957 issue an error message. */
11959 {
11963 }
11966 {
11971 }
11973 /* Extract the basic type from the decl-specifier-seq. */
11976 {
11979 }
11981 /* Ignore erroneous attributes. */
11985 /* An object declared as __attribute__((unavailable)) suppresses
11986 any reports of being declared with unavailable or deprecated
11987 items. An object declared as __attribute__((deprecated))
11988 suppresses warnings of uses of other deprecated items. */
11997 {
12003 }
12004 /* No type at all: default to `int', and set DEFAULTED_INT
12005 because it was not a user-defined typedef. */
12007 {
12009 {
12010 /* These imply 'int'. */
12013 }
12014 /* If we just have "complex", it is equivalent to "complex double". */
12017 {
12020 "ISO C++ does not support plain %<complex%> meaning "
12022 }
12023 }
12024 /* Gather flags. */
12028 #if 0
12029 /* See the code below that used this. */
12032 #endif
12037 else
12041 {
12043 ctor_return_type,
12044 type_quals,
12047 }
12049 {
12054 /* We handle `main' specially here, because 'main () { }' is so
12055 common. With no options, it is allowed. With -Wreturn-type,
12056 it is a warning. It is only an error with -pedantic-errors. */
12057 is_main = (funcdef_flag
12070 name);
12074 else
12079 /* FIXME we should be able to propagate the error_mark_node as is
12080 for other contexts too. */
12082 else
12084 }
12089 {
12091 {
12096 }
12097 /* Don't pedwarn if the alternate "__intN__" form has been used instead
12098 of "__intN". */
12103 }
12105 /* Now process the modifiers that were specified
12106 and check for invalid combinations. */
12108 /* Long double is a special combination. */
12110 {
12114 }
12116 /* Check all other uses of type modifiers. */
12119 {
12120 location_t loc;
12123 {
12126 }
12128 {
12131 }
12133 {
12136 }
12138 {
12141 }
12143 {
12146 }
12151 {
12156 }
12158 {
12162 }
12172 {
12174 {
12178 }
12181 else
12183 }
12184 else
12187 /* Discard the type modifiers if they are invalid. */
12189 {
12195 }
12196 }
12198 /* Decide whether an integer type is signed or not.
12199 Optionally treat bitfields as signed by default. */
12201 /* [class.bit]
12203 It is implementation-defined whether a plain (neither
12204 explicitly signed or unsigned) char, short, int, or long
12205 bit-field is signed or unsigned.
12207 Naturally, we extend this to long long as well. Note that
12208 this does not include wchar_t. */
12210 && !signed_p
12211 /* A typedef for plain `int' without `signed' can be
12212 controlled just like plain `int', but a typedef for
12213 `signed int' cannot be so controlled. */
12214 && !(typedef_decl
12218 {
12231 else
12233 }
12246 {
12250 /* If a modifier is specified, the resulting complex is the complex
12251 form of TYPE. E.g, "complex short" is "complex short int". */
12260 else
12262 }
12264 /* If we're using the injected-class-name to form a compound type or a
12265 declaration, replace it with the underlying class so we don't get
12266 redundant typedefs in the debug output. But if we are returning the
12267 type unchanged, leave it alone so that it's available to
12268 maybe_get_template_decl_from_type_decl. */
12276 type = cp_build_qualified_type_real
12280 /* We might have ignored or rejected some of the qualifiers. */
12287 {
12292 }
12303 /* Treat class-scope deduction guides as static member functions
12304 so that they get a FUNCTION_TYPE instead of a METHOD_TYPE. */
12308 {
12310 {
12317 }
12319 {
12323 "declared both %<virtual%> and %<constexpr%> only in "
12325 }
12326 }
12329 /* Issue errors about use of storage classes for parameters. */
12331 {
12333 {
12337 }
12339 {
12343 name);
12345 }
12349 {
12354 }
12356 /* Function parameters cannot be concept. */
12358 {
12363 }
12364 /* Function parameters cannot be constexpr. If we saw one, moan
12365 and pretend it wasn't there. */
12367 {
12371 }
12373 {
12377 }
12379 {
12383 }
12384 }
12386 /* Give error if `virtual' is used outside of class declaration. */
12389 {
12393 }
12396 {
12413 "structured binding declaration can be %qs only in "
12415 declspecs->gnu_thread_keyword_p
12420 /* [dcl.struct.bind] "A cv that includes volatile is deprecated." */
12425 {
12435 "structured binding declaration can be %qs only in "
12452 }
12455 {
12457 {
12461 "type must be cv-qualified %<auto%> or reference to "
12463 }
12466 }
12473 {
12476 }
12477 }
12479 /* Static anonymous unions are dealt with here. */
12485 /* Warn about storage classes that are invalid for certain
12486 kinds of declarations (parameters, typenames, etc.). */
12488 && ((storage_class
12492 {
12493 location_t loc
12498 }
12503 {
12507 ;
12509 ;
12511 /* C++ allows static class elements. */
12513 /* C++ also allows inlines and signed and unsigned elements,
12514 but in those cases we don't come in here. */
12515 ;
12516 else
12517 {
12518 location_t loc
12525 else
12532 }
12533 }
12538 {
12542 }
12546 {
12552 /* When thread_local is applied to a variable of block scope the
12553 storage-class-specifier static is implied if it does not appear
12554 explicitly. */
12557 }
12560 {
12563 "storage class specifiers invalid in friend function "
12567 }
12571 else
12572 {
12575 {
12588 }
12589 }
12592 {
12597 }
12599 /* Determine the type of the entity declared by recurring on the
12600 declarator. */
12602 {
12604 tree attrs;
12611 {
12623 /* Assume that any attributes that get applied late to
12624 templates will DTRT when applied to the declaration
12625 as a whole. */
12629 attr_flags);
12631 }
12635 /* We don't want to warn in parameter context because we don't
12636 yet know if the parse will succeed, and this might turn out
12637 to be a constructor call. */
12640 && !typedef_p
12642 /* If the type is class-like and the inner name used a
12643 global namespace qualifier, we need the parens.
12644 Unfortunately all we can tell is whether a qualified name
12645 was used or not. */
12646 && !(inner_declarator
12651 {
12654 name))
12655 {
12660 }
12661 }
12666 {
12677 /* [dcl.array]/1:
12679 The optional attribute-specifier-seq appertains to the
12680 array. */
12686 {
12687 tree arg_types;
12690 /* Declaring a function type. */
12692 /* Pick up type qualifiers which should be applied to `this'. */
12694 /* Pick up virt-specifiers. */
12696 /* And ref-qualifier, too */
12698 /* And tx-qualifier. */
12700 /* Pick up the exception specifications. */
12702 /* If the exception-specification is ill-formed, let's pretend
12703 there wasn't one. */
12711 /* Say it's a definition only for the CALL_EXPR
12712 closest to the identifier. */
12715 /* Handle a late-specified return type. */
12718 {
12720 {
12727 {
12729 "%<auto%> type specifier without "
12732 "deduced return type only available "
12734 }
12736 {
12740 }
12741 }
12743 {
12745 "return type has %qT as its type rather "
12748 }
12750 {
12753 "%qs function with trailing return type "
12754 "has %<decltype(auto)%> as its type "
12756 else
12760 }
12766 {
12768 {
12775 }
12777 {
12779 "for %qT must have trailing return "
12784 }
12790 else
12794 }
12795 }
12798 {
12802 /* Not using maybe_warn_cpp0x because this should
12803 always be an error. */
12805 "trailing return type only available "
12807 else
12809 "return type not declared with %<auto%> "
12812 }
12818 {
12821 }
12824 {
12828 /* [dcl.fct] "A volatile-qualified return type is
12829 deprecated." */
12832 "%<volatile%>-qualified return type is "
12835 /* We now know that the TYPE_QUALS don't apply to the
12836 decl, but to its return type. */
12838 }
12840 /* Error about some types functions can't return. */
12843 {
12847 }
12849 {
12853 }
12855 {
12857 "%<constinit%> on function return type is not "
12860 }
12867 && funcdecl_p
12873 {
12874 /* We are within a class's scope. If our declarator name
12875 is the same as the class name, and we are defining
12876 a function, then it is a constructor/destructor, and
12877 therefore returns a void type. */
12879 /* ISO C++ 12.4/2. A destructor may not be declared
12880 const or volatile. A destructor may not be static.
12881 A destructor may not be declared with ref-qualifier.
12883 ISO C++ 12.1. A constructor may not be declared
12884 const or volatile. A constructor may not be
12885 virtual. A constructor may not be static.
12886 A constructor may not be declared with ref-qualifier. */
12895 {
12900 }
12903 {
12909 }
12913 current_class_type,
12914 flags))
12918 {
12919 /* It's a constructor. */
12923 {
12927 }
12931 }
12934 }
12936 {
12938 {
12939 /* Cannot be both friend and virtual. */
12944 }
12949 {
12951 "cannot define friend function %qs in a local "
12954 }
12955 /* [class.friend]/6: A function can be defined in a friend
12956 declaration if the function name is unqualified. */
12958 {
12961 "friend function definition %qs cannot have "
12963 else
12965 "friend function definition %qs cannot have "
12967 in_namespace);
12968 }
12969 }
12971 {
12973 {
12976 }
12979 }
12981 {
12984 }
12991 pushed_scope
13003 {
13008 }
13014 {
13016 /* transaction_safe applies to the type, but
13017 transaction_safe_dynamic applies to the function. */
13020 else
13022 }
13024 /* [dcl.fct]/2:
13026 The optional attribute-specifier-seq appertains to
13027 the function type. */
13032 }
13038 /* Filter out pointers-to-references and references-to-references.
13039 We can get these if a TYPE_DECL is used. */
13042 {
13044 {
13047 }
13049 /* In C++0x, we allow reference to reference declarations
13050 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
13051 and template type arguments [14.3.1/4 temp.arg.type]. The
13052 check for direct reference to reference declarations, which
13053 are still forbidden, occurs below. Reasoning behind the change
13054 can be found in DR106, DR540, and the rvalue reference
13055 proposals. */
13057 {
13060 }
13061 }
13063 {
13068 }
13070 /* We now know that the TYPE_QUALS don't apply to the decl,
13071 but to the target of the pointer. */
13074 /* This code used to handle METHOD_TYPE, but I don't think it's
13075 possible to get it here anymore. */
13079 {
13083 memfn_quals,
13084 rqual);
13090 }
13098 type);
13100 /* When the pointed-to type involves components of variable size,
13101 care must be taken to ensure that the size evaluation code is
13102 emitted early enough to dominate all the possible later uses
13103 and late enough for the variables on which it depends to have
13104 been assigned.
13106 This is expected to happen automatically when the pointed-to
13107 type has a name/declaration of it's own, but special attention
13108 is required if the type is anonymous.
13110 We handle the NORMAL and FIELD contexts here by inserting a
13111 dummy statement that just evaluates the size at a safe point
13112 and ensures it is not deferred until e.g. within a deeper
13113 conditional context (c++/43555).
13115 We expect nothing to be needed here for PARM or TYPENAME.
13116 Evaluating the size at this point for TYPENAME would
13117 actually be incorrect, as we might be in the middle of an
13118 expression with side effects on the pointed-to type size
13119 "arguments" prior to the pointer declaration point and the
13120 size evaluation could end up prior to the side effects. */
13126 {
13130 }
13133 {
13134 /* In C++0x, the type we are creating a reference to might be
13135 a typedef which is itself a reference type. In that case,
13136 we follow the reference collapsing rules in
13137 [7.1.3/8 dcl.typedef] to create the final reference type:
13139 "If a typedef TD names a type that is a reference to a type
13140 T, an attempt to create the type 'lvalue reference to cv TD'
13141 creates the type 'lvalue reference to T,' while an attempt
13142 to create the type "rvalue reference to cv TD' creates the
13143 type TD."
13144 */
13148 {
13151 else
13153 }
13154 else
13155 type = cp_build_reference_type
13158 /* In C++0x, we need this check for direct reference to
13159 reference declarations, which are forbidden by
13160 [8.3.2/5 dcl.ref]. Reference to reference declarations
13161 are only allowed indirectly through typedefs and template
13162 type arguments. Example:
13164 void foo(int & &); // invalid ref-to-ref decl
13166 typedef int & int_ref;
13167 void foo(int_ref &); // valid ref-to-ref decl
13168 */
13172 }
13176 {
13180 /* We will already have complained. */
13182 else
13184 type);
13185 }
13186 else
13189 /* Process a list of type modifier keywords (such as
13190 const or volatile) that were given inside the `*' or `&'. */
13193 {
13194 type
13198 }
13200 /* Apply C++11 attributes to the pointer, and not to the
13201 type pointed to. This is unlike what is done for GNU
13202 attributes above. It is to comply with [dcl.ptr]/1:
13204 [the optional attribute-specifier-seq (7.6.1) appertains
13205 to the pointer and not to the object pointed to]. */
13218 }
13219 }
13224 /* Don't check this if it can be the artifical decltype(auto)
13225 we created when building a constraint in a compound-requirement:
13226 that the type-constraint is plain is going to be checked in
13227 cp_parser_compound_requirement. */
13232 /* A `constexpr' specifier used in an object declaration declares
13233 the object as `const'. */
13235 {
13236 /* DR1688 says that a `constexpr' specifier in combination with
13237 `volatile' is valid. */
13240 {
13243 }
13244 }
13249 {
13251 unqualified_id);
13253 }
13255 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
13256 qualified with a class-name, turn it into a METHOD_TYPE, unless
13257 we know that the function is static. We take advantage of this
13258 opportunity to do other processing that pertains to entities
13259 explicitly declared to be class members. Note that if DECLARATOR
13260 is non-NULL, we know it is a cdk_id declarator; otherwise, we
13261 would not have exited the loop above. */
13266 {
13272 {
13274 {
13276 "member functions are implicitly "
13279 }
13280 else
13283 }
13285 can skip the following checks. */
13288 qualifying type must certainly be complete. */
13289 funcdef_flag
13290 /* A friend declaration of "T::f" is OK, even if
13291 "T" is a template parameter. But, if this
13292 function is not a friend, the qualifying type
13293 must be a class. */
13295 /* For a declaration, the type need not be
13296 complete, if either it is dependent (since there
13297 is no meaningful definition of complete in that
13298 case) or the qualifying class is currently being
13299 defined. */
13302 /* Check that the qualifying type is complete. */
13306 {
13309 {
13317 }
13318 }
13320 {
13324 }
13325 }
13330 /* Now TYPE has the actual type. */
13333 {
13336 else
13338 }
13344 {
13345 /* [dcl.meaning]/1: The optional attribute-specifier-seq following
13346 a declarator-id appertains to the entity that is declared. */
13349 else
13350 /* We should have already diagnosed the issue (c++/78344). */
13352 }
13354 /* Handle parameter packs. */
13356 {
13358 /* Turn the type into a pack expansion.*/
13360 else
13362 }
13365 && !processing_template_decl
13367 {
13371 else
13375 }
13378 {
13379 /* [dcl.fct.spec] (C++11) The explicit specifier shall be used only
13380 in the declaration of a constructor or conversion function within
13381 a class definition. */
13388 else
13390 "only declarations of constructors and conversion operators "
13393 }
13396 {
13399 {
13401 name);
13403 }
13405 {
13408 name);
13410 }
13412 {
13414 name);
13416 }
13418 {
13420 name);
13422 }
13424 {
13426 name);
13428 }
13430 {
13432 name);
13434 }
13435 }
13437 /* If this is declaring a typedef name, return a TYPE_DECL. */
13439 {
13441 tree decl;
13444 {
13448 else
13452 }
13454 /* This declaration:
13456 typedef void f(int) const;
13458 declares a function type which is not a member of any
13459 particular class, but which is cv-qualified; for
13460 example "f S::*" declares a pointer to a const-qualified
13461 member function of S. We record the cv-qualification in the
13462 function type. */
13464 {
13467 /* We have now dealt with these qualifiers. */
13470 }
13473 {
13477 else
13481 }
13487 {
13490 }
13494 else
13498 {
13502 /* The TYPE_DECL is "abstract" because there will be
13503 clones of this constructor/destructor, and there will
13504 be copies of this TYPE_DECL generated in those
13505 clones. The decloning optimization (for space) may
13506 revert this subsequently if it determines that
13507 the clones should share a common implementation. */
13511 }
13516 unqualified_id);
13518 /* If the user declares "typedef struct {...} foo" then the
13519 struct will have an anonymous name. Fill that name in now.
13520 Nothing can refer to it, so nothing needs know about the name
13521 change. */
13523 && unqualified_id
13542 /* Acknowledge that this was written:
13543 `using analias = atype;'. */
13547 }
13549 /* Detect the case of an array type of unspecified size
13550 which came, as such, direct from a typedef name.
13551 We must copy the type, so that the array's domain can be
13552 individually set by the object's initializer. */
13559 /* Detect where we're using a typedef of function type to declare a
13560 function. PARMS will not be set, so we must create it now. */
13563 {
13565 tree args;
13570 {
13576 }
13581 {
13582 /* The qualifiers on the function type become the qualifiers on
13583 the non-static member function. */
13588 }
13589 }
13591 /* If this is a type name (such as, in a cast or sizeof),
13592 compute the type and return it now. */
13595 {
13596 /* Note that here we don't care about type_quals. */
13598 /* Special case: "friend class foo" looks like a TYPENAME context. */
13600 {
13602 {
13605 }
13608 {
13609 /* Don't allow friend declaration without a class-key. */
13616 else
13619 type);
13620 }
13622 /* Only try to do this stuff if we didn't already give up. */
13624 {
13625 /* A friendly class? */
13629 else
13631 type);
13634 }
13635 }
13637 {
13644 /* Core issue #547: need to allow this in template type args.
13645 Allow it in general in C++11 for alias-declarations. */
13649 else
13651 }
13657 }
13661 && ! bitfield
13663 {
13666 }
13669 {
13670 /* Only functions may be declared using an operator-function-id. */
13672 {
13675 }
13680 type);
13681 }
13683 /* We don't check parameter types here because we can emit a better
13684 error message later. */
13686 {
13690 }
13692 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
13693 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
13696 {
13702 {
13704 {
13709 {
13710 auto_diagnostic_group g;
13712 "class template placeholder %qE not permitted "
13717 }
13718 else
13721 }
13722 else
13725 }
13727 /* A parameter declared as an array of T is really a pointer to T.
13728 One declared as a function is really a pointer to a function.
13729 One declared as a member is really a pointer to member. */
13732 {
13733 /* Transfer const-ness of array into that of type pointed to. */
13737 }
13740 }
13743 && !(unqualified_id
13746 {
13752 }
13754 {
13758 {
13766 }
13768 {
13771 {
13777 else
13781 }
13783 /* The C99 flexible array extension. */
13786 {
13790 {
13793 }
13794 else
13795 {
13796 /* Array is a flexible member. */
13800 else
13804 /* Flexible array member has a null domain. */
13806 }
13807 }
13810 {
13811 /* Happens when declaring arrays of sizes which
13812 are error_mark_node, for example. */
13814 }
13816 {
13817 /* Something like struct S { int N::j; }; */
13820 }
13822 {
13824 tree function_context;
13827 {
13828 /* This should never happen in pure C++ (the check
13829 could be an assert). It could happen in
13830 Objective-C++ if someone writes invalid code that
13831 uses a function declaration for an instance
13832 variable or property (instance variables and
13833 properties are parsed as FIELD_DECLs, but they are
13834 part of an Objective-C class, not a C++ class).
13835 That code is invalid and is caught by this
13836 check. */
13838 {
13840 unqualified_id);
13842 }
13844 /* ``A union may [ ... ] not [ have ] virtual functions.''
13845 ARM 9.5 */
13847 {
13850 unqualified_id);
13852 }
13857 {
13859 "%qD cannot be declared %<virtual%>, since it "
13862 }
13863 }
13865 /* Check that the name used for a destructor makes sense. */
13867 {
13871 {
13876 }
13879 {
13883 }
13885 {
13889 }
13891 {
13893 "%<constexpr%> destructors only available"
13896 }
13898 {
13902 }
13903 }
13905 {
13910 }
13913 {
13917 }
13919 {
13923 }
13927 {
13931 }
13934 {
13937 {
13943 }
13944 }
13946 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
13947 function_context
13956 parms,
13957 unqualified_id,
13958 declspecs,
13959 reqs,
13971 #if 0
13972 /* This clobbers the attrs stored in `decl' from `attrlist'. */
13973 /* The decl and setting of decl_attr is also turned off. */
13975 #endif
13977 /* [class.conv.ctor]
13979 A constructor declared without the function-specifier
13980 explicit that can be called with a single parameter
13981 specifies a conversion from the type of its first
13982 parameter to the type of its class. Such a constructor
13983 is called a converting constructor. */
13989 }
13991 && ((current_class_type
13997 {
14000 {
14002 {
14006 }
14007 else
14012 }
14013 }
14015 staticp
14016 ? TCTX_STATIC_STORAGE
14018 {
14021 }
14022 else
14023 {
14025 {
14028 "%qE is neither function nor member function; "
14030 else
14034 }
14036 }
14039 {
14040 /* Packages tend to use GNU attributes on friends, so we only
14041 warn for standard attributes. */
14043 {
14048 }
14049 /* Friends are treated specially. */
14053 {
14057 /* Kludge: We need funcdef_flag to be true in do_friend for
14058 in-class defaulted functions, but that breaks grokfndecl.
14059 So set it here. */
14063 {
14064 decl = check_explicit_specialization
14069 }
14074 }
14075 else
14077 }
14079 /* Structure field. It may not be a function, except for C++. */
14082 {
14084 {
14085 /* C++ allows static class members. All other work
14086 for this is done by grokfield. */
14095 {
14097 "%<constexpr%> static data member %qD must "
14100 }
14111 /* Even if there is an in-class initialization, DECL
14112 is considered undefined until an out-of-class
14113 definition is provided, unless this is an inline
14114 variable. */
14118 {
14124 }
14126 /* Set the constraints on the declaration. */
14130 {
14131 tree tmpl_reqs
14135 }
14136 }
14137 else
14138 {
14140 {
14146 }
14148 {
14153 }
14155 {
14160 }
14162 {
14167 }
14174 {
14177 }
14180 {
14181 /* An attempt is being made to initialize a non-static
14182 member. This is new in C++11. */
14185 /* If this has been parsed with static storage class, but
14186 errors forced staticp to be cleared, ensure NSDMI is
14187 not present. */
14190 }
14191 }
14198 }
14199 }
14201 {
14202 tree original_name;
14210 else
14212 // FIXME:gcc_assert (original_name == dname);
14220 name);
14222 {
14226 name);
14227 else
14229 "storage class %<thread_local%> invalid for "
14231 }
14236 /* Function declaration not at top level.
14237 Storage classes other than `extern' are not allowed
14238 and `extern' makes no difference. */
14243 {
14246 "%<static%> specifier invalid for function %qs "
14248 else
14250 "%<inline%> specifier invalid for function %qs "
14252 }
14255 {
14257 {
14260 }
14263 {
14268 }
14269 }
14273 {
14277 }
14279 /* Record whether the function is public. */
14284 declspecs,
14287 publicp,
14291 sfk,
14292 funcdef_flag,
14293 late_return_type_p,
14295 id_loc);
14302 {
14305 /* Don't allow a static member function in a class, and forbid
14306 declaring main to be static. */
14308 {
14312 }
14314 {
14315 /* 7.1.1: There can be no static function declarations within a
14316 block. */
14320 }
14323 {
14326 }
14327 }
14330 }
14331 else
14332 {
14333 /* It's a variable. */
14335 /* An uninitialized decl with `extern' is a reference. */
14337 declspecs,
14338 initialized,
14339 type_quals,
14340 inlinep,
14341 concept_p,
14342 template_count,
14344 id_loc);
14354 {
14357 {
14359 "%<static%> may not be used when defining "
14363 }
14365 {
14368 }
14370 {
14372 "cannot explicitly declare member %q#D to have "
14375 }
14376 }
14378 {
14380 "declaration of %<constexpr%> variable %qD "
14383 }
14385 {
14389 }
14394 {
14399 }
14400 }
14405 {
14409 }
14412 {
14414 {
14415 /* It's common practice (and completely valid) to have a const
14416 be initialized and declared extern. */
14420 }
14421 else
14422 {
14426 }
14427 }
14429 /* Record `register' declaration for warnings on &
14430 and in case doing stupid register allocation. */
14433 {
14435 /* Warn about register storage specifiers on PARM_DECLs. */
14437 {
14440 "ISO C++17 does not allow %<register%> storage "
14442 else
14445 }
14446 }
14453 {
14454 /* Set constexpr flag on vars (functions got it in grokfndecl). */
14457 /* And the constinit flag (which only applies to variables). */
14460 }
14462 /* Record constancy and volatility on the DECL itself . There's
14463 no need to do this when processing a template; we'll do this
14464 for the instantiated declaration based on the type of DECL. */
14469 }
14470 }
14471 \f
14472 /* Subroutine of start_function. Ensure that each of the parameter
14473 types (as listed in PARMS) is complete, as is required for a
14474 function definition. */
14476 static void
14478 {
14480 {
14485 {
14492 }
14493 else
14494 /* grokparms or complete_type_or_else will have already issued
14495 an error. */
14497 }
14498 }
14500 /* Returns nonzero if T is a local variable. */
14502 int
14504 {
14513 }
14515 /* Like local_variable_p, but suitable for use as a tree-walking
14516 function. */
14518 static tree
14521 {
14523 {
14524 /* DR 2082 permits local variables in unevaluated contexts
14525 within a default argument. */
14528 }
14537 }
14539 /* Check that ARG, which is a default-argument expression for a
14540 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
14541 something goes wrong. DECL may also be a _TYPE node, rather than a
14542 DECL, if there is no DECL available. */
14544 tree
14546 {
14547 tree var;
14548 tree decl_type;
14551 /* We get a DEFERRED_PARSE when looking at an in-class declaration
14552 with a default argument. Ignore the argument for now; we'll
14553 deal with it after the class is complete. */
14557 {
14560 }
14561 else
14568 /* Something already went wrong. There's no need to check
14569 further. */
14572 /* [dcl.fct.default]
14574 A default argument expression is implicitly converted to the
14575 parameter type. */
14577 /* Avoid digest_init clobbering the initializer. */
14580 LOOKUP_IMPLICIT);
14583 /* Avoid redundant -Wzero-as-null-pointer-constant warnings at
14584 the call sites. */
14587 /* Don't lose side-effects as in PR90473. */
14591 /* [dcl.fct.default]
14593 Local variables shall not be used in default argument
14594 expressions.
14596 The keyword `this' shall not be used in a default argument of a
14597 member function. */
14600 {
14602 {
14606 else
14608 }
14610 }
14612 /* All is well. */
14614 }
14616 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
14618 static tree
14620 {
14625 {
14628 else
14629 {
14632 }
14633 }
14635 /* Do warn about using typedefs to a deprecated class. */
14647 return type_is_deprecated
14651 }
14653 /* Returns an unavailable type used within TYPE, or NULL_TREE if none. */
14655 static tree
14657 {
14662 {
14665 else
14666 {
14669 }
14670 }
14672 /* Do warn about using typedefs to a deprecated class. */
14684 return type_is_unavailable
14688 }
14690 /* Decode the list of parameter types for a function type.
14691 Given the list of things declared inside the parens,
14692 return a list of types.
14694 If this parameter does not end with an ellipsis, we append
14695 void_list_node.
14697 *PARMS is set to the chain of PARM_DECLs created. */
14699 tree
14701 {
14704 tree parm;
14708 {
14717 {
14720 }
14724 {
14726 && !init
14729 /* DR 577: A parameter list consisting of a single
14730 unnamed parameter of non-dependent type 'void'. */
14734 "invalid use of cv-qualified type %qT in "
14736 else
14738 "invalid use of type %<void%> in parameter "
14740 /* It's not a good idea to actually create parameters of
14741 type `void'; other parts of the compiler assume that a
14742 void type terminates the parameter list. */
14745 }
14748 {
14750 {
14754 }
14757 {
14761 }
14763 /* [dcl.fct] "A parameter with volatile-qualified type is
14764 deprecated." */
14767 "%<volatile%>-qualified parameter is "
14770 /* Top-level qualifiers on the parameters are
14771 ignored for function types. */
14774 {
14778 }
14780 {
14781 /* Before C++17 DR 393:
14782 [dcl.fct]/6, parameter types cannot contain pointers
14783 (references) to arrays of unknown bound. */
14788 {
14796 }
14799 ptr
14805 }
14809 }
14814 }
14824 /* We had parm errors, recover by giving the function (...) type. */
14828 }
14830 \f
14831 /* D is a constructor or overloaded `operator='.
14833 Let T be the class in which D is declared. Then, this function
14834 returns:
14836 -1 if D's is an ill-formed constructor or copy assignment operator
14837 whose first parameter is of type `T'.
14838 0 if D is not a copy constructor or copy assignment
14839 operator.
14840 1 if D is a copy constructor or copy assignment operator whose
14841 first parameter is a reference to non-const qualified T.
14842 2 if D is a copy constructor or copy assignment operator whose
14843 first parameter is a reference to const qualified T.
14845 This function can be used as a predicate. Positive values indicate
14846 a copy constructor and nonzero values indicate a copy assignment
14847 operator. */
14849 int
14851 {
14852 tree args;
14853 tree arg_type;
14861 /* Instantiations of template member functions are never copy
14862 functions. Note that member functions of templated classes are
14863 represented as template functions internally, and we must
14864 accept those as copy functions. */
14880 {
14881 /* Pass by value copy assignment operator. */
14883 }
14887 {
14890 }
14891 else
14897 /* There are more non-optional args. */
14901 }
14903 /* D is a constructor or overloaded `operator='.
14905 Let T be the class in which D is declared. Then, this function
14906 returns true when D is a move constructor or move assignment
14907 operator, false otherwise. */
14909 bool
14911 {
14915 /* There are no move constructors if we are in C++98 mode. */
14921 /* Instantiations of template member functions are never move
14922 functions. Note that member functions of templated classes are
14923 represented as template functions internally, and we must
14924 accept those as move functions. */
14928 }
14930 /* D is a constructor or overloaded `operator='.
14932 Then, this function returns true when D has the same signature as a move
14933 constructor or move assignment operator (because either it is such a
14934 ctor/op= or it is a template specialization with the same signature),
14935 false otherwise. */
14937 bool
14939 {
14940 tree args;
14941 tree arg_type;
14965 /* There are more non-optional args. */
14969 }
14971 /* Remember any special properties of member function DECL. */
14973 void
14975 {
14976 tree class_type;
14984 {
14991 {
14992 /* [class.copy]
14994 A non-template constructor for class X is a copy
14995 constructor if its first parameter is of type X&, const
14996 X&, volatile X& or const volatile X&, and either there
14997 are no other parameters or else all other parameters have
14998 default arguments. */
15002 }
15013 }
15015 {
15016 /* [class.copy]
15018 A non-template assignment operator for class X is a copy
15019 assignment operator if its parameter is of type X, X&, const
15020 X&, volatile X& or const volatile X&. */
15025 {
15029 }
15030 }
15034 /* Destructors are handled in check_methods. */
15035 }
15037 /* Check a constructor DECL has the correct form. Complains
15038 if the class has a constructor of the form X(X). */
15040 bool
15042 {
15046 {
15047 /* [class.copy]
15049 A declaration of a constructor for a class X is ill-formed if
15050 its first parameter is of type (optionally cv-qualified) X
15051 and either there are no other parameters or else all other
15052 parameters have default arguments.
15054 We *don't* complain about member template instantiations that
15055 have this form, though; they can occur as we try to decide
15056 what constructor to use during overload resolution. Since
15057 overload resolution will never prefer such a constructor to
15058 the non-template copy constructor (which is either explicitly
15059 or implicitly defined), there's no need to worry about their
15060 existence. Theoretically, they should never even be
15061 instantiated, but that's hard to forestall. */
15066 }
15069 }
15071 /* DECL is a declaration for an overloaded or conversion operator. If
15072 COMPLAIN is true, errors are issued for invalid declarations. */
15074 bool
15076 {
15086 tree_code operator_code;
15089 {
15090 /* Conversion operators are TYPE_EXPR for the purposes of this
15091 function. */
15094 }
15095 else
15096 {
15103 }
15106 {
15107 /* operator new and operator delete are quite special. */
15110 {
15129 }
15131 /* [basic.std.dynamic.allocation]/1:
15133 A program is ill-formed if an allocation function is declared
15134 in a namespace scope other than global scope or declared
15135 static in global scope.
15137 The same also holds true for deallocation functions. */
15139 {
15141 {
15143 decl);
15145 }
15148 {
15151 }
15152 }
15155 {
15158 }
15159 else
15160 {
15163 }
15166 }
15168 /* An operator function must either be a non-static member function
15169 or have at least one parameter of a class, a reference to a class,
15170 an enumeration, or a reference to an enumeration. 13.4.0.6 */
15172 {
15178 {
15181 }
15184 {
15188 }
15191 {
15193 {
15198 }
15204 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
15205 because these checks are performed even on template
15206 functions. */
15210 }
15211 }
15214 /* There are no further restrictions on the arguments to an overloaded
15215 "operator ()". */
15219 {
15220 /* 13.4.0.3 */
15223 }
15225 /* Count the number of arguments and check for ellipsis. */
15228 {
15230 {
15231 /* Variadic. */
15236 decl);
15238 }
15240 }
15242 /* Verify correct number of arguments. */
15244 {
15247 {
15248 /* We have a unary instance of an ambi-ary op. Remap to the
15249 unary one. */
15255 }
15257 {
15258 /* This was an ambiguous operator but is invalid. */
15260 methodp
15264 }
15267 && ! processing_template_decl
15268 /* x++ and x--'s second argument must be an int. */
15270 integer_type_node))
15271 {
15273 methodp
15276 decl);
15278 }
15283 {
15285 methodp
15289 }
15294 {
15298 methodp
15302 }
15307 }
15309 /* There can be no default arguments. */
15313 {
15317 }
15319 /* At this point the declaration is well-formed. It may not be
15320 sensible though. */
15322 /* Check member function warnings only on the in-class declaration.
15323 There's no point warning on an out-of-class definition. */
15327 /* Warn about conversion operators that will never be used. */
15331 {
15342 {
15345 ref
15350 class_type);
15351 /* Don't force t to be complete here. */
15356 ref
15362 }
15363 }
15368 /* Effective C++ rules below. */
15370 /* More Effective C++ rule 7. */
15377 /* More Effective C++ rule 6. */
15382 {
15391 {
15396 }
15397 else
15398 {
15402 }
15403 }
15405 /* Effective C++ rule 23. */
15416 }
15417 \f
15418 /* Return a string giving the keyword associate with CODE. */
15422 {
15424 {
15437 }
15438 }
15440 /* Name lookup in an elaborated-type-specifier (after the keyword
15441 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
15442 elaborated-type-specifier is invalid, issue a diagnostic and return
15443 error_mark_node; otherwise, return the *_TYPE to which it referred.
15444 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
15446 tree
15448 tree decl,
15450 {
15451 tree type;
15453 /* In the case of:
15455 struct S { struct S *p; };
15457 name lookup will find the TYPE_DECL for the implicit "S::S"
15458 typedef. Adjust for that here. */
15464 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
15465 is false for this case as well. */
15467 {
15471 }
15472 /* Accept template template parameters. */
15476 ;
15477 /* [dcl.type.elab]
15479 If the identifier resolves to a typedef-name or the
15480 simple-template-id resolves to an alias template
15481 specialization, the elaborated-type-specifier is ill-formed.
15483 In other words, the only legitimate declaration to use in the
15484 elaborated type specifier is the implicit typedef created when
15485 the type is declared. */
15489 {
15493 else
15498 }
15503 {
15507 }
15510 {
15514 }
15518 {
15519 /* If a class template appears as elaborated type specifier
15520 without a template header such as:
15522 template <class T> class C {};
15523 void f(class C); // No template header here
15525 then the required template argument is missing. */
15530 }
15533 }
15535 /* Lookup NAME of an elaborated type specifier according to SCOPE and
15536 issue diagnostics if necessary. Return *_TYPE node upon success,
15537 NULL_TREE when the NAME is not found, and ERROR_MARK_NODE for type
15538 error. */
15540 static tree
15543 {
15544 tree decl;
15546 {
15547 /* First try ordinary name lookup, ignoring hidden class name
15548 injected via friend declaration. */
15551 /* If that fails, the name will be placed in the smallest
15552 non-class, non-function-prototype scope according to 3.3.1/5.
15553 We may already have a hidden name declared as friend in this
15554 scope. So lookup again but not ignoring hidden names.
15555 If we find one, that name will be made visible rather than
15556 creating a new tag. */
15559 }
15560 else
15564 /* We found nothing. */
15568 {
15572 }
15575 && !template_header_p
15577 {
15582 }
15585 /* If scope is TAG_how::CURRENT_ONLY we're defining a class,
15586 so ignore a template template parameter. */
15591 /* Found not-a-type. */
15594 /* Look for invalid nested type:
15595 class C {
15596 class C {};
15597 }; */
15599 {
15603 }
15605 /* Two cases we need to consider when deciding if a class
15606 template is allowed as an elaborated type specifier:
15607 1. It is a self reference to its own class.
15608 2. It comes with a template header.
15610 For example:
15612 template <class T> class C {
15613 class C *c1; // DECL_SELF_REFERENCE_P is true
15614 class D;
15615 };
15616 template <class U> class C; // template_header_p is true
15617 template <class T> class C<T>::D {
15618 class C *c2; // DECL_SELF_REFERENCE_P is true
15619 }; */
15622 template_header_p
15627 {
15636 }
15639 }
15641 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
15642 Define the tag as a forward-reference if it is not defined.
15644 If a declaration is given, process it here, and report an error if
15645 multiple declarations are not identical.
15647 SCOPE is TS_CURRENT when this is also a definition. Only look in
15648 the current frame for the name (since C++ allows new names in any
15649 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
15650 declaration. Only look beginning from the current scope outward up
15651 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
15653 TEMPLATE_HEADER_P is true when this declaration is preceded by
15654 a set of template parameters. */
15656 tree
15659 {
15668 {
15681 }
15683 /* In case of anonymous name, xref_tag is only called to
15684 make type node and push name. Name lookup is not required. */
15695 {
15699 /* Since HOW is not TAG_how::CURRENT_ONLY, we are not looking at
15700 a definition of this tag. Since, in addition, we are
15701 currently processing a (member) template declaration of a
15702 template class, we must be very careful; consider:
15704 template <class X> struct S1
15706 template <class U> struct S2
15707 {
15708 template <class V> friend struct S1;
15709 };
15711 Here, the S2::S1 declaration should not be confused with the
15712 outer declaration. In particular, the inner version should
15713 have a template parameter of level 2, not level 1.
15715 On the other hand, when presented with:
15717 template <class T> struct S1
15718 {
15719 template <class U> struct S2 {};
15720 template <class U> friend struct S2;
15721 };
15723 the friend must find S1::S2 eventually. We accomplish this
15724 by making sure that the new type we create to represent this
15725 declaration has the right TYPE_CONTEXT. */
15728 }
15731 {
15732 /* If no such tag is yet defined, create a forward-reference node
15733 and record it as the "definition".
15734 When a real declaration of this type is found,
15735 the forward-reference will be altered into a real type. */
15737 {
15740 }
15745 /* Mark it as a lambda type right now. Our caller will
15746 correct the value. */
15749 }
15750 else
15751 {
15753 {
15754 /* Check that we aren't trying to overload a class with different
15755 constraints. */
15758 {
15761 }
15764 }
15768 {
15772 }
15776 {
15779 {
15783 }
15792 {
15793 /* Push it into this TU's symbol slot. */
15796 /* We're in the template parm binding level.
15797 Pushtag has logic to slide under that, but we're
15798 not pushing a *new* type. */
15804 }
15807 }
15808 }
15811 }
15813 /* Create the binfo hierarchy for REF with (possibly NULL) base list
15814 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
15815 access_* node, and the TREE_VALUE is the type of the base-class.
15816 Non-NULL TREE_TYPE indicates virtual inheritance. */
15818 void
15820 {
15827 tree default_access;
15833 /* The base of a derived class is private by default, all others are
15834 public. */
15839 /* First, make sure that any templates in base-classes are
15840 instantiated. This ensures that if we call ourselves recursively
15841 we do not get confused about which classes are marked and which
15842 are not. */
15845 {
15848 /* The dependent_type_p call below should really be dependent_scope_p
15849 so that we give a hard error about using an incomplete type as a
15850 base, but we allow it with a pedwarn for backward
15851 compatibility. */
15857 /* An incomplete type. Remove it from the list. */
15859 else
15860 {
15861 max_bases++;
15863 max_dvbases++;
15867 }
15868 }
15873 /* The binfo slot should be empty, unless this is an (ill-formed)
15874 redefinition. */
15885 /* Apply base-class info set up to the variants of this type. */
15889 {
15891 /* A C++98 POD cannot have base classes. */
15895 {
15898 }
15899 }
15906 {
15907 /* An aggregate can't have virtual base classes. */
15915 }
15918 {
15926 /* Before C++17, an aggregate cannot have base classes. In C++17, an
15927 aggregate can't have virtual, private, or protected base classes. */
15938 {
15940 basetype);
15942 }
15946 {
15948 /* The original basetype could have been a typedef'd type. */
15951 /* Inherit flags from the base. */
15962 }
15964 /* We must do this test after we've seen through a typedef
15965 type. */
15967 {
15970 else
15973 }
15976 /* Regenerate the pack expansion for the bases. */
15990 dropped_base:
15991 /* Update max_vbases to reflect the reality that we are dropping
15992 this base: if it reaches zero we want to undo the vec_alloc
15993 above to avoid inconsistencies during error-recovery: eg, in
15994 build_special_member_call, CLASSTYPE_VBASECLASSES non null
15995 and vtt null (c++/27952). */
15997 max_vbases--;
15999 max_vbases
16001 }
16008 /* If we didn't get max_vbases vbases, we must have shared at
16009 least one of them, and are therefore diamond shaped. */
16012 /* Unmark all the types. */
16017 /* Now see if we have a repeated base type. */
16019 {
16022 {
16024 {
16027 }
16029 }
16034 else
16036 }
16037 }
16039 \f
16040 /* Copies the enum-related properties from type SRC to type DST.
16041 Used with the underlying type of an enum and the enum itself. */
16042 static void
16044 {
16045 tree t;
16047 {
16057 else
16061 }
16062 }
16064 /* Begin compiling the definition of an enumeration type.
16065 NAME is its name,
16067 if ENUMTYPE is not NULL_TREE then the type has alredy been found.
16069 UNDERLYING_TYPE is the type that will be used as the storage for
16070 the enumeration type. This should be NULL_TREE if no storage type
16071 was specified.
16073 ATTRIBUTES are any attributes specified after the enum-key.
16075 SCOPED_ENUM_P is true if this is a scoped enumeration type.
16077 if IS_NEW is not NULL, gets TRUE iff a new type is created.
16079 Returns the type object, as yet incomplete.
16080 Also records info about it so that build_enumerator
16081 may be used to declare the individual values as they are read. */
16083 tree
16086 {
16092 /* [C++0x dcl.enum]p5:
16094 If not explicitly specified, the underlying type of a scoped
16095 enumeration type is int. */
16102 /* If this is the real definition for a previous forward reference,
16103 fill in the contents in the same object that used to be the
16104 forward reference. */
16110 /* In case of a template_decl, the only check that should be deferred
16111 to instantiation time is the comparison of underlying types. */
16113 {
16115 {
16121 }
16123 {
16129 }
16133 {
16139 }
16142 {
16144 {
16150 }
16152 }
16153 }
16157 {
16158 /* In case of error, make a dummy enum to allow parsing to
16159 continue. */
16161 {
16164 }
16166 /* enumtype may be an ENUMERAL_TYPE if this is a redefinition
16167 of an opaque enum, or an opaque enum of an already defined
16168 enumeration (C++11).
16169 In any other case, it'll be NULL_TREE. */
16171 {
16174 }
16177 /* Do not push the decl more than once. */
16180 {
16184 /* std::byte aliases anything. */
16189 }
16190 else
16196 /* The enum is considered opaque until the opening '{' of the
16197 enumerator list. */
16200 }
16207 {
16209 /* We already checked that it matches, don't change it to a different
16212 {
16215 }
16218 else
16221 }
16223 /* If into a template class, the returned enum is always the first
16224 declaration (opaque or not) seen. This way all the references to
16225 this type will be to the same declaration. The following ones are used
16226 only to check for definition errors. */
16229 else
16231 }
16233 /* After processing and defining all the values of an enumeration type,
16234 install their decls in the enumeration type.
16235 ENUMTYPE is the type object. */
16237 void
16239 {
16240 tree values;
16241 tree underlying_type;
16242 tree decl;
16243 tree value;
16245 tree t;
16247 bool fixed_underlying_type_p
16250 /* We built up the VALUES in reverse order. */
16253 /* For an enum defined in a template, just set the type of the values;
16254 all further processing is postponed until the template is
16255 instantiated. We need to set the type so that tsubst of a CONST_DECL
16256 works. */
16258 {
16260 values;
16264 }
16266 /* Determine the minimum and maximum values of the enumerators. */
16268 {
16272 values;
16274 {
16277 /* [dcl.enum]: Following the closing brace of an enum-specifier,
16278 each enumerator has the type of its enumeration. Prior to the
16279 closing brace, the type of each enumerator is the type of its
16280 initializing value. */
16283 /* Update the minimum and maximum values, if appropriate. */
16287 /* Figure out what the minimum and maximum values of the
16288 enumerators are. */
16295 }
16296 }
16297 else
16298 /* [dcl.enum]
16300 If the enumerator-list is empty, the underlying type is as if
16301 the enumeration had a single enumerator with value 0. */
16305 {
16306 /* Compute the number of bits require to represent all values of the
16307 enumeration. We must do this before the type of MINNODE and
16308 MAXNODE are transformed, since tree_int_cst_min_precision relies
16309 on the TREE_TYPE of the value it is passed. */
16317 /* Determine the underlying type of the enumeration.
16319 [dcl.enum]
16321 The underlying type of an enumeration is an integral type that
16322 can represent all the enumerator values defined in the
16323 enumeration. It is implementation-defined which integral type is
16324 used as the underlying type for an enumeration except that the
16325 underlying type shall not be larger than int unless the value of
16326 an enumerator cannot fit in an int or unsigned int.
16328 We use "int" or an "unsigned int" as the underlying type, even if
16329 a smaller integral type would work, unless the user has
16330 explicitly requested that we use the smallest possible type. The
16331 user can request that for all enumerations with a command line
16332 flag, or for just one enumeration with an attribute. */
16334 use_short_enum = flag_short_enums
16337 /* If the precision of the type was specified with an attribute and it
16338 was too small, give an error. Otherwise, use it. */
16340 {
16343 else
16344 {
16347 }
16348 }
16352 itk++)
16353 {
16359 }
16361 {
16362 /* DR 377
16364 IF no integral type can represent all the enumerator values, the
16365 enumeration is ill-formed. */
16370 }
16372 /* [dcl.enum]
16374 The value of sizeof() applied to an enumeration type, an object
16375 of an enumeration type, or an enumerator, is the value of sizeof()
16376 applied to the underlying type. */
16379 /* Compute the minimum and maximum values for the type.
16381 [dcl.enum]
16383 For an enumeration where emin is the smallest enumerator and emax
16384 is the largest, the values of the enumeration are the values of the
16385 underlying type in the range bmin to bmax, where bmin and bmax are,
16386 respectively, the smallest and largest values of the smallest bit-
16387 field that can store emin and emax. */
16389 /* The middle-end currently assumes that types with TYPE_PRECISION
16390 narrower than their underlying type are suitably zero or sign
16391 extended to fill their mode. Similarly, it assumes that the front
16392 end assures that a value of a particular type must be within
16393 TYPE_MIN_VALUE and TYPE_MAX_VALUE.
16395 We used to set these fields based on bmin and bmax, but that led
16396 to invalid assumptions like optimizing away bounds checking. So
16397 now we just set the TYPE_PRECISION, TYPE_MIN_VALUE, and
16398 TYPE_MAX_VALUE to the values for the mode above and only restrict
16399 the ENUM_UNDERLYING_TYPE for the benefit of diagnostics. */
16403 set_min_and_max_values_for_integral_type
16406 /* If -fstrict-enums, still constrain TYPE_MIN/MAX_VALUE. */
16409 }
16410 else
16413 /* If the enum is exported, mark the consts too. */
16418 /* Convert each of the enumerators to the type of the underlying
16419 type of the enumeration. */
16421 {
16425 /* If the enumeration type has a fixed underlying type, we
16426 already checked all of the enumerator values. */
16428 else
16431 tf_warning_or_error);
16432 /* Do not clobber shared ints. */
16434 {
16438 }
16442 }
16444 /* Fix up all variant types of this enum type. */
16451 {
16453 /* TYPE_FIELDS needs fixup. */
16455 }
16457 /* Finish debugging output for this type. */
16460 /* Each enumerator now has the type of its enumeration. Clear the cache
16461 so that this change in types doesn't confuse us later on. */
16463 }
16465 /* Finishes the enum type. This is called only the first time an
16466 enumeration is seen, be it opaque or odinary.
16467 ENUMTYPE is the type object. */
16469 void
16471 {
16473 {
16477 }
16479 /* If this is a forward declaration, there should not be any variants,
16480 though we can get a variant in the middle of an enum-specifier with
16481 wacky code like 'enum E { e = sizeof(const E*) };' */
16485 }
16487 /* Build and install a CONST_DECL for an enumeration constant of the
16488 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
16489 Apply ATTRIBUTES if available. LOC is the location of NAME.
16490 Assignment of sequential values by default is handled here. */
16492 tree
16494 location_t loc)
16495 {
16496 tree decl;
16497 tree context;
16498 tree type;
16500 /* scalar_constant_value will pull out this expression, so make sure
16501 it's folded as appropriate. */
16505 /* If the VALUE was erroneous, pretend it wasn't there; that will
16506 result in the enum being assigned the next value in sequence. */
16510 /* Remove no-op casts from the value. */
16515 {
16516 /* Validate and default VALUE. */
16518 {
16520 {
16525 }
16528 value = perform_implicit_conversion_flags
16536 {
16539 {
16541 "enumerator value for %qD must have integral or "
16544 }
16545 else
16546 {
16550 {
16554 }
16555 }
16556 }
16557 }
16559 /* Default based on previous value. */
16561 {
16563 {
16564 tree prev_value;
16566 /* C++03 7.2/4: If no initializer is specified for the first
16567 enumerator, the type is an unspecified integral
16568 type. Otherwise the type is the same as the type of the
16569 initializing value of the preceding enumerator unless the
16570 incremented value is not representable in that type, in
16571 which case the type is an unspecified integral type
16572 sufficient to contain the incremented value. */
16576 else
16577 {
16584 {
16587 {
16590 {
16596 }
16603 }
16606 else
16608 }
16611 {
16614 }
16615 }
16616 }
16617 else
16619 }
16621 /* Remove no-op casts from the value. */
16624 /* If the underlying type of the enum is fixed, check whether
16625 the enumerator values fits in the underlying type. If it
16626 does not fit, the program is ill-formed [C++0x dcl.enum]. */
16628 && value
16630 {
16635 /* Convert the value to the appropriate type. */
16637 }
16638 }
16640 /* C++ associates enums with global, function, or class declarations. */
16643 /* Build the actual enumeration constant. Note that the enumeration
16644 constants have the underlying type of the enum (if it is fixed)
16645 or the type of their initializer (if the underlying type of the
16646 enum is not fixed):
16648 [ C++0x dcl.enum ]
16650 If the underlying type is fixed, the type of each enumerator
16651 prior to the closing brace is the underlying type; if the
16652 initializing value of an enumerator cannot be represented by
16653 the underlying type, the program is ill-formed. If the
16654 underlying type is not fixed, the type of each enumerator is
16655 the type of its initializing value.
16657 If the underlying type is not fixed, it will be computed by
16658 finish_enum and we will reset the type of this enumerator. Of
16659 course, if we're processing a template, there may be no value. */
16673 {
16674 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
16675 on the TYPE_FIELDS list for `S'. (That's so that you can say
16676 things like `S::i' later.) */
16678 /* The enumerator may be getting declared outside of its enclosing
16679 class, like so:
16681 class S { public: enum E : int; }; enum S::E : int { i = 7; };
16683 For which case we need to make sure that the access of `S::i'
16684 matches the access of `S::E'. */
16688 }
16689 else
16692 /* Add this enumeration constant to the list for this type. */
16696 }
16698 /* Look for an enumerator with the given NAME within the enumeration
16699 type ENUMTYPE. This routine is used primarily for qualified name
16700 lookup into an enumerator in C++0x, e.g.,
16702 enum class Color { Red, Green, Blue };
16704 Color color = Color::Red;
16706 Returns the value corresponding to the enumerator, or
16707 NULL_TREE if no such enumerator was found. */
16708 tree
16710 {
16711 tree e;
16716 }
16718 /* Implement LANG_HOOKS_SIMULATE_ENUM_DECL. */
16720 tree
16723 {
16730 {
16735 }
16749 }
16751 /* Implement LANG_HOOKS_SIMULATE_RECORD_DECL. */
16753 tree
16756 {
16763 {
16766 }
16785 }
16786 \f
16787 /* We're defining DECL. Make sure that its type is OK. */
16789 static void
16791 {
16795 /* In a function definition, arg types must be complete. */
16802 {
16807 /* Make it return void instead. */
16810 void_type_node,
16812 else
16814 fntype = (cp_build_type_attribute_variant
16818 }
16819 else
16820 {
16824 }
16825 }
16827 /* True iff FN is an implicitly-defined default constructor. */
16829 static bool
16831 {
16835 }
16837 /* Clobber the contents of *this to let the back end know that the object
16838 storage is dead when we enter the constructor or leave the destructor. */
16840 static tree
16842 {
16843 /* Clobbering an empty base is pointless, and harmful if its one byte
16844 TYPE_SIZE overlays real data. */
16848 /* If we have virtual bases, clobber the whole object, but only if we're in
16849 charge. If we don't have virtual bases, clobber the as-base type so we
16850 don't mess with tail padding. */
16861 {
16864 }
16871 }
16873 /* Create the FUNCTION_DECL for a function definition.
16874 DECLSPECS and DECLARATOR are the parts of the declaration;
16875 they describe the function's name and the type it returns,
16876 but twisted together in a fashion that parallels the syntax of C.
16878 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
16879 DECLARATOR is really the DECL for the function we are about to
16880 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
16881 indicating that the function is an inline defined in-class.
16883 This function creates a binding context for the function body
16884 as well as setting up the FUNCTION_DECL in current_function_decl.
16886 For C++, we must first check whether that datum makes any sense.
16887 For example, "class A local_a(1,2);" means that variable local_a
16888 is an aggregate of type A, which should have a constructor
16889 applied to it with the argument list [1, 2].
16891 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
16892 or may be a BLOCK if the function has been defined previously
16893 in this translation unit. On exit, DECL_INITIAL (decl1) will be
16894 error_mark_node if the function has never been defined, or
16895 a BLOCK if the function has been defined somewhere. */
16897 bool
16899 {
16903 /* Sanity check. */
16910 else
16911 {
16916 }
16923 /* Handle gnu_inline attribute. */
16925 {
16930 }
16933 /* This is a constructor, we must ensure that any default args
16934 introduced by this definition are propagated to the clones
16935 now. The clones are used directly in overload resolution. */
16938 /* Sometimes we don't notice that a function is a static member, and
16939 build a METHOD_TYPE for it. Fix that up now. */
16943 /* Set up current_class_type, and enter the scope of the class, if
16944 appropriate. */
16950 /* Now that we have entered the scope of the class, we must restore
16951 the bindings for any template parameters surrounding DECL1, if it
16952 is an inline member template. (Order is important; consider the
16953 case where a template parameter has the same name as a field of
16954 the class.) It is not until after this point that
16955 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
16959 /* Effective C++ rule 15. */
16967 /* Make the init_value nonzero so pushdecl knows this is not tentative.
16968 error_mark_node is replaced below (in poplevel) with the BLOCK. */
16972 /* This function exists in static storage.
16973 (This does not mean `static' in the C sense!) */
16976 /* We must call push_template_decl after current_class_type is set
16977 up. (If we are processing inline definitions after exiting a
16978 class scope, current_class_type will be NULL_TREE until set above
16979 by push_nested_class.) */
16981 {
16984 {
16988 }
16990 }
16992 /* Make sure the parameter and return types are reasonable. When
16993 you declare a function, these types can be incomplete, but they
16994 must be complete when you define the function. */
16997 /* Build the return declaration for the function. */
17001 {
17002 tree resdecl;
17010 }
17012 /* Record the decl so that the function name is defined.
17013 If we already have a decl for this name, and it is a FUNCTION_DECL,
17014 use the old decl. */
17016 {
17017 /* A specialization is not used to guide overload resolution. */
17021 {
17025 /* If something went wrong when registering the declaration,
17026 use DECL1; we have to have a FUNCTION_DECL to use when
17027 parsing the body of the function. */
17028 ;
17029 else
17030 {
17031 /* Otherwise, OLDDECL is either a previous declaration
17032 of the same function or DECL1 itself. */
17039 {
17040 tree context;
17042 /* Check whether DECL1 is in an anonymous
17043 namespace. */
17045 context;
17047 {
17051 }
17055 OPT_Wmissing_declarations,
17057 }
17060 }
17061 }
17062 else
17063 {
17064 /* We need to set the DECL_CONTEXT. */
17067 }
17071 /* If #pragma weak applies, mark the decl appropriately now.
17072 The pragma only applies to global functions. Because
17073 determining whether or not the #pragma applies involves
17074 computing the mangled name for the declaration, we cannot
17075 apply the pragma until after we have merged this declaration
17076 with any previous declarations; if the original declaration
17077 has a linkage specification, that specification applies to
17078 the definition as well, and may affect the mangled name. */
17081 }
17083 /* We are now in the scope of the function being defined. */
17086 /* Save the parm names or decls from this function's declarator
17087 where store_parm_decls will find them. */
17090 /* Let the user know we're compiling this function. */
17095 /* This function may already have been parsed, in which case just
17096 return; our caller will skip over the body without parsing. */
17100 /* Initialize RTL machinery. We cannot do this until
17101 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
17102 even when processing a template; this is how we get
17103 CFUN set up, and our per-function variables initialized.
17104 FIXME factor out the non-RTL stuff. */
17108 /* Initialize the language data structures. Whenever we start
17109 a new function, we destroy temporaries in the usual way. */
17114 /* If we are (erroneously) defining a function that we have already
17115 defined before, wipe out what we knew before. */
17121 {
17124 }
17126 /* Start the statement-tree, start the tree now. */
17130 {
17131 /* We know that this was set up by `grokclassfn'. We do not
17132 wait until `store_parm_decls', since evil parse errors may
17133 never get us to that point. Here we keep the consistency
17134 between `current_class_type' and `current_class_ptr'. */
17140 cp_function_chain->x_current_class_ref
17142 /* Set this second to avoid shortcut in cp_build_indirect_ref. */
17145 /* Constructors and destructors need to know whether they're "in
17146 charge" of initializing virtual base classes. */
17149 {
17152 }
17154 {
17157 }
17158 }
17161 /* Implicitly-defined methods (like the
17162 destructor for a class in which no destructor
17163 is explicitly declared) must not be defined
17164 until their definition is needed. So, we
17165 ignore interface specifications for
17166 compiler-generated functions. */
17174 {
17181 /* This is a function in a local class in an extern inline
17182 or template function. */
17184 }
17185 /* If this function belongs to an interface, it is public.
17186 If it belongs to someone else's interface, it is also external.
17187 This only affects inlines and template instantiations. */
17189 {
17192 {
17196 && ! flag_implement_inlines
17199 /* For WIN32 we also want to put these in linkonce sections. */
17201 }
17202 else
17205 /* If this function is in an interface implemented in this file,
17206 make sure that the back end knows to emit this function
17207 here. */
17210 }
17213 {
17214 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
17215 interface, we will have both finfo->interface_unknown and
17216 finfo->interface_only set. In that case, we don't want to
17217 use the normal heuristics because someone will supply a
17218 #pragma implementation elsewhere, and deducing it here would
17219 produce a conflict. */
17224 }
17225 else
17226 {
17227 /* This is a definition, not a reference.
17228 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
17236 else
17238 }
17240 /* Determine the ELF visibility attribute for the function. We must not
17241 do this before calling "pushdecl", as we must allow "duplicate_decls"
17242 to merge any attributes appropriately. We also need to wait until
17243 linkage is set. */
17257 {
17260 }
17270 /* Clobbering an empty base is harmful if it overlays real data. */
17272 /* We can't clobber safely for an implicitly-defined default constructor
17273 because part of the initialization might happen before we enter the
17274 constructor, via AGGR_INIT_ZERO_FIRST (c++/68006). */
17289 }
17292 /* Like start_preparsed_function, except that instead of a
17293 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
17295 Returns true on success. If the DECLARATOR is not suitable
17296 for a function, we return false, which tells the parser to
17297 skip the entire function. */
17299 bool
17302 tree attrs)
17303 {
17304 tree decl1;
17312 /* main must return int. grokfndecl should have corrected it
17313 (and issued a diagnostic) if the user got it wrong. */
17315 integer_type_node));
17318 }
17319 \f
17320 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
17321 FN. */
17323 static bool
17325 {
17327 && !processing_template_decl
17328 /* We insert the EH_SPEC_BLOCK only in the original
17329 function; then, it is copied automatically to the
17330 clones. */
17332 /* Implicitly-generated constructors and destructors have
17333 exception specifications. However, those specifications
17334 are the union of the possible exceptions specified by the
17335 constructors/destructors for bases and members, so no
17336 unallowed exception will ever reach this function. By
17337 not creating the EH_SPEC_BLOCK we save a little memory,
17338 and we avoid spurious warnings about unreachable
17339 code. */
17342 }
17344 /* Helper function to push ARGS into the current lexical scope. DECL
17345 is the function declaration. NONPARMS is used to handle enum
17346 constants. */
17348 void
17350 {
17351 /* If we're doing semantic analysis, then we'll call pushdecl
17352 for each of these. We must do them in reverse order so that
17353 they end in the correct forward order. */
17356 tree next;
17358 {
17363 {
17364 /* If we find an enum constant or a type tag, put it aside for
17365 the moment. */
17368 }
17369 }
17371 /* Get the decls in their original chain order and record in the
17372 function. This is all and only the PARM_DECLs that were
17373 pushed into scope by the loop above. */
17375 }
17377 /* Store the parameter declarations into the current function declaration.
17378 This is called after parsing the parameter declarations, before
17379 digesting the body of the function.
17381 Also install to binding contour return value identifier, if any. */
17383 static void
17385 {
17388 /* This is a chain of any other decls that came in among the parm
17389 declarations. If a parm is declared with enum {foo, bar} x;
17390 then CONST_DECLs for foo and bar are put here. */
17394 {
17395 /* This case is when the function was defined with an ANSI prototype.
17396 The parms already have decls, so we need not do anything here
17397 except record them as in effect
17398 and complain if any redundant old-style parm decls were written. */
17402 /* Must clear this because it might contain TYPE_DECLs declared
17403 at class level. */
17407 }
17408 else
17411 /* Now store the final chain of decls for the arguments
17412 as the decl-chain of the current lexical scope.
17413 Put the enumerators in as well, at the front so that
17414 DECL_ARGUMENTS is not modified. */
17419 }
17421 \f
17422 /* Set the return value of the constructor (if present). */
17424 static void
17426 {
17427 tree val;
17428 tree exprstmt;
17431 {
17432 /* Any return from a constructor will end up here. */
17439 /* Return the address of the object. */
17442 }
17443 }
17445 /* Do all the processing for the beginning of a destructor; set up the
17446 vtable pointers and cleanups for bases and members. */
17448 static void
17450 {
17451 tree compound_stmt;
17453 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
17454 issued an error message. We still want to try to process the
17455 body of the function, but initialize_vtbl_ptrs will crash if
17456 TYPE_BINFO is NULL. */
17458 {
17460 /* Make all virtual function table pointers in non-virtual base
17461 classes point to CURRENT_CLASS_TYPE's virtual function
17462 tables. */
17467 /* Clobbering an empty base is harmful if it overlays real data. */
17469 {
17473 {
17475 tree ref
17482 tf_warning_or_error);
17483 /* If the vptr is shared with some virtual nearly empty base,
17484 don't clear it if not in charge, the dtor of the virtual
17485 nearly empty base will do that later. */
17487 {
17490 {
17492 {
17494 tf_warning_or_error);
17497 }
17499 }
17500 }
17502 }
17503 else
17505 }
17507 /* And insert cleanups for our bases and members so that they
17508 will be properly destroyed if we throw. */
17510 }
17511 }
17513 /* At the end of every destructor we generate code to delete the object if
17514 necessary. Do that now. */
17516 static void
17518 {
17519 tree exprstmt;
17521 /* Any return from a destructor will end up here; that way all base
17522 and member cleanups will be run when the function returns. */
17526 {
17527 tree val;
17533 /* Return the address of the object. */
17536 }
17537 }
17539 /* Do the necessary processing for the beginning of a function body, which
17540 in this case includes member-initializers, but not the catch clauses of
17541 a function-try-block. Currently, this means opening a binding level
17542 for the member-initializers (in a ctor), member cleanups (in a dtor),
17543 and capture proxies (in a lambda operator()). */
17545 tree
17547 {
17553 else
17554 /* Always keep the BLOCK node associated with the outermost pair of
17555 curly braces of a function. These are needed for correct
17556 operation of dwarfout.c. */
17567 }
17569 /* Do the processing for the end of a function body. Currently, this means
17570 closing out the cleanups for fully-constructed bases and members, and in
17571 the case of the destructor, deleting the object if desired. Again, this
17572 is only meaningful for [cd]tors, since they are the only functions where
17573 there is a significant distinction between the main body and any
17574 function catch clauses. Handling, say, main() return semantics here
17575 would be wrong, as flowing off the end of a function catch clause for
17576 main() would also need to return 0. */
17578 void
17580 {
17584 /* Close the block. */
17593 }
17595 /* Given a function, returns the BLOCK corresponding to the outermost level
17596 of curly braces, skipping the artificial block created for constructor
17597 initializers. */
17599 tree
17601 {
17611 }
17613 /* If FNDECL is a class's key method, add the class to the list of
17614 keyed classes that should be emitted. */
17616 static void
17618 {
17622 {
17626 }
17627 }
17629 /* Attempt to add a fix-it hint to RICHLOC suggesting the insertion
17630 of "return *this;" immediately before its location, using FNDECL's
17631 first statement (if any) to give the indentation, if appropriate. */
17633 static void
17635 {
17642 indent);
17643 }
17645 /* This function carries out the subset of finish_function operations needed
17646 to emit the compiler-generated outlined helper functions used by the
17647 coroutines implementation. */
17649 static void
17651 {
17652 /* This is a partial set of the operations done by finish_function()
17653 plus emitting the result. */
17663 /* We must start each function with a clear fold cache. */
17668 /* This function has coroutine IFNs that we should handle in middle
17669 end lowering. */
17673 }
17675 /* Finish up a function declaration and compile that function
17676 all the way to assembler language output. The free the storage
17677 for the function definition. INLINE_P is TRUE if we just
17678 finished processing the body of an in-class inline function
17679 definition. (This processing will have taken place after the
17680 class definition is complete.) */
17682 tree
17684 {
17689 && !processing_template_decl
17693 /* When we get some parse errors, we can end up without a
17694 current_function_decl, so cope. */
17708 /* TREE_READONLY (fndecl) = 1;
17709 This caused &foo to be of type ptr-to-const-function
17710 which then got a warning when stored in a ptr-to-function variable. */
17713 /* The current function is being defined, so its DECL_INITIAL should
17714 be set, and unless there's a multiple definition, it should be
17715 error_mark_node. */
17719 {
17720 /* Only try to emit the coroutine outlined helper functions if the
17721 transforms succeeded. Otherwise, treat errors in the same way as
17722 a regular function. */
17725 /* We should handle coroutine IFNs in middle end lowering. */
17728 /* Do not try to process the ramp's EH unless outlining succeeded. */
17732 current_eh_spec_block);
17733 }
17734 else
17735 /* For a cloned function, we've already got all the code we need;
17736 there's no need to add any extra bits. */
17738 {
17739 /* Make it so that `main' always returns 0 by default. */
17746 current_eh_spec_block);
17747 }
17749 /* If we're saving up tree structure, tie off the function now. */
17754 /* If this function can't throw any exceptions, remember that. */
17757 && !flag_non_call_exceptions
17762 /* This must come after expand_function_end because cleanups might
17763 have declarations (from inline functions) that need to go into
17764 this function's blocks. */
17766 /* If the current binding level isn't the outermost binding level
17767 for this function, either there is a bug, or we have experienced
17768 syntax errors and the statement tree is malformed. */
17770 {
17771 /* Make sure we have already experienced errors. */
17774 /* Throw away the broken statement tree and extra binding
17775 levels. */
17779 {
17782 else
17784 }
17785 }
17788 /* Statements should always be full-expressions at the outermost set
17789 of curly braces for a function. */
17792 /* If there are no return statements in a function with auto return type,
17793 the return type is void. But if the declared type is something like
17794 auto*, this is an error. */
17797 {
17799 && !current_function_returns_value
17801 {
17802 /* We haven't applied return type deduction because we haven't
17803 seen any return statements. Do that now. */
17807 adc_return_type);
17811 }
17814 {
17819 }
17820 }
17822 /* Remember that we were in class scope. */
17827 {
17831 }
17833 // If this is a concept, check that the definition is reasonable.
17842 /* Complain if there's just no return statement. */
17849 /* Don't complain if we abort or throw. */
17850 && !current_function_returns_abnormally
17851 /* Don't complain if there's an infinite loop. */
17852 && !current_function_infinite_loop
17853 /* Don't complain if we are declared noreturn. */
17857 /* Structor return values (if any) are set by the compiler. */
17861 {
17863 /* Potentially add a "return *this;" fix-it hint for
17864 assignment operators. */
17866 {
17869 && current_class_ref
17870 && same_type_ignoring_top_level_qualifiers_p
17876 }
17882 "no return statement in function returning "
17885 }
17887 /* Lambda closure members are implicitly constexpr if possible. */
17891 = ((processing_template_decl
17895 /* Save constexpr function body before it gets munged by
17896 the NRV transformation. */
17899 /* Invoke the pre-genericize plugin before we start munging things. */
17903 /* Perform delayed folding before NRV transformation. */
17909 /* Set up the named return value optimization, if we can. Candidate
17910 variables are selected in check_return_expr. */
17912 {
17914 tree outer;
17917 /* This is only worth doing for fns that return in memory--and
17918 simpler, since we don't have to worry about promoted modes. */
17920 /* Only allow this for variables declared in the outer scope of
17921 the function so we know that their lifetime always ends with a
17922 return; see g++.dg/opt/nrv6.C. We could be more flexible if
17923 we were to do this optimization in tree-ssa. */
17929 }
17931 /* Must mark the RESULT_DECL as being in this function. */
17934 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
17935 to the FUNCTION_DECL node itself. */
17938 /* Store the end of the function, so that we get good line number
17939 info for the epilogue. */
17942 /* Complain about parameters that are only set, but never otherwise used. */
17944 && !processing_template_decl
17947 {
17948 tree decl;
17951 decl;
17965 OPT_Wunused_but_set_parameter,
17968 }
17970 /* Complain about locally defined typedefs that are not used in this
17971 function. */
17974 /* Possibly warn about unused parameters. */
17976 && !processing_template_decl
17980 /* Genericize before inlining. */
17986 /* Emit the resumer and destroyer functions now, providing that we have
17987 not encountered some fatal error. */
17989 {
17992 }
17994 cleanup:
17995 /* We're leaving the context of this function, so zap cfun. It's still in
17996 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
18000 /* If this is an in-class inline definition, we may have to pop the
18001 bindings for the template parameters that we added in
18002 maybe_begin_member_template_processing when start_function was
18003 called. */
18007 /* Leave the scope of the class. */
18013 /* Clean up. */
18018 }
18019 \f
18020 /* Create the FUNCTION_DECL for a function definition.
18021 DECLSPECS and DECLARATOR are the parts of the declaration;
18022 they describe the return type and the name of the function,
18023 but twisted together in a fashion that parallels the syntax of C.
18025 This function creates a binding context for the function body
18026 as well as setting up the FUNCTION_DECL in current_function_decl.
18028 Returns a FUNCTION_DECL on success.
18030 If the DECLARATOR is not suitable for a function (it defines a datum
18031 instead), we return 0, which tells yyparse to report a parse error.
18033 May return void_type_node indicating that this method is actually
18034 a friend. See grokfield for more details.
18036 Came here with a `.pushlevel' .
18038 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
18039 CHANGES TO CODE IN `grokfield'. */
18041 tree
18044 {
18054 /* Pass friends other than inline friend functions back. */
18059 {
18064 }
18068 /* p1779 ABI-Isolation makes inline not a default for in-class
18069 definitions in named module purview. If the user explicitly
18070 made it inline, grokdeclarator will already have done the right
18071 things. */
18073 || flag_module_implicit_inline
18074 /* Lambda's operator function remains inline. */
18076 /* If the user explicitly asked for this to be inline, we don't
18077 need to do more, but more importantly we want to warn if we
18078 can't inline it. */
18080 {
18084 /* It's ok if we can't inline this. */
18086 }
18088 /* We process method specializations in finish_struct_1. */
18090 {
18091 /* Avoid calling decl_spec_seq... until we have to. */
18096 }
18099 {
18102 }
18108 }
18109 \f
18111 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
18112 we can lay it out later, when and if its type becomes complete.
18114 Also handle constexpr variables where the initializer involves
18115 an unlowered PTRMEM_CST because the class isn't complete yet. */
18117 void
18119 {
18122 /* Keep track of variables with incomplete types. */
18125 {
18133 /* RTTI TD entries are created while defining the type_info. */
18136 {
18139 }
18143 {
18144 /* When the outermost open class is complete we can resolve any
18145 pointers-to-members. */
18149 }
18150 }
18151 }
18153 /* Called when a class type (given by TYPE) is defined. If there are
18154 any existing VAR_DECLs whose type has been completed by this
18155 declaration, update them now. */
18157 void
18159 {
18164 {
18166 {
18173 {
18174 /* Complete the type of the variable. */
18179 }
18181 /* Remove this entry from the list. */
18183 }
18184 else
18185 ix++;
18186 }
18187 }
18189 /* If DECL is of a type which needs a cleanup, build and return an
18190 expression to perform that cleanup here. Return NULL_TREE if no
18191 cleanup need be done. DECL can also be a _REF when called from
18192 split_nonconstant_init_1. */
18194 tree
18196 {
18197 tree type;
18198 tree attr;
18199 tree cleanup;
18201 /* Assume no cleanup is required. */
18207 /* Handle "__attribute__((cleanup))". We run the cleanup function
18208 before the destructor since the destructor is what actually
18209 terminates the lifetime of the object. */
18212 else
18215 {
18216 tree id;
18217 tree fn;
18218 tree arg;
18220 /* Get the name specified by the user for the cleanup function. */
18222 /* Look up the name to find the cleanup function to call. It is
18223 important to use lookup_name here because that is what is
18224 used in c-common.cc:handle_cleanup_attribute when performing
18225 initial checks on the attribute. Note that those checks
18226 include ensuring that the function found is not an overloaded
18227 function, or an object with an overloaded call operator,
18228 etc.; we can rely on the fact that the function found is an
18229 ordinary FUNCTION_DECL. */
18237 }
18238 /* Handle ordinary C++ destructors. */
18241 {
18243 tree addr;
18244 tree call;
18248 else
18262 else
18264 }
18266 /* build_delete sets the location of the destructor call to the
18267 current location, even though the destructor is going to be
18268 called later, at the end of the current scope. This can lead to
18269 a "jumpy" behavior for users of debuggers when they step around
18270 the end of the block. So let's unset the location of the
18271 destructor call instead. */
18279 /* Treat objects with destructors as used; the destructor may do
18280 something substantive. */
18289 }
18291 \f
18292 /* Return the FUNCTION_TYPE that corresponds to MEMFNTYPE, which can be a
18293 FUNCTION_DECL, METHOD_TYPE, FUNCTION_TYPE, pointer or reference to
18294 METHOD_TYPE or FUNCTION_TYPE, or pointer to member function. */
18296 tree
18298 {
18299 tree fntype;
18300 tree args;
18313 fntype = (cp_build_type_attribute_variant
18317 }
18319 /* DECL was originally constructed as a non-static member function,
18320 but turned out to be static. Update it accordingly. */
18322 void
18324 {
18337 }
18339 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
18340 one of the language-independent trees. */
18342 enum cp_tree_node_structure_enum
18344 {
18346 {
18364 }
18365 }
18367 /* Build the void_list_node (void_type_node having been created). */
18368 tree
18370 {
18373 }
18375 bool
18377 {
18378 /* A missing noreturn is ok for the `main' function. */
18380 }
18382 /* Return the decl used to identify the COMDAT group into which DECL should
18383 be placed. */
18385 tree
18387 {
18388 /* Virtual tables, construction virtual tables, and virtual table
18389 tables all go in a single COMDAT group, named after the primary
18390 virtual table. */
18393 /* For all other DECLs, the COMDAT group is the mangled name of the
18394 declaration itself. */
18395 else
18396 {
18398 {
18399 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
18400 into the same section as the target function. In that case
18401 we must return target's name. */
18407 else
18409 }
18410 }
18413 }
18415 /* Returns the return type for FN as written by the user, which may include
18416 a placeholder for a deduced return type. */
18418 tree
18420 {
18426 }
18428 /* Returns true iff DECL is a variable or function declared with an auto type
18429 that has not yet been deduced to a real type. */
18431 bool
18433 {
18440 }
18442 /* Complain if DECL has an undeduced return type. */
18444 bool
18446 {
18448 {
18455 }
18457 }
18459 /* Create a representation of the explicit-specifier with
18460 constant-expression of EXPR. COMPLAIN is as for tsubst. */
18462 tree
18464 {
18469 /* Wait for instantiation, tsubst_function_decl will handle it. */
18476 }