| blob | 2e0339858c33c35bfbb18f1f04b033cb55413aec |
1 /* Process declarations and variables for -*- C++ -*- compiler.
2 Copyright (C) 1988-2021 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 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1474 If the redeclaration is invalid, a diagnostic is issued, and the
1475 error_mark_node is returned. Otherwise, OLDDECL is returned.
1477 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1478 returned.
1480 HIDING is true if the new decl is being hidden. WAS_HIDDEN is true
1481 if the old decl was hidden.
1483 Hidden decls can be anticipated builtins, injected friends, or
1484 (coming soon) injected from a local-extern decl. */
1486 tree
1488 {
1492 tree new_template_info;
1501 /* If either the type of the new decl or the type of the old decl is an
1502 error_mark_node, then that implies that we have already issued an
1503 error (earlier) for some bogus type specification, and in that case,
1504 it is rather pointless to harass the user with yet more error message
1505 about the same declaration, so just pretend the types match here. */
1510 /* Check for redeclaration and other discrepancies. */
1513 {
1515 {
1516 /* Avoid warnings redeclaring built-ins which have not been
1517 explicitly declared. */
1519 {
1523 OPT_Wbuiltin_declaration_mismatch,
1525 newdecl);
1527 }
1529 /* If you declare a built-in or predefined function name as static,
1530 the old definition is overridden, but optionally warn this was a
1531 bad choice of name. */
1533 {
1535 OPT_Wshadow,
1539 /* Discard the old built-in function. */
1541 }
1542 /* If the built-in is not ansi, then programs can override
1543 it even globally without an error. */
1548 else
1550 "declaration of %q#D conflicts with built-in "
1553 }
1555 {
1556 /* Avoid warnings redeclaring built-ins which have not been
1557 explicitly declared. */
1559 {
1562 /* A new declaration doesn't match a built-in one unless it
1563 is also extern "C". */
1573 {
1576 /* FILE, tm types are not known at the time
1577 we create the builtins. */
1583 {
1590 {
1600 }
1602 }
1606 next_arg:;
1607 }
1610 OPT_Wbuiltin_declaration_mismatch,
1611 "declaration of %q#D conflicts with built-in "
1613 }
1618 {
1619 /* Don't really override olddecl for __* prefixed builtins
1620 except for __[^b]*_chk, the compiler might be using those
1621 explicitly. */
1623 {
1634 {
1636 {
1638 "definition of %q#D ambiguates built-in "
1641 }
1642 auto_diagnostic_group d;
1644 "new declaration %q#D ambiguates built-in"
1650 }
1651 }
1653 /* A near match; override the builtin. */
1657 OPT_Wbuiltin_declaration_mismatch,
1658 "new declaration %q#D ambiguates built-in "
1660 else
1665 }
1666 else
1667 /* Discard the old built-in function. */
1670 /* Replace the old RTL to avoid problems with inlining. */
1672 }
1673 else
1674 {
1675 /* Even if the types match, prefer the new declarations type
1676 for built-ins which have not been explicitly declared,
1677 for exception lists, etc... */
1684 }
1686 /* If a function is explicitly declared "throw ()", propagate that to
1687 the corresponding builtin. */
1689 && was_hidden
1692 {
1697 }
1699 /* Whether or not the builtin can throw exceptions has no
1700 bearing on this declarator. */
1704 {
1705 /* If a builtin function is redeclared as `static', merge
1706 the declarations, but make the original one static. */
1710 /* Make the old declaration consistent with the new one so
1711 that all remnants of the builtin-ness of this function
1712 will be banished. */
1715 }
1716 }
1718 {
1719 /* C++ Standard, 3.3, clause 4:
1720 "[Note: a namespace name or a class template name must be unique
1721 in its declarative region (7.3.2, clause 14). ]" */
1742 {
1743 /* One is a function and the other is a template
1744 function. */
1748 /* There can only be one! */
1752 "literal operator %q#D conflicts with"
1756 "raw literal operator %q#D conflicts with"
1758 else
1763 }
1769 /* One is an implicit typedef, that's ok. */
1776 }
1778 {
1780 /* These are certainly not duplicate declarations; they're
1781 from different scopes. */
1785 {
1789 /* The name of a class template may not be declared to refer to
1790 any other template, class, function, object, namespace, value,
1791 or type in the same scope. */
1794 {
1800 }
1804 {
1808 }
1812 }
1814 {
1816 {
1819 newdecl);
1823 }
1824 /* For function versions, params and types match, but they
1825 are not ambiguous. */
1828 // The functions have the same parameter types.
1831 // And the same constraints.
1833 {
1839 }
1840 else
1842 }
1843 else
1844 {
1849 }
1850 }
1853 {
1854 /* OMP UDRs are never duplicates. */
1861 }
1871 /* It's OK to have a template specialization and a non-template
1872 with the same type, or to have specializations of two
1873 different templates with the same type. Note that if one is a
1874 specialization, and the other is an instantiation of the same
1875 template, that we do not exit at this point. That situation
1876 can occur if we instantiate a template class, and then
1877 specialize one of its methods. This situation is valid, but
1878 the declarations must be merged in the usual way. */
1885 /* One of the declarations is a template instantiation, and the
1886 other is not a template at all. That's OK. */
1889 {
1890 /* In [namespace.alias] we have:
1892 In a declarative region, a namespace-alias-definition can be
1893 used to redefine a namespace-alias declared in that declarative
1894 region to refer only to the namespace to which it already
1895 refers.
1897 Therefore, if we encounter a second alias directive for the same
1898 alias, we can just ignore the second directive. */
1904 /* Leave it to update_binding to merge or report error. */
1906 }
1907 else
1908 {
1911 {
1912 auto_diagnostic_group d;
1920 }
1925 {
1926 /* Prototype decl follows defn w/o prototype. */
1927 auto_diagnostic_group d;
1932 }
1935 {
1936 /* [dcl.link]
1937 If two declarations of the same function or object
1938 specify different linkage-specifications ..., the program
1939 is ill-formed.... Except for functions with C++ linkage,
1940 a function declaration without a linkage specification
1941 shall not precede the first linkage specification for
1942 that function. A function can be declared without a
1943 linkage specification after an explicit linkage
1944 specification has been seen; the linkage explicitly
1945 specified in the earlier declaration is not affected by
1946 such a function declaration.
1948 DR 563 raises the question why the restrictions on
1949 functions should not also apply to objects. Older
1950 versions of G++ silently ignore the linkage-specification
1951 for this example:
1953 namespace N {
1954 extern int i;
1955 extern "C" int i;
1956 }
1958 which is clearly wrong. Therefore, we now treat objects
1959 like functions. */
1961 {
1962 /* There is no explicit linkage-specification, so we use
1963 the linkage from the previous declaration. */
1966 }
1967 else
1968 {
1969 auto_diagnostic_group d;
1976 }
1977 }
1980 ;
1982 {
1983 /* Note: free functions, as TEMPLATE_DECLs, are handled below. */
1986 as FUNCTION_DECLs. */
1988 /* C++11 8.3.6/6.
1989 Default arguments for a member function of a class
1990 template shall be specified on the initial declaration
1991 of the member function within the class template. */
1994 else
1995 {
2003 {
2006 {
2007 auto_diagnostic_group d;
2009 "default argument given for parameter "
2013 olddecl);
2014 }
2015 else
2016 {
2017 auto_diagnostic_group d;
2019 "default argument given for parameter %d "
2023 olddecl);
2024 }
2025 }
2027 /* C++17 11.3.6/4: "If a friend declaration specifies a default
2028 argument expression, that declaration... shall be the only
2029 declaration of the function or function template in the
2030 translation unit." */
2032 }
2033 }
2034 }
2036 /* Do not merge an implicit typedef with an explicit one. In:
2038 class A;
2039 ...
2040 typedef class A A __attribute__ ((foo));
2042 the attribute should apply only to the typedef. */
2058 {
2060 {
2063 else
2065 }
2066 else
2067 {
2069 {
2074 }
2078 {
2081 }
2082 }
2083 }
2085 /* We have committed to returning OLDDECL at this point. */
2087 /* If new decl is `static' and an `extern' was seen previously,
2088 warn about it. */
2091 /* True to merge attributes between the declarations, false to
2092 set OLDDECL's attributes to those of NEWDECL (for template
2093 explicit specializations that specify their own attributes
2094 independent of those specified for the primary template). */
2100 {
2102 {
2108 /* [dcl.attr.noreturn]: The first declaration of a function shall
2109 specify the noreturn attribute if any declaration of that function
2110 specifies the noreturn attribute. */
2111 tree a;
2114 /* This applies to [[noreturn]] only, not its GNU variants. */
2118 {
2122 }
2123 }
2125 /* Now that functions must hold information normally held
2126 by field decls, there is extra work to do so that
2127 declaration information does not get destroyed during
2128 definition. */
2148 /* Optionally warn about more than one declaration for the same
2149 name, but don't warn about a function declaration followed by a
2150 definition. */
2153 /* Don't warn about extern decl followed by definition. */
2155 /* Don't warn if at least one is/was hidden. */
2157 /* Don't warn about declaration followed by specialization. */
2160 {
2161 auto_diagnostic_group d;
2163 OPT_Wredundant_decls,
2165 newdecl))
2168 }
2170 /* [dcl.fct.def.delete] A deleted definition of a function shall be the
2171 first declaration of the function or, for an explicit specialization
2172 of a function template, the first declaration of that
2173 specialization. */
2176 {
2178 {
2179 auto_diagnostic_group d;
2184 }
2186 }
2187 }
2189 /* Deal with C++: must preserve virtual function table size. */
2191 {
2201 }
2203 /* Copy all the DECL_... slots specified in the new decl except for
2204 any that we copy here from the old type. */
2208 else
2212 {
2217 /* The new decl should not already have gathered any
2218 specializations. */
2225 {
2228 {
2229 /* Per C++11 8.3.6/4, default arguments cannot be added in
2230 later declarations of a function template. */
2232 /* C++17 11.3.6/4: "If a friend declaration specifies a default
2233 argument expression, that declaration... shall be the only
2234 declaration of the function or function template in the
2235 translation unit." */
2236 check_no_redeclaration_friend_default_args
2238 }
2246 {
2249 else
2261 }
2262 else
2263 {
2271 }
2272 }
2274 /* If the new declaration is a definition, update the file and
2275 line information on the declaration, and also make
2276 the old declaration the same definition. */
2278 {
2284 {
2285 tree parm;
2291 }
2292 }
2295 }
2298 {
2302 /* Automatically handles default parameters. */
2304 tree newtype;
2306 /* For typedefs use the old type, as the new type's DECL_NAME points
2307 at newdecl, which will be ggc_freed. */
2309 {
2310 /* But NEWTYPE might have an attribute, honor that. */
2315 {
2319 }
2321 /* And remove the new type from the variants list. */
2323 {
2326 {
2328 /* If remove is the main variant, no need to remove that
2329 from the list. One of the DECL_ORIGINAL_TYPE
2330 variants, e.g. created for aligned attribute, might still
2331 refer to the newdecl TYPE_DECL though, so remove that one
2332 in that case. */
2338 {
2342 }
2343 }
2344 else
2348 {
2351 }
2352 }
2353 }
2356 else
2360 {
2362 /* For already initialized vars, TREE_READONLY could have been
2363 cleared in cp_finish_decl, because the var needs runtime
2364 initialization or destruction. Make sure not to set
2365 TREE_READONLY on it again. */
2382 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
2385 {
2386 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
2389 }
2390 }
2392 /* An explicit specialization of a function template or of a member
2393 function of a class template can be declared transaction_safe
2394 independently of whether the corresponding template entity is declared
2395 transaction_safe. */
2408 /* Lay the type out, unless already done. */
2422 /* Merge deprecatedness. */
2426 /* Merge unavailability. */
2430 /* Preserve function specific target and optimization options */
2432 {
2445 }
2446 else
2447 {
2448 /* Merge the const type qualifier. */
2451 /* Merge the volatile type qualifier. */
2454 }
2456 /* Merge the initialization information. */
2459 {
2463 {
2466 }
2467 }
2470 {
2483 else
2484 {
2485 /* Merge the noreturn bit. */
2491 }
2492 /* Keep the old RTL. */
2494 }
2497 {
2498 /* Keep the old RTL. We cannot keep the old RTL if the old
2499 declaration was for an incomplete object and the new
2500 declaration is not since many attributes of the RTL will
2501 change. */
2503 }
2504 }
2505 /* If cannot merge, then use the new type and qualifiers,
2506 and don't preserve the old rtl. */
2507 else
2508 {
2509 /* Clean out any memory we had of the old declaration. */
2519 }
2521 /* Merge the storage class information. */
2533 {
2535 /* This can happen if olddecl was brought in from the
2536 enclosing namespace via a using-decl. The new decl is
2537 then not a block-scope extern at all. */
2539 else
2540 {
2543 }
2544 }
2548 {
2560 {
2564 }
2567 {
2572 /* If the OLDDECL is an instantiation and/or specialization,
2573 then the NEWDECL must be too. But, it may not yet be marked
2574 as such if the caller has created NEWDECL, but has not yet
2575 figured out that it is a redeclaration. */
2582 }
2584 /* Don't really know how much of the language-specific
2585 values we should copy from old to new. */
2589 {
2592 {
2596 /* Remember the presence of explicit specialization args. */
2599 }
2601 }
2604 {
2605 /* Only functions have these fields. */
2610 /* DECL_THUNKS is only valid for virtual functions,
2611 otherwise it is a DECL_FRIEND_CONTEXT. */
2614 }
2616 {
2617 /* Only variables have this field. */
2620 }
2621 }
2624 {
2625 tree parm;
2627 /* Merge parameter attributes. */
2632 {
2636 }
2640 {
2641 /* If newdecl is not a specialization, then it is not a
2642 template-related function at all. And that means that we
2643 should have exited above, returning 0. */
2647 /* From [temp.expl.spec]:
2649 If a template, a member template or the member of a class
2650 template is explicitly specialized then that
2651 specialization shall be declared before the first use of
2652 that specialization that would cause an implicit
2653 instantiation to take place, in every translation unit in
2654 which such a use occurs. */
2656 olddecl);
2662 /* Don't propagate visibility from the template to the
2663 specialization here. We'll do that in determine_visibility if
2664 appropriate. */
2667 /* [temp.expl.spec/14] We don't inline explicit specialization
2668 just because the primary template says so. */
2678 }
2680 {
2681 /* Never inline re-defined extern inline functions.
2682 FIXME: this could be better handled by keeping both
2683 function as separate declarations. */
2685 }
2686 else
2687 {
2689 {
2693 }
2695 ;
2709 }
2711 /* Preserve abstractness on cloned [cd]tors. */
2714 /* Update newdecl's parms to point at olddecl. */
2720 {
2724 }
2726 {
2727 /* These need to be copied so that the names are available.
2728 Note that if the types do match, we'll preserve inline
2729 info and other bits, but if not, we won't. */
2732 }
2733 /* If redeclaring a builtin function, it stays built in
2734 if newdecl is a gnu_inline definition, or if newdecl is just
2735 a declaration. */
2738 {
2740 /* If we're keeping the built-in definition, keep the rtl,
2741 regardless of declaration matches. */
2744 {
2747 {
2748 /* A compatible prototype of these builtin functions
2749 is seen, assume the runtime implements it with
2750 the expected semantics. */
2752 {
2759 }
2760 }
2763 }
2764 }
2766 /* If defining a function declared with other language
2767 linkage, use the previously declared language linkage. */
2770 {
2772 /* Don't clear out the arguments if we're just redeclaring a
2773 function. */
2776 }
2777 }
2781 /* Now preserve various other info from the definition. */
2787 /* Warn about conflicting visibility specifications. */
2791 {
2792 auto_diagnostic_group d;
2794 "%qD: visibility attribute ignored because it "
2798 }
2799 /* Choose the declaration which specified visibility. */
2801 {
2804 }
2805 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
2806 so keep this behavior. */
2808 {
2811 }
2812 /* Likewise for DECL_ALIGN, DECL_USER_ALIGN and DECL_PACKED. */
2814 {
2817 }
2830 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
2831 with that from NEWDECL below. */
2833 {
2837 }
2839 /* Merge the USED information. */
2846 {
2851 }
2858 /* Merge the DECL_FUNCTION_VERSIONED information. newdecl will be copied
2859 to olddecl and deleted. */
2862 {
2863 /* Set the flag for newdecl so that it gets copied to olddecl. */
2865 /* newdecl will be purged after copying to olddecl and is no longer
2866 a version. */
2868 }
2871 {
2885 /* Preserve symtab node mapping. */
2889 /* If newdecl is a template instantiation, it is possible that
2890 the following sequence of events has occurred:
2892 o A friend function was declared in a class template. The
2893 class template was instantiated.
2895 o The instantiation of the friend declaration was
2896 recorded on the instantiation list, and is newdecl.
2898 o Later, however, instantiate_class_template called pushdecl
2899 on the newdecl to perform name injection. But, pushdecl in
2900 turn called duplicate_decls when it discovered that another
2901 declaration of a global function with the same name already
2902 existed.
2904 o Here, in duplicate_decls, we decided to clobber newdecl.
2906 If we're going to do that, we'd better make sure that
2907 olddecl, and not newdecl, is on the list of
2908 instantiations so that if we try to do the instantiation
2909 again we won't get the clobbered declaration. */
2911 new_template_info,
2912 olddecl);
2913 }
2914 else
2915 {
2923 {
2931 {
2944 }
2952 }
2953 }
2956 {
2960 {
2961 /* Merge the section attribute.
2962 We want to issue an error if the sections conflict but that must be
2963 done later in decl_attributes since we are called before attributes
2964 are assigned. */
2969 {
2973 else
2977 }
2978 }
2982 {
2986 }
2987 }
2991 /* NEWDECL contains the merged attribute lists.
2992 Update OLDDECL to be the same. */
2995 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2996 so that encode_section_info has a chance to look at the new decl
2997 flags and attributes. */
3004 /* The NEWDECL will no longer be needed. Because every out-of-class
3005 declaration of a member results in a call to duplicate_decls,
3006 freeing these nodes represents in a significant savings.
3008 Before releasing the node, be sore to remove function from symbol
3009 table that might have been inserted there to record comdat group.
3010 Be sure to however do not free DECL_STRUCT_FUNCTION because this
3011 structure is shared in between newdecl and oldecl. */
3015 {
3019 }
3022 {
3023 tree clone;
3025 {
3028 }
3029 }
3031 /* Remove the associated constraints for newdecl, if any, before
3032 reclaiming memory. */
3039 }
3040 \f
3041 /* Return zero if the declaration NEWDECL is valid
3042 when the declaration OLDDECL (assumed to be for the same name)
3043 has already been seen.
3044 Otherwise return an error message format string with a %s
3045 where the identifier should go. */
3049 {
3051 {
3052 /* Because C++ can put things into name space for free,
3053 constructs like "typedef struct foo { ... } foo"
3054 would look like an erroneous redeclaration. */
3057 else
3059 }
3061 {
3062 /* If this is a pure function, its olddecl will actually be
3063 the original initialization to `0' (which we force to call
3064 abort()). Don't complain about redefinition in this case. */
3069 /* If both functions come from different namespaces, this is not
3070 a redeclaration - this is a conflict with a used function. */
3076 /* We'll complain about linkage mismatches in
3077 warn_extern_redeclared_static. */
3079 /* Defining the same name twice is no good. */
3082 {
3088 }
3091 {
3096 {
3100 else
3103 }
3104 }
3110 /* [class.compare.default]: A definition of a comparison operator as
3111 defaulted that appears in a class shall be the first declaration of
3112 that function. */
3118 check_abi_tag_redeclaration
3123 }
3125 {
3149 {
3154 {
3158 else
3161 }
3162 }
3168 /* Core issue #226 (C++11):
3170 If a friend function template declaration specifies a
3171 default template-argument, that declaration shall be a
3172 definition and shall be the only declaration of the
3173 function template in the translation unit. */
3184 }
3191 {
3192 /* Only variables can be thread-local, and all declarations must
3193 agree on this property. */
3197 else
3200 }
3202 {
3203 /* The objects have been declared at namespace scope. If either
3204 is a member of an anonymous union, then this is an invalid
3205 redeclaration. For example:
3207 int i;
3208 union { int i; };
3210 is invalid. */
3214 /* If at least one declaration is a reference, there is no
3215 conflict. For example:
3217 int i = 3;
3218 extern int i;
3220 is valid. */
3224 /* Static data member declared outside a class definition
3225 if the variable is defined within the class with constexpr
3226 specifier is declaration rather than definition (and
3227 deprecated). */
3233 {
3235 /* For now, only warn with explicit -Wdeprecated. */
3237 {
3238 auto_diagnostic_group d;
3240 "redundant redeclaration of %<constexpr%> "
3244 }
3246 }
3248 /* Reject two definitions. */
3250 }
3251 else
3252 {
3253 /* Objects declared with block scope: */
3254 /* Reject two definitions, and reject a definition
3255 together with an external reference. */
3259 }
3260 }
3261 \f
3263 /* Hash and equality functions for the named_label table. */
3265 hashval_t
3267 {
3269 }
3271 bool
3273 {
3275 }
3277 /* Look for a label named ID in the current function. If one cannot
3278 be found, create one. Return the named_label_entry, or NULL on
3279 failure. */
3283 {
3286 /* You can't use labels at global scope. */
3288 {
3291 }
3297 named_label_entry **slot
3302 {
3307 {
3311 }
3312 }
3314 /* We are making a new decl, create or reuse the named_label_entry */
3318 else
3319 {
3324 }
3326 /* Now create the LABEL_DECL. */
3332 {
3336 }
3341 }
3343 /* Wrapper for lookup_label_1. */
3345 tree
3347 {
3350 }
3352 tree
3354 {
3357 }
3359 /* Returns nonzero if it is ill-formed to jump past the declaration of
3360 DECL. Returns 2 if it's also a real problem. */
3362 static int
3364 {
3365 /* [stmt.dcl]/3: A program that jumps from a point where a local variable
3366 with automatic storage duration is not in scope to a point where it is
3367 in scope is ill-formed unless the variable has scalar type, class type
3368 with a trivial default constructor and a trivial destructor, a
3369 cv-qualified version of one of these types, or an array of one of the
3370 preceding types and is declared without an initializer (8.5). */
3385 }
3387 /* A subroutine of check_previous_goto_1 and check_goto to identify a branch
3388 to the user. */
3390 static bool
3392 diagnostic_t diag_kind)
3393 {
3394 bool complained
3401 }
3403 /* Check that a single previously seen jump to a newly defined label
3404 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
3405 the jump context; NAMES are the names in scope in LEVEL at the jump
3406 context; LOCUS is the source position of the jump or 0. Returns
3407 true if all is well. */
3409 static bool
3412 {
3420 {
3426 }
3429 {
3435 {
3441 {
3446 }
3448 {
3452 else
3454 " enters scope of %q#D, which has "
3456 }
3457 }
3465 {
3492 {
3496 }
3498 {
3502 }
3507 }
3510 {
3516 }
3517 }
3520 }
3522 static void
3524 {
3528 }
3530 static bool
3532 {
3534 }
3536 /* Check that a new jump to a label DECL is OK. Called by
3537 finish_goto_stmt. */
3539 void
3541 {
3542 /* We can't know where a computed goto is jumping.
3543 So we assume that it's OK. */
3547 /* We didn't record any information about this label when we created it,
3548 and there's not much point since it's trivial to analyze as a return. */
3553 named_label_entry **slot
3557 /* If the label hasn't been defined yet, defer checking. */
3559 {
3560 /* Don't bother creating another use if the last goto had the
3561 same data, and will therefore create the same set of errors. */
3566 named_label_use_entry *new_use
3576 }
3580 tree bad;
3586 {
3595 }
3598 {
3602 {
3603 /* Can't skip init of __exception_info. */
3605 {
3609 }
3613 }
3615 {
3619 else
3621 " enters scope of %q#D which has "
3623 }
3624 }
3627 {
3638 }
3641 {
3644 }
3647 {
3651 {
3653 {
3658 }
3662 }
3663 }
3664 }
3666 /* Check that a return is ok wrt OpenMP structured blocks.
3667 Called by finish_return_stmt. Returns true if all is well. */
3669 bool
3671 {
3674 {
3677 }
3681 }
3683 /* Define a label, specifying the location in the source file.
3684 Return the LABEL_DECL node for the label. */
3686 tree
3688 {
3691 /* After labels, make any new cleanups in the function go into their
3692 own new (temporary) binding contour. */
3702 {
3705 }
3706 else
3707 {
3708 /* Mark label as having been defined. */
3710 /* Say where in the source. */
3719 }
3722 }
3724 struct cp_switch
3725 {
3728 /* The SWITCH_STMT being built. */
3729 tree switch_stmt;
3730 /* A splay-tree mapping the low element of a case range to the high
3731 element, or NULL_TREE if there is no high element. Used to
3732 determine whether or not a new case label duplicates an old case
3733 label. We need a tree, rather than simply a hash table, because
3734 of the GNU case range extension. */
3735 splay_tree cases;
3736 /* Remember whether a default: case label has been seen. */
3738 /* Remember whether a BREAK_STMT has been seen in this SWITCH_STMT. */
3740 /* Set if inside of {FOR,DO,WHILE}_BODY nested inside of a switch,
3741 where BREAK_STMT doesn't belong to the SWITCH_STMT. */
3743 };
3745 /* A stack of the currently active switch statements. The innermost
3746 switch statement is on the top of the stack. There is no need to
3747 mark the stack for garbage collection because it is only active
3748 during the processing of the body of a function, and we never
3749 collect at that point. */
3753 /* Called right after a switch-statement condition is parsed.
3754 SWITCH_STMT is the switch statement being parsed. */
3756 void
3758 {
3768 }
3770 void
3772 {
3775 /* Emit warnings as needed. */
3778 const bool bool_cond_p
3784 bool_cond_p);
3786 /* For the benefit of block_may_fallthru remember if the switch body
3787 case labels cover all possible values and if there are break; stmts. */
3789 || (!processing_template_decl
3795 /* Now that we're done with the switch warnings, set the switch type
3796 to the type of the condition if the index type was of scoped enum type.
3797 (Such types don't participate in the integer promotions.) We do this
3798 because of bit-fields whose declared type is a scoped enum type:
3799 gimplification will use the lowered index type, but convert the
3800 case values to SWITCH_STMT_TYPE, which would have been the declared type
3801 and verify_gimple_switch doesn't accept that. */
3808 }
3810 /* Note that a BREAK_STMT is about to be added. If it is inside of
3811 a SWITCH_STMT and not inside of a loop body inside of it, note
3812 in switch_stack we've seen a BREAK_STMT. */
3814 void
3816 {
3819 }
3821 /* Note the start of processing of an iteration statement's body.
3822 The note_break_stmt function will do nothing while processing it.
3823 Return a flag that should be passed to note_iteration_stmt_body_end. */
3825 bool
3827 {
3833 }
3835 /* Note the end of processing of an iteration statement's body. */
3837 void
3839 {
3842 }
3844 /* Convert a case constant VALUE in a switch to the type TYPE of the switch
3845 condition. Note that if TYPE and VALUE are already integral we don't
3846 really do the conversion because the language-independent
3847 warning/optimization code will work better that way. */
3849 static tree
3851 {
3861 /* The constant-expression VALUE shall be a converted constant expression
3862 of the adjusted type of the switch condition, which doesn't allow
3863 narrowing conversions. */
3870 else
3871 /* The already integral case. */
3875 }
3877 /* Note that we've seen a definition of a case label, and complain if this
3878 is a bad place for one. */
3880 tree
3882 {
3885 tree type;
3891 {
3892 tree label;
3894 /* For templates, just add the case label; we'll do semantic
3895 analysis at instantiation-time. */
3898 }
3900 /* Find the condition on which this switch statement depends. */
3917 /* After labels, make any new cleanups in the function go into their
3918 own new (temporary) binding contour. */
3925 }
3926 \f
3928 tree scope;
3929 tree name;
3930 tree template_id;
3933 };
3936 {
3939 /* Hash a TYPENAME_TYPE. */
3941 static hashval_t
3943 {
3944 hashval_t hash;
3950 }
3952 /* Compare two TYPENAME_TYPEs. */
3954 static bool
3956 {
3962 }
3963 };
3965 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
3966 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
3968 Returns the new TYPENAME_TYPE. */
3972 tree
3975 {
3976 typename_info ti;
3991 /* See if we already have this type. */
3996 else
3997 {
3998 /* Build the TYPENAME_TYPE. */
4005 /* Build the corresponding TYPE_DECL. */
4012 /* Store it in the hash table. */
4015 /* TYPENAME_TYPEs must always be compared structurally, because
4016 they may or may not resolve down to another type depending on
4017 the currently open classes. */
4019 }
4022 }
4024 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
4025 provided to name the type. Returns an appropriate type, unless an
4026 error occurs, in which case error_mark_node is returned. If we
4027 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
4028 return that, rather than the _TYPE it corresponds to, in other
4029 cases we look through the type decl. If TF_ERROR is set, complain
4030 about errors, otherwise be quiet. */
4032 tree
4034 tsubst_flags_t complain)
4035 {
4036 tree fullname;
4037 tree t;
4046 {
4051 else
4052 /* Create a TEMPLATE_ID_EXPR for the type. */
4056 }
4063 {
4068 {
4072 }
4073 }
4075 {
4079 }
4081 {
4085 }
4092 {
4096 }
4098 /* When the CONTEXT is a dependent type, NAME could refer to a
4099 dependent base class of CONTEXT. But look inside it anyway
4100 if CONTEXT is a currently open scope, in case it refers to a
4101 member of the current instantiation or a non-dependent base;
4102 lookup will stop when we hit a dependent base. */
4104 /* We should only set WANT_TYPE when we're a nested typename type.
4105 Then we can give better diagnostics if we find a non-type. */
4107 else
4116 {
4118 {
4121 else
4124 }
4126 }
4128 /* Pull out the template from an injected-class-name (or multiple). */
4133 {
4135 {
4138 }
4140 }
4143 {
4148 }
4150 {
4155 }
4162 {
4170 }
4178 }
4180 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
4181 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
4182 in which case error_mark_node is returned.
4184 If PARM_LIST is non-NULL, also make sure that the template parameter
4185 list of TEMPLATE_DECL matches.
4187 If COMPLAIN zero, don't complain about any errors that occur. */
4189 tree
4191 tsubst_flags_t complain)
4192 {
4201 {
4211 {
4215 }
4219 {
4221 {
4225 }
4227 }
4230 complain))
4234 }
4237 }
4239 /* Build an UNBOUND_CLASS_TEMPLATE. */
4241 tree
4243 {
4244 /* Build the UNBOUND_CLASS_TEMPLATE. */
4250 /* Build the corresponding TEMPLATE_DECL. */
4259 }
4261 \f
4263 /* Push the declarations of builtin types into the global namespace.
4264 RID_INDEX is the index of the builtin type in the array
4265 RID_POINTERS. NAME is the name used when looking up the builtin
4266 type. TYPE is the _TYPE node for the builtin type.
4268 The calls to set_global_binding below should be
4269 eliminated. Built-in types should not be looked up name; their
4270 names are keywords that the parser can recognize. However, there
4271 is code in c-common.c that uses identifier_global_value to look up
4272 built-in types by name. */
4274 void
4277 tree type)
4278 {
4282 {
4288 }
4293 {
4299 }
4302 {
4306 }
4307 }
4309 /* Push a type into the namespace so that the back ends ignore it. */
4311 static void
4313 {
4316 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
4323 }
4325 /* Create all the predefined identifiers. */
4327 static void
4329 {
4330 struct predefined_identifier
4331 {
4335 };
4337 /* A table of identifiers to create at startup. */
4341 /* Some of these names have a trailing space so that it is
4342 impossible for them to conflict with names written by users. */
4359 /* The demangler expects anonymous namespaces to be called
4360 something starting with '_GLOBAL__N_'. It no longer needs
4361 to be unique to the TU. */
4391 };
4395 {
4397 /* Some of these identifiers already have a special kind. */
4400 }
4401 }
4403 /* Create the predefined scalar types of C,
4404 and some nodes representing standard constants (0, 1, (void *)0).
4405 Initialize the global binding level.
4406 Make definitions for built-in primitive functions. */
4408 void
4410 {
4411 tree void_ftype;
4412 tree void_ftype_ptr;
4414 /* Create all the identifiers we need. */
4417 /* Create the global variables. */
4422 /* Enter the global namespace. */
4425 void_type_node);
4430 /* Remember whether we want the empty class passing ABI change warning
4431 in this TU. */
4434 debug_hooks->register_main_translation_unit
4442 /* Initially, C. */
4445 /* Create the `std' namespace. */
4455 tree decl
4468 NULL_TREE);
4469 decl
4471 bool_vaftype,
4472 CP_BUILT_IN_IS_CORRESPONDING_MEMBER,
4476 decl
4478 bool_vaftype,
4479 CP_BUILT_IN_IS_POINTER_INTERCONVERTIBLE_WITH_CLASS,
4485 /* Guess at the initial static decls size. */
4488 /* ... and keyed classes. */
4500 NULL_TREE);
4502 #if 0
4504 #endif
4513 void_ftype_ptr
4516 /* Create the conversion operator marker. This operator's DECL_NAME
4517 is in the identifier table, so we can use identifier equality to
4518 find it. */
4520 void_ftype);
4522 /* C++ extensions */
4527 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
4530 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
4531 result. */
4538 /* Used when parsing to distinguish parameter-lists () and (void). */
4541 {
4542 /* Make sure we get a unique function type, so we can give
4543 its pointer type a name. (This wins for gdb.) */
4550 }
4553 vtbl_type_node
4569 /* Now, C++. */
4574 {
4576 aligned_new_threshold);
4578 }
4584 {
4587 tree ptr_ftype_sizetype;
4588 tree new_eh_spec;
4590 ptr_ftype_sizetype
4593 {
4594 tree bad_alloc_id;
4595 tree bad_alloc_type_node;
4596 tree bad_alloc_decl;
4602 bad_alloc_decl
4607 new_eh_spec
4609 }
4610 else
4613 /* Ensure attribs.c is initialized. */
4617 NULL_TREE);
4620 extvisattr);
4640 {
4641 /* Also push the sized deallocation variants:
4642 void operator delete(void*, std::size_t) throw();
4643 void operator delete[](void*, std::size_t) throw(); */
4644 tree void_ftype_ptr_size
4648 extvisattr);
4656 }
4659 {
4666 /* operator new (size_t, align_val_t); */
4680 /* operator delete (void *, align_val_t); */
4693 {
4694 /* operator delete (void *, size_t, align_val_t); */
4697 NULL_TREE);
4706 }
4707 }
4719 }
4721 abort_fndecl
4725 /* If no definition is available, resolve references to NULL. */
4728 /* Perform other language dependent initializations. */
4745 /* Show we use EH for cleanups. */
4749 /* Check that the hardware interference sizes are at least
4750 alignof(max_align_t), as required by the standard. */
4753 {
4759 "%<--param destructive-interference-size=%d%> "
4762 }
4767 /* else leave it unset. */
4770 {
4777 "%<--param constructive-interference-size=%d%> "
4780 }
4785 }
4787 /* Enter an abi node in global-module context. returns a cookie to
4788 give to pop_abi_namespace. */
4790 unsigned
4792 {
4798 }
4800 /* Pop an abi namespace, FLAGS is the cookie push_abi_namespace gave
4801 you. */
4803 void
4805 {
4809 }
4811 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give
4812 the decl, LOC is the location to give the decl, NAME is the
4813 initialization string and TYPE_DEP indicates whether NAME depended
4814 on the type of the function. We make use of that to detect
4815 __PRETTY_FUNCTION__ inside a template fn. This is being done lazily
4816 at the point of first use, so we mustn't push the decl now. */
4818 static tree
4820 {
4825 {
4832 {
4833 /* __FUNCTION__ */
4836 }
4837 else
4838 {
4839 /* __PRETTY_FUNCTION__ */
4842 }
4849 }
4856 else
4870 /* For decl_constant_var_p. */
4874 {
4879 }
4880 else
4881 {
4884 }
4887 }
4889 /* Install DECL as a builtin function at current global scope. Return
4890 the new decl (if we found an existing version). Also installs it
4891 into ::std, if it's not '_*'. */
4893 tree
4895 {
4900 /* Runtime library routines are, by definition, available in an
4901 external shared object. */
4909 /* In the user's namespace, it must be declared before use. */
4915 /* Treat __*_chk fortification functions as anticipated as well,
4916 unless they are __builtin_*_chk. */
4919 /* All builtins that don't begin with an '_' should additionally
4920 go in the 'std' namespace. */
4922 {
4929 }
4935 }
4937 /* Like cxx_builtin_function, but guarantee the function is added to the global
4938 scope. This is to allow function specific options to add new machine
4939 dependent builtins when the target ISA changes via attribute((target(...)))
4940 which saves space on program startup if the program does not use non-generic
4941 ISAs. */
4943 tree
4945 {
4951 }
4953 /* Implement LANG_HOOKS_SIMULATE_BUILTIN_FUNCTION_DECL. */
4955 tree
4957 {
4964 }
4966 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
4967 function. Not called directly. */
4969 static tree
4972 {
4980 /* Runtime library routines are, by definition, available in an
4981 external shared object. */
4986 }
4988 /* Returns the _DECL for a library function with C++ linkage. */
4990 static tree
4993 {
4998 }
5000 /* Like build_library_fn, but takes a C string instead of an
5001 IDENTIFIER_NODE. */
5003 tree
5005 {
5007 }
5009 /* Like build_cp_library_fn, but takes a C string instead of an
5010 IDENTIFIER_NODE. */
5012 tree
5014 {
5016 ecf_flags);
5017 }
5019 /* Like build_library_fn, but also pushes the function so that we will
5020 be able to find it via get_global_binding. Also, the function
5021 may throw exceptions listed in RAISES. */
5023 tree
5025 {
5031 }
5033 /* Like build_cp_library_fn, but also pushes the function so that it
5034 will be found by normal lookup. */
5036 static tree
5039 {
5046 }
5048 /* Like push_library_fn, but also note that this function throws
5049 and does not return. Used for __throw_foo and the like. */
5051 tree
5053 {
5056 }
5057 \f
5058 /* When we call finish_struct for an anonymous union, we create
5059 default copy constructors and such. But, an anonymous union
5060 shouldn't have such things; this function undoes the damage to the
5061 anonymous union type T.
5063 (The reason that we create the synthesized methods is that we don't
5064 distinguish `union { int i; }' from `typedef union { int i; } U'.
5065 The first is an anonymous union; the second is just an ordinary
5066 union type.) */
5068 void
5070 {
5071 /* Wipe out memory of synthesized methods. */
5079 /* Splice the implicitly generated functions out of TYPE_FIELDS and diagnose
5080 invalid members. */
5082 {
5085 else
5095 {
5096 /* We already complained about static data members in
5097 finish_static_data_member_decl. */
5099 {
5100 auto_diagnostic_group d;
5104 "only have public non-static data members"
5107 {
5110 {
5113 "this flexibility is deprecated and will be "
5115 }
5116 }
5117 }
5118 }
5119 }
5121 /* Splice all functions out of CLASSTYPE_MEMBER_VEC. */
5129 /* Wipe RTTI info. */
5132 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
5133 assignment operators (because they cannot have these methods themselves).
5134 For anonymous unions this is already checked because they are not allowed
5135 in any union, otherwise we have to check it. */
5137 {
5141 {
5143 /* Avoid ICE after error on anon-struct9.C. */
5145 }
5149 {
5152 {
5162 }
5163 }
5164 }
5165 }
5167 /* Warn for an attribute located at LOCATION that appertains to the
5168 class type CLASS_TYPE that has not been properly placed after its
5169 class-key, in it class-specifier. */
5171 void
5173 tree class_type)
5174 {
5177 auto_diagnostic_group d;
5179 "attribute ignored in declaration "
5184 }
5186 /* Returns the cv-qualifiers that apply to the type specified
5187 by the DECLSPECS. */
5189 static int
5191 {
5202 }
5204 /* Make sure that a declaration with no declarator is well-formed, i.e.
5205 just declares a tagged type or anonymous union.
5207 Returns the type declared; or NULL_TREE if none. */
5209 tree
5212 {
5215 /* If a class, struct, or enum type is declared by the DECLSPECS
5216 (i.e, if a class-specifier, enum-specifier, or non-typename
5217 elaborated-type-specifier appears in the DECLSPECS),
5218 DECLARED_TYPE is set to the corresponding type. */
5226 {
5232 }
5244 {
5246 "%<auto%> can only be specified for variables "
5249 }
5256 /* Check for an anonymous union. */
5259 {
5260 /* 7/3 In a simple-declaration, the optional init-declarator-list
5261 can be omitted only when declaring a class (clause 9) or
5262 enumeration (7.2), that is, when the decl-specifier-seq contains
5263 either a class-specifier, an elaborated-type-specifier with
5264 a class-key (9.1), or an enum-specifier. In these cases and
5265 whenever a class-specifier or enum-specifier is present in the
5266 decl-specifier-seq, the identifiers in these specifiers are among
5267 the names being declared by the declaration (as class-name,
5268 enum-names, or enumerators, depending on the syntax). In such
5269 cases, and except for the declaration of an unnamed bit-field (9.6),
5270 the decl-specifier-seq shall introduce one or more names into the
5271 program, or shall redeclare a name introduced by a previous
5272 declaration. [Example:
5273 enum { }; // ill-formed
5274 typedef class { }; // ill-formed
5275 --end example] */
5277 {
5281 }
5288 }
5290 else
5291 {
5299 && (!current_class_type
5308 "a storage class can only be specified for objects "
5312 "%<const%> can only be specified for objects and "
5316 "%<volatile%> can only be specified for objects and "
5320 "%<__restrict%> can only be specified for objects and "
5324 "%<__thread%> can only be specified for objects "
5338 }
5341 {
5342 location_t loc;
5345 /* For a non-template class, use the name location. */
5347 else
5348 /* For a template class (an explicit instantiation), use the
5349 current location. */
5353 /* [dcl.attr.grammar]/4:
5355 No attribute-specifier-seq shall appertain to an explicit
5356 instantiation. */
5357 {
5360 declared_type))
5362 "no attribute can be applied to "
5364 }
5365 else
5367 }
5370 }
5372 /* Called when a declaration is seen that contains no names to declare.
5373 If its type is a reference to a structure, union or enum inherited
5374 from a containing scope, shadow that tag name for the current scope
5375 with a forward reference.
5376 If its type defines a new named structure or union
5377 or defines an enum, it is valid but we need not do anything here.
5378 Otherwise, it is an error.
5380 C++: may have to grok the declspecs to learn about static,
5381 complain for anonymous unions.
5383 Returns the TYPE declared -- or NULL_TREE if none. */
5385 tree
5387 {
5397 /* This is where the variables in an anonymous union are
5398 declared. An anonymous union declaration looks like:
5399 union { ... } ;
5400 because there is no declarator after the union, the parser
5401 sends that declaration here. */
5403 {
5407 {
5411 }
5412 }
5415 }
5416 \f
5417 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
5419 tree
5423 {
5424 tree attrs;
5425 tree type;
5426 enum decl_context context
5432 {
5437 /* A template type parameter or other dependent type. */
5440 else
5442 }
5444 }
5446 /* Process a DECLARATOR for a function-scope or namespace-scope
5447 variable or function declaration.
5448 (Function definitions go through start_function; class member
5449 declarations appearing in the body of the class go through
5450 grokfield.) The DECL corresponding to the DECLARATOR is returned.
5451 If an error occurs, the error_mark_node is returned instead.
5453 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED is
5454 SD_INITIALIZED if an explicit initializer is present, or SD_DEFAULTED
5455 for an explicitly defaulted function, or SD_DELETED for an explicitly
5456 deleted function, but 0 (SD_UNINITIALIZED) if this is a variable
5457 implicitly initialized via a default constructor. It can also be
5458 SD_DECOMPOSITION which behaves much like SD_INITIALIZED, but we also
5459 mark the new decl as DECL_DECOMPOSITION_P.
5461 ATTRIBUTES and PREFIX_ATTRIBUTES are GNU attributes associated with this
5462 declaration.
5464 The scope represented by the context of the returned DECL is pushed
5465 (if it is not the global namespace) and is assigned to
5466 *PUSHED_SCOPE_P. The caller is then responsible for calling
5467 pop_scope on *PUSHED_SCOPE_P if it is set. */
5469 tree
5473 tree attributes,
5474 tree prefix_attributes,
5476 {
5477 tree decl;
5478 tree context;
5482 tree initial;
5500 {
5505 }
5507 /* Save the DECL_INITIAL value in case it gets clobbered to assist
5508 with attribute validation. */
5512 {
5516 decl);
5520 /* Tell 'cplus_decl_attributes' this is an initialized decl,
5521 even though we might not yet have the initializer expression. */
5524 }
5530 /* If this is a typedef that names the class for linkage purposes
5531 (7.1.3p8), apply any attributes directly to the type. */
5536 else
5539 /* Set attributes here so if duplicate decl, will have proper attributes. */
5542 /* Restore the original DECL_INITIAL that we may have clobbered earlier to
5543 assist with attribute validation. */
5546 /* Dllimported symbols cannot be defined. Static data members (which
5547 can be initialized in-class and dllimported) go through grokfield,
5548 not here, so we don't need to exclude those decls when checking for
5549 a definition. */
5551 {
5555 }
5557 /* If #pragma weak was used, mark the decl weak now. */
5569 {
5573 {
5583 {
5589 }
5590 else
5591 {
5596 {
5603 }
5604 /* Static data member are tricky; an in-class initialization
5605 still doesn't provide a definition, so the in-class
5606 declaration will have DECL_EXTERNAL set, but will have an
5607 initialization. Thus, duplicate_decls won't warn
5608 about this situation, and so we check here. */
5616 }
5617 }
5618 else
5619 {
5621 this_tmpl
5622 ? current_template_parms
5627 }
5629 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
5631 /* Do not mark DECL as an explicit specialization if it was not
5632 already marked as an instantiation; a declaration should
5633 never be marked as a specialization unless we know what
5634 template is being specialized. */
5636 {
5641 else
5644 /* [temp.expl.spec] An explicit specialization of a static data
5645 member of a template is a definition if the declaration
5646 includes an initializer; otherwise, it is a declaration.
5648 We check for processing_specialization so this only applies
5649 to the new specialization syntax. */
5652 }
5655 /* Aliases are definitions. */
5659 decl);
5660 }
5662 /* Create a DECL_LANG_SPECIFIC so that DECL_DECOMPOSITION_P works. */
5670 {
5671 /* A function-scope decl of some namespace-scope decl. */
5675 "block-scope extern declaration %q#D not permitted"
5677 }
5679 /* Enter this declaration into the symbol table. Don't push the plain
5680 VAR_DECL for a variable template. */
5694 /* But not templated variables. */
5696 {
5697 /* This is a const variable with implicit 'static'. Set
5698 DECL_THIS_STATIC so we can tell it from variables that are
5699 !TREE_PUBLIC because of the anonymous namespace. */
5702 }
5707 {
5711 "%qD declared %<thread_local%> in %qs function only "
5717 "%qD declared %<static%> in %qs function only available "
5721 else
5725 }
5731 }
5733 /* Process the declaration of a variable DECL. INITIALIZED is true
5734 iff DECL is explicitly initialized. (INITIALIZED is false if the
5735 variable is initialized via an implicitly-called constructor.)
5736 This function must be called for ordinary variables (including, for
5737 example, implicit instantiations of templates), but must not be
5738 called for template declarations. */
5740 void
5742 {
5752 bool aggregate_definition_p
5755 /* If an explicit initializer is present, or if this is a definition
5756 of an aggregate, then we need a complete type at this point.
5757 (Scalars are always complete types, so there is nothing to
5758 check.) This code just sets COMPLETE_P; errors (if necessary)
5759 are issued below. */
5761 && !complete_p
5763 {
5765 /* We will not yet have set TREE_READONLY on DECL if the type
5766 was "const", but incomplete, before this point. But, now, we
5767 have a complete type, so we can try again. */
5769 }
5772 /* Is it valid for this decl to have an initializer at all? */
5773 {
5774 /* Don't allow initializations for incomplete types except for
5775 arrays which might be completed by the initialization. */
5781 {
5784 }
5786 {
5789 /* else we already gave an error in start_decl. */
5790 }
5791 }
5793 {
5796 else
5797 {
5799 decl);
5800 /* Change the type so that assemble_variable will give
5801 DECL an rtl we can live with: (mem (const_int 0)). */
5803 }
5804 }
5806 /* Create a new scope to hold this declaration if necessary.
5807 Whether or not a new scope is necessary cannot be determined
5808 until after the type has been completed; if the type is a
5809 specialization of a class template it is not until after
5810 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
5811 will be set correctly. */
5813 }
5815 /* Given a parenthesized list of values INIT, create a CONSTRUCTOR to handle
5816 C++20 P0960. TYPE is the type of the object we're initializing. */
5818 tree
5820 {
5824 {
5825 /* If the list has a single element and it's a string literal,
5826 then it's the initializer for the array as a whole. */
5832 /* Handle non-standard extensions like compound literals. This also
5833 prevents triggering aggregate parenthesized-initialization in
5834 compiler-generated code for =default. */
5838 }
5844 }
5846 /* Handle initialization of references. DECL, TYPE, and INIT have the
5847 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
5848 but will be set to a new CLEANUP_STMT if a temporary is created
5849 that must be destroyed subsequently.
5851 Returns an initializer expression to use to initialize DECL, or
5852 NULL if the initialization can be performed statically.
5854 Quotes on semantics can be found in ARM 8.4.3. */
5856 static tree
5858 {
5860 {
5867 }
5871 {
5872 /* This handles (C++20 only) code like
5874 const A& r(1, 2, 3);
5876 where we treat the parenthesized list as a CONSTRUCTOR. */
5881 {
5882 /* We don't know yet if we should treat const A& r(1) as
5883 const A& r{1}. */
5885 {
5888 tf_warning_or_error);
5889 }
5890 /* If the list had more than one element, the code is ill-formed
5891 pre-C++20, so we can build a constructor right away. */
5892 else
5894 }
5895 else
5897 tf_warning_or_error);
5898 }
5902 /* Note: default conversion is only called in very special cases. */
5905 /* check_initializer handles this for non-reference variables, but for
5906 references we need to do it here or the initializer will get the
5907 incomplete array type and confuse later calls to
5908 cp_complete_array_type. */
5913 {
5917 }
5919 /* Convert INIT to the reference type TYPE. This may involve the
5920 creation of a temporary, whose lifetime must be the same as that
5921 of the reference. If so, a DECL_EXPR for the temporary will be
5922 added just after the DECL_EXPR for DECL. That's why we don't set
5923 DECL_INITIAL for local references (instead assigning to them
5924 explicitly); we need to allow the temporary to be initialized
5925 first. */
5927 tf_warning_or_error);
5928 }
5930 /* Designated initializers in arrays are not supported in GNU C++.
5931 The parser cannot detect this error since it does not know whether
5932 a given brace-enclosed initializer is for a class type or for an
5933 array. This function checks that CE does not use a designated
5934 initializer. If it does, an error is issued. Returns true if CE
5935 is valid, i.e., does not have a designated initializer. */
5937 bool
5940 {
5941 /* Designated initializers for array elements are not supported. */
5943 {
5944 /* The parser only allows identifiers as designated
5945 initializers. */
5947 {
5951 }
5953 {
5957 }
5965 {
5966 /* A C99 designator is OK if it matches the current index. */
5968 {
5971 }
5972 else
5974 }
5975 else
5981 }
5984 }
5986 /* When parsing `int a[] = {1, 2};' we don't know the size of the
5987 array until we finish parsing the initializer. If that's the
5988 situation we're in, update DECL accordingly. */
5990 static void
5992 {
5998 {
5999 /* do_default is really a C-ism to deal with tentative definitions.
6000 But let's leave it here to ease the eventual merge. */
6005 /* Check that there are no designated initializers in INIT, as
6006 those are not supported in GNU C++, and as the middle-end
6007 will crash if presented with a non-numeric designated
6008 initializer. */
6010 {
6013 HOST_WIDE_INT i;
6015 {
6020 }
6021 }
6025 else
6026 {
6028 do_default);
6030 {
6034 }
6036 {
6038 {
6041 }
6042 /* If a `static' var's size isn't known, make it extern as
6043 well as static, so it does not get allocated. If it's not
6044 `static', then don't mark it extern; finish_incomplete_decl
6045 will give it a default size and it will get allocated. */
6048 }
6050 {
6053 }
6054 }
6059 }
6060 }
6062 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
6063 any appropriate error messages regarding the layout. */
6065 static void
6067 {
6068 tree type;
6074 /* If we haven't already laid out this declaration, do so now.
6075 Note that we must not call complete type for an external object
6076 because it's type might involve templates that we are not
6077 supposed to instantiate yet. (And it's perfectly valid to say
6078 `extern X x' for some incomplete type `X'.) */
6087 {
6088 /* An automatic variable with an incomplete type: that is an error.
6089 Don't talk about array types here, since we took care of that
6090 message in grokdeclarator. */
6094 }
6095 #if 0
6096 /* Keep this code around in case we later want to control debug info
6097 based on whether a type is "used". (jason 1999-11-11) */
6100 /* Let debugger know it should output info for this type. */
6105 #endif
6110 {
6114 else
6115 {
6120 }
6121 }
6123 /* If the final element initializes a flexible array field, add the size of
6124 that initializer to DECL's size. */
6134 {
6137 {
6144 {
6150 }
6151 }
6152 }
6153 }
6155 /* If a local static variable is declared in an inline function, or if
6156 we have a weak definition, we must endeavor to create only one
6157 instance of the variable at link-time. */
6159 void
6161 {
6162 /* Don't mess with __FUNCTION__ and similar. */
6166 /* Static data in a function with comdat linkage also has comdat
6167 linkage. */
6172 {
6174 {
6175 /* With weak symbols, we simply make the variable COMDAT;
6176 that will cause copies in multiple translations units to
6177 be merged. */
6179 }
6180 else
6181 {
6184 {
6185 /* Without weak symbols, we can use COMMON to merge
6186 uninitialized variables. */
6189 }
6190 else
6191 {
6192 /* While for initialized variables, we must use internal
6193 linkage -- which means that multiple copies will not
6194 be merged. */
6201 "%q#D are wrong (you%'ll wind up with "
6203 else
6205 "static data %q#D are wrong (you%'ll wind "
6211 }
6212 }
6213 }
6214 }
6216 /* Issue an error message if DECL is an uninitialized const variable.
6217 CONSTEXPR_CONTEXT_P is true when the function is called in a constexpr
6218 context from potential_constant_expression. Returns true if all is well,
6219 false otherwise. */
6221 bool
6223 tsubst_flags_t complain)
6224 {
6227 /* ``Unless explicitly declared extern, a const object does not have
6228 external linkage and must be initialized. ($8.4; $12.1)'' ARM
6229 7.1.6 */
6233 /* C++20 permits trivial default initialization in constexpr
6234 context (P1331R2). */
6236 && (constexpr_context_p
6239 {
6247 {
6249 {
6253 }
6254 else
6255 {
6259 "uninitialized variable %qD in %<constexpr%> "
6261 else
6264 }
6265 }
6269 decl);
6272 {
6273 tree defaulted_ctor;
6280 "constructor is not user-provided because it is "
6283 "and the implicitly-defined constructor does not "
6285 }
6288 }
6291 }
6292 \f
6293 /* Structure holding the current initializer being processed by reshape_init.
6294 CUR is a pointer to the current element being processed, END is a pointer
6295 after the last element present in the initializer. */
6296 struct reshape_iter
6297 {
6300 };
6304 /* FIELD is an element of TYPE_FIELDS or NULL. In the former case, the value
6305 returned is the next FIELD_DECL (possibly FIELD itself) that can be
6306 initialized. If there are no more such fields, the return value
6307 will be NULL. */
6309 tree
6311 {
6316 /* In C++17, don't skip base class fields. */
6318 /* Don't skip vptr fields. We might see them when we're
6319 called from reduced_constant_expression_p. */
6324 }
6326 /* Return true for [dcl.init.list] direct-list-initialization from
6327 single element of enumeration with a fixed underlying type. */
6329 bool
6331 {
6338 /* DR 2374: The single element needs to be implicitly
6339 convertible to the underlying type of the enum. */
6346 }
6348 /* Subroutine of reshape_init_array and reshape_init_vector, which does
6349 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
6350 INTEGER_CST representing the size of the array minus one (the maximum index),
6351 or NULL_TREE if the array was declared without specifying the size. D is
6352 the iterator within the constructor. */
6354 static tree
6357 {
6358 tree new_init;
6363 /* The initializer for an array is always a CONSTRUCTOR. If this is the
6364 outermost CONSTRUCTOR and the element type is non-aggregate, we don't need
6365 to build a new one. But don't reuse if not complaining; if this is
6366 tentative, we might also reshape to another type (95319). */
6373 else
6377 {
6378 /* Minus 1 is used for zero sized arrays. */
6384 /* sizetype is sign extended, not zero extended. */
6385 else
6387 }
6389 /* Loop until there are no more initializers. */
6393 {
6394 tree elt_init;
6400 complain);
6405 {
6408 }
6409 else
6415 /* This can happen with an invalid initializer (c++/54501). */
6418 }
6421 }
6423 /* Subroutine of reshape_init_r, processes the initializers for arrays.
6424 Parameters are the same of reshape_init_r. */
6426 static tree
6428 tsubst_flags_t complain)
6429 {
6439 }
6441 /* Subroutine of reshape_init_r, processes the initializers for vectors.
6442 Parameters are the same of reshape_init_r. */
6444 static tree
6446 {
6452 {
6455 {
6460 }
6463 }
6465 /* For a vector, we initialize it as an array of the appropriate size. */
6471 }
6473 /* Subroutine of reshape_init_r, processes the initializers for classes
6474 or union. Parameters are the same of reshape_init_r. */
6476 static tree
6478 tsubst_flags_t complain)
6479 {
6480 tree field;
6481 tree new_init;
6485 /* The initializer for a class is always a CONSTRUCTOR. */
6492 {
6493 /* We get here from maybe_aggr_guide for C++20 class template argument
6494 deduction. In this case we need to look through the binfo because a
6495 template doesn't have base fields. */
6498 }
6501 else
6505 {
6506 /* [dcl.init.aggr]
6508 An initializer for an aggregate member that is an
6509 empty class shall have the form of an empty
6510 initializer-list {}. */
6512 {
6516 }
6518 }
6520 /* For C++20 CTAD, handle pack expansions in the base list. */
6523 /* Loop through the initializable fields, gathering initializers. */
6525 {
6526 tree field_init;
6529 /* Handle designated initializers, as an extension. */
6531 {
6536 {
6537 /* We already reshaped this. */
6539 {
6544 }
6545 }
6548 else
6549 {
6554 }
6557 {
6562 }
6564 /* If the element is an anonymous union object and the initializer
6565 list is a designated-initializer-list, the anonymous union object
6566 is initialized by the designated-initializer-list { D }, where D
6567 is the designated-initializer-clause naming a member of the
6568 anonymous union object. */
6571 {
6573 /* Find the anon aggr that is a direct member of TYPE. */
6575 {
6580 }
6581 /* And then the TYPE member with that anon aggr type. */
6588 }
6589 }
6591 /* If we processed all the member of the class, we are done. */
6598 /* Each non-trailing aggregate element that is a pack expansion is
6599 assumed to correspond to no elements of the initializer list. */
6604 complain);
6609 {
6610 /* This can happen with an invalid initializer for a flexible
6611 array member (c++/54441). */
6615 }
6619 /* [dcl.init.aggr]
6621 When a union is initialized with a brace-enclosed
6622 initializer, the braces shall only contain an
6623 initializer for the first member of the union. */
6627 continue_:
6629 {
6632 else
6634 }
6635 else
6637 }
6639 /* A trailing aggregate element that is a pack expansion is assumed to
6640 correspond to all remaining elements of the initializer list (if any). */
6642 {
6647 }
6650 }
6652 /* Subroutine of reshape_init_r. We're in a context where C99 initializer
6653 designators are not valid; either complain or return true to indicate
6654 that reshape_init_r should return error_mark_node. */
6656 static bool
6658 {
6660 {
6665 else
6667 }
6669 }
6671 /* Subroutine of reshape_init, which processes a single initializer (part of
6672 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
6673 iterator within the CONSTRUCTOR which points to the initializer to process.
6674 If this is the first initializer of the outermost CONSTRUCTOR node,
6675 FIRST_INITIALIZER_P is that CONSTRUCTOR; otherwise, it is NULL_TREE. */
6677 static tree
6679 tsubst_flags_t complain)
6680 {
6693 {
6694 /* A complex type can be initialized from one or two initializers,
6695 but braces are not elided. */
6698 {
6700 {
6703 else
6705 }
6706 }
6708 {
6716 }
6718 }
6720 /* A non-aggregate type is always initialized with a single
6721 initializer. */
6723 /* As is an array with dependent bound, which we can see
6724 during C++20 aggregate CTAD. */
6728 {
6729 /* It is invalid to initialize a non-aggregate type with a
6730 brace-enclosed initializer before C++0x.
6731 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
6732 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
6733 a CONSTRUCTOR (with a record type). */
6735 /* Don't complain about a capture-init. */
6738 {
6740 {
6742 {
6745 type);
6747 }
6750 && (BRACE_ENCLOSED_INITIALIZER_P
6752 {
6757 }
6758 }
6759 else
6761 }
6765 }
6767 /* "If T is a class type and the initializer list has a single element of
6768 type cv U, where U is T or a class derived from T, the object is
6769 initialized from that element." Even if T is an aggregate. */
6771 && first_initializer_p
6772 /* But not if it's a designated init. */
6776 {
6779 }
6781 /* [dcl.init.aggr]
6783 All implicit type conversions (clause _conv_) are considered when
6784 initializing the aggregate member with an initializer from an
6785 initializer-list. If the initializer can initialize a member,
6786 the member is initialized. Otherwise, if the member is itself a
6787 non-empty subaggregate, brace elision is assumed and the
6788 initializer is considered for the initialization of the first
6789 member of the subaggregate. */
6791 /* But don't try this for the first initializer, since that would be
6792 looking through the outermost braces; A a2 = { a1 }; is not a
6793 valid aggregate initialization. */
6794 && !first_initializer_p
6797 complain)))
6798 {
6801 }
6803 /* [dcl.init.string]
6805 A char array (whether plain char, signed char, or unsigned char)
6806 can be initialized by a string-literal (optionally enclosed in
6807 braces); a wchar_t array can be initialized by a wide
6808 string-literal (optionally enclosed in braces). */
6811 {
6815 /* Strip one level of braces if and only if they enclose a single
6816 element (as allowed by [dcl.init.string]). */
6820 {
6823 }
6825 /* If it's a string literal, then it's the initializer for the array
6826 as a whole. Otherwise, continue with normal initialization for
6827 array types (one value per array element). */
6829 {
6834 }
6835 }
6837 /* The following cases are about aggregates. If we are not within a full
6838 initializer already, and there is not a CONSTRUCTOR, it means that there
6839 is a missing set of braces (that is, we are processing the case for
6840 which reshape_init exists). */
6843 {
6845 {
6848 /* There is no need to call reshape_init for pointer-to-member
6849 function initializers, as they are always constructed correctly
6850 by the front end. Here we have e.g. {.__pfn=0B, .__delta=0},
6851 which is missing outermost braces. We should warn below, and
6853 /* For a nested compound literal, proceed to specialized routines,
6854 to handle initialization of arrays and similar. */
6857 /* A CONSTRUCTOR of the target's type is a previously
6858 digested initializer. */
6860 {
6863 }
6864 else
6865 {
6866 /* Something that hasn't been reshaped yet. */
6870 }
6871 }
6876 type);
6878 }
6880 /* Dispatch to specialized routines. */
6881 tree new_init;
6888 else
6896 }
6898 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
6899 brace-enclosed aggregate initializer.
6901 INIT is the CONSTRUCTOR containing the list of initializers describing
6902 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
6903 It may not presently match the shape of the TYPE; for example:
6905 struct S { int a; int b; };
6906 struct S a[] = { 1, 2, 3, 4 };
6908 Here INIT will hold a vector of four elements, rather than a
6909 vector of two elements, each itself a vector of two elements. This
6910 routine transforms INIT from the former form into the latter. The
6911 revised CONSTRUCTOR node is returned. */
6913 tree
6915 {
6917 reshape_iter d;
6918 tree new_init;
6924 /* An empty constructor does not need reshaping, and it is always a valid
6925 initializer. */
6929 /* Brace elision is not performed for a CONSTRUCTOR representing
6930 parenthesized aggregate initialization. */
6932 {
6934 /* If we're initializing a char array from a string-literal that is
6935 enclosed in braces, unwrap it here. */
6942 }
6944 /* Handle [dcl.init.list] direct-list-initialization from
6945 single element of enumeration with a fixed underlying type. */
6947 {
6951 {
6955 tf_warning_or_error);
6956 }
6957 else
6959 }
6961 /* Recurse on this CONSTRUCTOR. */
6969 /* Make sure all the element of the constructor were used. Otherwise,
6970 issue an error about exceeding initializers. */
6972 {
6976 }
6986 }
6988 /* Verify array initializer. Returns true if errors have been reported. */
6990 bool
6992 {
6995 /* Structured binding when initialized with an array type needs
6996 to have complete type. */
7001 {
7006 }
7008 /* The array type itself need not be complete, because the
7009 initializer may tell us how many elements are in the array.
7010 But, the elements of the array must be complete. */
7012 {
7016 else
7019 }
7025 /* A compound literal can't have variable size. */
7029 {
7032 }
7034 }
7036 /* Subroutine of check_initializer; args are passed down from that function.
7037 Set stmts_are_full_exprs_p to 1 across a call to build_aggr_init. */
7039 static tree
7042 {
7045 }
7047 /* Verify INIT (the initializer for DECL), and record the
7048 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
7049 grok_reference_init.
7051 If the return value is non-NULL, it is an expression that must be
7052 evaluated dynamically to initialize DECL. */
7054 static tree
7056 {
7057 tree type;
7059 tree core_type;
7061 /* Things that are going to be initialized need to have complete
7062 type. */
7066 {
7067 /* A variable with DECL_HAS_VALUE_EXPR_P set is just a placeholder,
7068 it doesn't have storage to be initialized. */
7071 }
7074 /* We will have already complained. */
7078 {
7081 }
7083 {
7088 }
7089 else
7090 /* There is no way to make a variable-sized class type in GNU C++. */
7094 {
7097 {
7099 {
7102 }
7104 {
7106 "scalar object %qD requires one element in "
7110 }
7111 }
7112 }
7115 {
7122 }
7124 ;
7127 {
7129 {
7132 }
7135 tf_warning_or_error);
7136 /* Do not reshape constructors of vectors (they don't need to be
7137 reshaped. */
7139 {
7141 {
7143 tf_warning_or_error);
7145 }
7147 {
7148 /* Don't reshape if the class has constructors. */
7151 "in C++98 %qD must be initialized by "
7153 decl);
7154 }
7156 {
7159 }
7160 else
7161 {
7164 }
7165 }
7166 /* [dcl.init] "Otherwise, if the destination type is an array, the object
7167 is initialized as follows..." So handle things like
7169 int a[](1, 2, 3);
7171 which is permitted in C++20 by P0960. */
7181 {
7184 /* We get here with code like `int a (2);' */
7186 tf_warning_or_error);
7187 }
7189 /* If DECL has an array type without a specific bound, deduce the
7190 array size from the initializer. */
7204 {
7207 /* A constructor call is a non-trivial initializer even if
7208 it isn't explicitly written. */
7212 /* If this is a constexpr initializer, expand_default_init will
7213 have returned an INIT_EXPR rather than a CALL_EXPR. In that
7214 case, pull the initializer back out and pass it down into
7215 store_init_value. */
7217 {
7224 else
7226 }
7228 {
7229 /* In C++20, the call to build_aggr_init could have created
7230 an INIT_EXPR with a CONSTRUCTOR as the RHS to handle
7231 A(1, 2). */
7234 /* Don't call digest_init; it's unnecessary and will complain
7235 about aggregate initialization of non-aggregate classes. */
7237 }
7240 {
7241 /* Declared constexpr or constinit, but no suitable initializer;
7242 massage init appropriately so we can pass it into
7243 store_init_value for the error. */
7246 {
7251 }
7253 }
7254 else
7256 }
7259 {
7260 /* In aggregate initialization of a variable, each element
7261 initialization is a full-expression because there is no
7262 enclosing expression. */
7270 {
7275 }
7287 }
7288 }
7289 else
7290 {
7298 tf_warning_or_error);
7299 }
7305 {
7306 /* We might have set these in cp_finish_decl. */
7309 }
7314 {
7322 else
7326 {
7330 }
7332 }
7335 }
7337 /* If DECL is not a local variable, give it RTL. */
7339 static void
7341 {
7345 /* Set the DECL_ASSEMBLER_NAME for the object. */
7347 {
7348 /* The `register' keyword, when used together with an
7349 asm-specification, indicates that the variable should be
7350 placed in a particular register. */
7352 {
7355 }
7356 else
7357 {
7364 /* We have to propagate the name to the ns-alias.
7365 This is horrible, as we're affecting a
7366 possibly-shared decl. Again, a one-true-decl
7367 model breaks down. */
7370 }
7371 }
7373 /* Handle non-variables up front. */
7375 {
7378 }
7380 /* If we see a class member here, it should be a static data
7381 member. */
7383 {
7385 /* An in-class declaration of a static data member should be
7386 external; it is only a declaration, and not a definition. */
7390 }
7392 /* We don't create any RTL for local variables. */
7396 /* We defer emission of local statics until the corresponding
7397 DECL_EXPR is expanded. But with constexpr its function might never
7398 be expanded, so go ahead and tell cgraph about the variable now. */
7403 /* Defer template instantiations. */
7408 /* If we're not deferring, go ahead and assemble the variable. */
7411 }
7413 /* walk_tree helper for wrap_temporary_cleanups, below. */
7415 static tree
7417 {
7418 /* Stop at types or full-expression boundaries. */
7421 {
7424 }
7427 {
7432 /* Tell honor_protect_cleanup_actions to handle this as a separate
7433 cleanup. */
7437 }
7440 }
7442 /* We're initializing a local variable which has a cleanup GUARD. If there
7443 are any temporaries used in the initializer INIT of this variable, we
7444 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
7445 variable will be cleaned up properly if one of them throws.
7447 Unfortunately, there's no way to express this properly in terms of
7448 nesting, as the regions for the temporaries overlap the region for the
7449 variable itself; if there are two temporaries, the variable needs to be
7450 the first thing destroyed if either of them throws. However, we only
7451 want to run the variable's cleanup if it actually got constructed. So
7452 we need to guard the temporary cleanups with the variable's cleanup if
7453 they are run on the normal path, but not if they are run on the
7454 exceptional path. We implement this by telling
7455 honor_protect_cleanup_actions to strip the variable cleanup from the
7456 exceptional path. */
7458 static void
7460 {
7462 }
7464 /* Generate code to initialize DECL (a local variable). */
7466 static void
7468 {
7470 tree cleanup;
7478 {
7479 /* If we used it already as memory, it must stay in memory. */
7483 }
7488 /* Compute and store the initial value. */
7493 /* Generate a cleanup, if necessary. */
7496 /* Perform the initialization. */
7498 {
7502 {
7503 /* Stick simple initializers in DECL_INITIAL so that
7504 -Wno-init-self works (c++/34772). */
7509 {
7513 OPT_Winit_self,
7515 }
7516 }
7517 else
7518 {
7521 /* If we're only initializing a single object, guard the
7522 destructors of any temporaries used in its initializer with
7523 its destructor. This isn't right for arrays because each
7524 element initialization is a full-expression. */
7533 saved_stmts_are_full_exprs_p;
7534 }
7535 }
7537 /* Set this to 0 so we can tell whether an aggregate which was
7538 initialized was ever used. Don't do this if it has a
7539 destructor, so we don't complain about the 'resource
7540 allocation is initialization' idiom. Now set
7541 attribute((unused)) on types so decls of that type will be
7542 marked used. (see TREE_USED, above.) */
7544 && ! already_used
7553 }
7555 /* DECL is a VAR_DECL for a compiler-generated variable with static
7556 storage duration (like a virtual table) whose initializer is a
7557 compile-time constant. Initialize the variable and provide it to the
7558 back end. */
7560 void
7562 {
7563 tree init;
7569 /* Mark the decl as constexpr so that we can access its content
7570 at compile time. */
7577 }
7579 /* INIT is the initializer for a variable, as represented by the
7580 parser. Returns true iff INIT is value-dependent. */
7582 static bool
7584 {
7586 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
7589 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
7590 {
7603 }
7604 else
7605 /* It must be a simple expression, e.g., int i = 3; */
7609 }
7611 // Returns true if a DECL is VAR_DECL with the concept specifier.
7614 {
7616 // Not all variables have DECL_LANG_SPECIFIC.
7619 }
7621 /* A helper function to be called via walk_tree. If any label exists
7622 under *TP, it is (going to be) forced. Set has_forced_label_in_static. */
7624 static tree
7626 {
7632 }
7634 /* Return true if DECL has either a trivial destructor, or for C++20
7635 is constexpr and has a constexpr destructor. */
7637 static bool
7639 {
7645 }
7649 /* Helper function of omp_declare_variant_finalize. Finalize one
7650 "omp declare variant base" attribute. Return true if it should be
7651 removed. */
7653 static bool
7655 {
7657 {
7662 }
7667 {
7671 /* FIXME, adjusting simd args unimplemented. */
7673 }
7676 location_t varid_loc
7685 releasing_vec args;
7694 else
7699 {
7701 /* In C++20, we may need to perform ADL for a template
7702 name. */
7705 {
7707 {
7711 tf_warning_or_error);
7712 }
7713 else
7715 }
7717 {
7723 {
7727 tf_warning_or_error);
7728 }
7729 }
7730 }
7735 else
7745 {
7748 {
7752 }
7757 {
7760 }
7761 else
7762 {
7768 }
7769 }
7771 {
7774 }
7777 }
7779 /* Helper function, finish up "omp declare variant base" attribute
7780 now that there is a DECL. ATTR is the first "omp declare variant base"
7781 attribute. */
7783 void
7785 {
7795 {
7798 }
7800 {
7803 }
7805 {
7808 }
7810 {
7813 }
7815 {
7818 }
7819 /* This loop is like private_lookup_attribute, except that it works
7820 with tree * rather than tree, as we might want to remove the
7821 attributes that are diagnosed as errorneous. */
7823 {
7828 {
7830 {
7833 }
7834 }
7836 }
7837 }
7839 /* Finish processing of a declaration;
7840 install its line number and initial value.
7841 If the length of an array type is not known before,
7842 it must be determined now, from the initial value, or it is an error.
7844 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
7845 true, then INIT is an integral constant expression.
7847 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
7848 if the (init) syntax was used. */
7850 void
7853 {
7854 tree type;
7859 tree auto_node;
7864 {
7868 }
7871 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
7878 /* Warn about register storage specifiers except when in GNU global
7879 or local register variable extension. */
7881 {
7884 "ISO C++17 does not allow %<register%> storage "
7886 else
7889 }
7891 /* If a name was specified, get the string. */
7897 bool in_class_decl
7898 = (current_class_type
7909 {
7910 tree d_init;
7912 {
7916 {
7917 /* init is null because we're deferring instantiating the
7918 initializer until we need it. Well, we need it now. */
7921 }
7924 }
7927 {
7931 tf_warning_or_error);
7933 }
7943 {
7948 }
7950 }
7953 {
7956 {
7959 }
7960 }
7970 {
7972 ? TCTX_THREAD_STORAGE
7975 }
7978 {
7979 tree clone;
7981 {
7982 /* FIXME check this is 1st decl. */
7987 {
7991 }
7993 }
7995 {
7998 else
8000 }
8001 }
8004 {
8006 /* If DECL is a reference, then we want to know whether init is a
8007 reference constant; init_const_expr_p as passed tells us whether
8008 it's an rvalue constant. */
8012 {
8013 /* Set these flags now for templates. We'll update the flags in
8014 store_init_value for instantiations. */
8017 /* FIXME setting TREE_CONSTANT on refs breaks the back end. */
8020 }
8021 }
8025 /* #pragma omp declare variant on methods handled in finish_struct
8026 instead. */
8034 {
8037 /* Add this declaration to the statement-tree. */
8044 {
8047 }
8049 /* Generally, initializers in templates are expanded when the
8050 template is instantiated. But, if DECL is a variable constant
8051 then it can be used in future constant expressions, so its value
8052 must be available. */
8059 {
8062 }
8068 {
8069 /* This variable seems to be a non-dependent constant, so process
8070 its initializer. If check_initializer returns non-null the
8071 initialization wasn't constant after all. */
8072 tree init_code;
8078 }
8079 else
8080 {
8082 /* Deduce array size even if the initializer is dependent. */
8084 /* And complain about multiple initializers. */
8088 tf_warning_or_error);
8089 }
8095 {
8098 }
8101 {
8104 }
8106 }
8108 /* Just store non-static data member initializers for later. */
8112 /* Take care of TYPE_DECLs up front. */
8114 {
8117 {
8121 }
8123 /* If we have installed this as the canonical typedef for this
8124 type, and that type has not been defined yet, delay emitting
8125 the debug information for it, as we will emit it later. */
8131 at_eof);
8133 }
8135 /* A reference will be modified here, as it is initialized. */
8139 {
8142 }
8144 /* This needs to happen before extend_ref_init_temps. */
8146 {
8150 }
8153 {
8155 /* [dcl.constinit]/1 "The constinit specifier shall be applied
8156 only to a declaration of a variable with static or thread storage
8157 duration." */
8160 {
8162 "%<constinit%> can only be applied to a variable with "
8165 }
8167 /* If this is a local variable that will need a mangled name,
8168 register it now. We must do this before processing the
8169 initializer for the variable, since the initialization might
8170 require a guard variable, and since the mangled name of the
8171 guard variable will depend on the mangled name of this
8172 variable. */
8176 {
8177 /* The variable holding an anonymous union will have had its
8178 discriminator set in finish_anon_union, after which it's
8179 NAME will have been cleared. */
8182 /* Normally has_forced_label_in_static is set during GIMPLE
8183 lowering, but [cd]tors are never actually compiled directly.
8184 We need to set this early so we can deal with the label
8185 address extension. */
8189 {
8192 }
8193 /* And make sure it's in the symbol table for
8194 c_parse_final_cleanups to find. */
8196 }
8198 /* Convert the initializer to the type of DECL, if we have not
8199 already initialized DECL. */
8201 /* If !DECL_EXTERNAL then DECL is being defined. In the
8202 case of a static data member initialized inside the
8203 class-specifier, there can be an initializer even if DECL
8204 is *not* defined. */
8206 {
8210 /* Handle:
8212 [dcl.init]
8214 The memory occupied by any object of static storage
8215 duration is zero-initialized at program startup before
8216 any other initialization takes place.
8218 We cannot create an appropriate initializer until after
8219 the type of DECL is finalized. If DECL_INITIAL is set,
8220 then the DECL is statically initialized, and any
8221 necessary zero-initialization has already been performed. */
8226 /* Remember that the initialization for this variable has
8227 taken place. */
8229 /* This declaration is the definition of this variable,
8230 unless we are initializing a static data member within
8231 the class specifier. */
8234 }
8235 /* If the variable has an array type, lay out the type, even if
8236 there is no initializer. It is valid to index through the
8237 array, and we must get TYPE_ALIGN set correctly on the array
8238 type. */
8245 /* So decl is a global variable or a static member of a
8246 non local class. Record the types it uses
8247 so that we can decide later to emit debug info for them. */
8249 }
8251 /* Add this declaration to the statement-tree. This needs to happen
8252 after the call to check_initializer so that the DECL_EXPR for a
8253 reference temp is added before the DECL_EXPR for the reference itself. */
8255 {
8256 /* If we're building a variable sized type, and we might be
8257 reachable other than via the top of the current binding
8258 level, then create a new BIND_EXPR so that we deallocate
8259 the object at the right time. */
8264 {
8265 tree bind;
8270 }
8272 }
8274 /* Let the middle end know about variables and functions -- but not
8275 static data members in uninstantiated class templates. */
8277 {
8279 {
8282 /* Check again now that we have an initializer. */
8284 /* A class-scope constexpr variable with an out-of-class declaration.
8285 C++17 makes them implicitly inline, but still force it out. */
8291 }
8294 /* With -fmerge-all-constants, gimplify_init_constructor
8295 might add TREE_STATIC to the variable. */
8297 {
8298 /* If a TREE_READONLY variable needs initialization
8299 at runtime, it is no longer readonly and we need to
8300 avoid MEM_READONLY_P being set on RTL created for it. */
8302 {
8306 }
8310 /* Likewise if it needs destruction. */
8313 }
8317 /* Check for abstractness of the type. */
8322 /* No initialization required. */
8323 ;
8325 {
8327 {
8329 {
8330 /* An out-of-class default definition is defined at
8331 the point where it is explicitly defaulted. */
8336 }
8337 else
8341 decl);
8342 }
8343 /* else no initialization required. */
8344 }
8348 {
8349 /* check_initializer will have done any constant initialization. */
8350 }
8351 /* A variable definition. */
8353 /* Initialize the local variable. */
8356 /* If a variable is defined, and then a subsequent
8357 definition with external linkage is encountered, we will
8358 get here twice for the same variable. We want to avoid
8359 calling expand_static_init more than once. For variables
8360 that are not static data members, we can call
8361 expand_static_init only when we actually process the
8362 initializer. It is not legal to redeclare a static data
8363 member, so this issue does not arise in that case. */
8366 }
8368 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
8369 reference, insert it in the statement-tree now. */
8371 {
8375 }
8384 {
8390 {
8394 }
8399 {
8405 {
8408 {
8412 }
8413 }
8414 }
8415 }
8417 /* This is the last point we can lower alignment so give the target the
8418 chance to do so. */
8425 }
8427 /* For class TYPE return itself or some its bases that contain
8428 any direct non-static data members. Return error_mark_node if an
8429 error has been diagnosed. */
8431 static tree
8433 {
8443 {
8447 else
8452 }
8454 {
8462 }
8463 else
8473 {
8478 {
8480 {
8485 }
8489 {
8491 "classes %qT and %qT have non-static data "
8494 }
8495 else
8497 }
8498 }
8500 }
8502 /* Return std::tuple_size<TYPE>::value. */
8504 static tree
8506 {
8522 else
8524 }
8526 /* Return std::tuple_element<I,TYPE>::type. */
8528 static tree
8530 {
8538 tf_warning_or_error);
8541 }
8543 /* Return e.get<i>() or get<i>(e). */
8545 static tree
8547 {
8554 /* [The id-expression] e is an lvalue if the type of the entity e is an
8555 lvalue reference and an xvalue otherwise. */
8564 /* To use a member get, member lookup must find at least one
8565 declaration that is a function template
8566 whose first template parameter is a non-type parameter. */
8568 {
8571 {
8575 {
8578 }
8579 }
8580 }
8583 {
8588 }
8589 else
8590 {
8596 }
8597 }
8599 /* It's impossible to recover the decltype of a tuple decomposition variable
8600 based on the actual type of the variable, so store it in a hash table. */
8604 tree
8606 {
8608 }
8610 /* Mangle a decomposition declaration if needed. Arguments like
8611 in cp_finish_decomp. */
8613 void
8615 {
8619 {
8627 }
8628 }
8630 /* Finish a decomposition declaration. DECL is the underlying declaration
8631 "e", FIRST is the head of a chain of decls for the individual identifiers
8632 chained through DECL_CHAIN in reverse order and COUNT is the number of
8633 those decls. */
8635 void
8637 {
8639 {
8640 error_out:
8642 {
8645 {
8648 }
8650 }
8654 }
8658 /* This happens for range for when not in templates.
8659 Still add the DECL_VALUE_EXPRs for later processing. */
8660 || (!processing_template_decl
8662 {
8664 {
8666 {
8672 }
8676 }
8678 }
8684 {
8687 }
8693 {
8699 {
8701 type);
8703 }
8704 }
8709 {
8710 tree nelts;
8715 {
8718 }
8721 {
8722 cnt_mismatch:
8727 else
8736 }
8739 {
8747 NULL_TREE);
8750 }
8751 }
8752 /* 2 GNU extensions. */
8754 {
8760 {
8768 t);
8771 }
8772 }
8774 {
8776 {
8779 }
8784 {
8794 NULL_TREE);
8797 }
8798 }
8800 {
8802 {
8806 }
8808 {
8815 }
8821 {
8832 {
8836 }
8838 {
8842 }
8843 /* Save the decltype away before reference collapse. */
8849 {
8850 /* In this case the names are variables, not just proxies. */
8853 }
8855 {
8859 }
8860 }
8861 /* Ignore reads from the underlying decl performed during initialization
8862 of the individual variables. If those will be read, we'll mark
8863 the underlying decl as read at that point. */
8865 }
8867 {
8870 }
8872 {
8875 }
8877 {
8880 }
8885 type);
8886 else
8887 {
8892 {
8896 }
8902 else
8903 eltscnt++;
8908 {
8912 }
8919 else
8920 {
8922 NULL_TREE);
8928 {
8931 }
8932 i++;
8933 }
8934 }
8936 {
8939 {
8944 }
8945 }
8946 }
8948 /* Returns a declaration for a VAR_DECL as if:
8950 extern "C" TYPE NAME;
8952 had been seen. Used to create compiler-generated global
8953 variables. */
8955 static tree
8957 {
8964 /* If the user has explicitly declared this variable (perhaps
8965 because the code we are compiling is part of a low-level runtime
8966 library), then it is possible that our declaration will be merged
8967 with theirs by pushdecl. */
8973 }
8975 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
8976 if "__cxa_atexit" is not being used) corresponding to the function
8977 to be called when the program exits. */
8979 static tree
8981 {
8982 tree fn_type;
8985 {
8986 tree arg_type;
8989 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
8991 else
8992 /* The parameter to "atexit" is "void (*)(void)". */
8998 }
9001 }
9003 /* Returns a pointer to the `atexit' function. Note that if
9004 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
9005 `__cxa_atexit' function specified in the IA64 C++ ABI. */
9007 static tree
9009 {
9010 tree atexit_fndecl;
9011 tree fn_type;
9012 tree fn_ptr_type;
9021 {
9022 /* The declaration for `__cxa_atexit' is:
9024 int __cxa_atexit (void (*)(void *), void *, void *)
9026 We build up the argument types and then the function type
9027 itself. */
9031 /* First, build the pointer-to-function type for the first
9032 argument. */
9034 /* Then, build the rest of the argument types. */
9037 {
9040 }
9041 else
9042 {
9045 }
9046 /* And the final __cxa_atexit type. */
9049 NULL_TREE);
9050 /* ... which needs noexcept. */
9053 {
9061 }
9062 else
9063 {
9066 }
9067 }
9068 else
9069 {
9070 /* The declaration for `atexit' is:
9072 int atexit (void (*)());
9074 We build up the argument types and then the function type
9075 itself. */
9077 /* Build the final atexit type. */
9080 /* ... which needs noexcept. */
9083 }
9085 /* Now, build the function declaration. */
9090 /* Install as hidden builtin so we're (a) more relaxed about
9091 exception spec matching and (b) will not give a confusing location
9092 in diagnostic and (c) won't magically appear in user-visible name
9093 lookups. */
9102 }
9104 /* Like get_atexit_node, but for thread-local cleanups. */
9106 static tree
9108 {
9109 /* The declaration for `__cxa_thread_atexit' is:
9111 int __cxa_thread_atexit (void (*)(void *), void *, void *) */
9115 NULL_TREE);
9117 /* Now, build the function declaration. */
9121 }
9123 /* Returns the __dso_handle VAR_DECL. */
9125 static tree
9127 {
9131 /* Declare the variable. */
9133 ptr_type_node);
9135 #ifdef HAVE_GAS_HIDDEN
9137 {
9140 }
9141 #endif
9144 }
9146 /* Begin a new function with internal linkage whose job will be simply
9147 to destroy some particular variable. */
9151 static tree
9153 {
9158 /* No need to mangle this. */
9161 /* Build the name of the function. */
9163 /* Build the function declaration. */
9167 /* It's a function with internal linkage, generated by the
9168 compiler. */
9171 /* Make the function `inline' so that it is only emitted if it is
9172 actually needed. It is unlikely that it will be inlined, since
9173 it is only called via a function pointer, but we avoid unnecessary
9174 emissions this way. */
9178 {
9179 /* Build the parameter. */
9184 }
9192 }
9194 /* Finish the cleanup function begun by start_cleanup_fn. */
9196 static void
9198 {
9202 }
9204 /* Generate code to handle the destruction of DECL, an object with
9205 static storage duration. */
9207 tree
9209 {
9210 tree cleanup;
9211 tree addr;
9212 tree compound_stmt;
9213 tree fcall;
9214 tree type;
9217 tree atex_node;
9225 {
9228 }
9230 /* If we're using "__cxa_atexit" (or "__cxa_thread_atexit" or
9231 "__aeabi_atexit"), and DECL is a class object, we can just pass the
9232 destructor to "__cxa_atexit"; we don't have to build a temporary
9233 function to do the cleanup. */
9234 dso_parm = (flag_use_cxa_atexit
9239 {
9242 /* Make sure it is accessible. */
9244 tf_warning_or_error);
9245 }
9246 else
9247 {
9248 /* Call build_cleanup before we enter the anonymous function so
9249 that any access checks will be done relative to the current
9250 scope, rather than the scope of the anonymous function. */
9253 /* Now start the function. */
9256 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
9257 to the original function, rather than the anonymous one. That
9258 will make the back end think that nested functions are in use,
9259 which causes confusion. */
9264 /* Create the body of the anonymous function. */
9269 }
9271 /* Call atexit with the cleanup function. */
9277 else
9281 {
9282 /* We must convert CLEANUP to the type that "__cxa_atexit"
9283 expects. */
9285 /* "__cxa_atexit" will pass the address of DECL to the
9286 cleanup function. */
9289 /* The declared type of the parameter to "__cxa_atexit" is
9290 "void *". For plain "T*", we could just let the
9291 machinery in cp_build_function_call convert it -- but if the
9292 type is "cv-qualified T *", then we need to convert it
9293 before passing it in, to avoid spurious errors. */
9295 }
9296 else
9297 /* Since the cleanup functions we build ignore the address
9298 they're given, there's no reason to pass the actual address
9299 in, and, in general, it's cheaper to pass NULL than any
9300 other value. */
9305 tf_warning_or_error);
9307 /* Just pass NULL to the dso handle parm if we don't actually
9308 have a DSO handle on this target. */
9310 else
9314 {
9317 {
9320 }
9321 else
9322 {
9325 }
9326 }
9327 else
9328 {
9331 }
9334 }
9336 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
9337 is its initializer. Generate code to handle the construction
9338 and destruction of DECL. */
9340 static void
9342 {
9346 /* Some variables require no dynamic initialization. */
9348 {
9349 /* Make sure the destructor is callable. */
9353 }
9357 {
9362 else
9367 {
9371 }
9373 }
9376 {
9377 /* Emit code to perform this initialization but once. */
9382 /* We don't need thread-safety code for thread-local vars. */
9386 /* Emit code to perform this initialization but once. This code
9387 looks like:
9389 static <type> guard;
9390 if (!__atomic_load (guard.first_byte)) {
9391 if (__cxa_guard_acquire (&guard)) {
9392 bool flag = false;
9393 try {
9394 // Do initialization.
9395 flag = true; __cxa_guard_release (&guard);
9396 // Register variable for destruction at end of program.
9397 } catch {
9398 if (!flag) __cxa_guard_abort (&guard);
9399 }
9400 }
9401 }
9403 Note that the `flag' variable is only set to 1 *after* the
9404 initialization is complete. This ensures that an exception,
9405 thrown during the construction, will cause the variable to
9406 reinitialized when we pass through this code again, as per:
9408 [stmt.dcl]
9410 If the initialization exits by throwing an exception, the
9411 initialization is not complete, so it will be tried again
9412 the next time control enters the declaration.
9414 This process should be thread-safe, too; multiple threads
9415 should not be able to initialize the variable more than
9416 once. */
9418 /* Create the guard variable. */
9421 /* Begin the conditional initialization. */
9428 {
9441 acquire_fn = push_library_fn
9444 NULL_TREE),
9449 NULL_TREE);
9452 ECF_NOTHROW);
9459 inner_if_stmt);
9467 void_node,
9471 /* Do the initialization itself. */
9477 /* Use atexit to register a function for destroying this static
9478 variable. Do this before calling __cxa_guard_release. */
9482 guard_addr));
9483 }
9484 else
9485 {
9488 /* Use atexit to register a function for destroying this static
9489 variable. */
9491 }
9496 {
9500 }
9505 }
9508 else
9510 }
9512 \f
9513 /* Make TYPE a complete type based on INITIAL_VALUE.
9514 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
9515 2 if there was no information (in which case assume 0 if DO_DEFAULT),
9516 3 if the initializer list is empty (in pedantic mode). */
9518 int
9520 {
9524 /* Don't get confused by a CONSTRUCTOR for some other type. */
9531 {
9532 /* An array of character type can be initialized from a
9533 brace-enclosed string constant.
9535 FIXME: this code is duplicated from reshape_init. Probably
9536 we should just call reshape_init here? */
9540 {
9548 }
9550 /* If any of the elements are parameter packs, we can't actually
9551 complete this type now because the array size is dependent. */
9556 }
9560 /* We can create the array before the element type is complete, which
9561 means that we didn't have these two bits set in the original type
9562 either. In completing the type, we are expected to propagate these
9563 bits. See also complete_type which does the same thing for arrays
9564 of fixed size. */
9567 {
9572 }
9575 }
9577 /* As above, but either give an error or reject zero-size arrays, depending
9578 on COMPLAIN. */
9580 int
9583 {
9586 /* In SFINAE context we can't be lenient about zero-size arrays. */
9593 {
9599 {
9602 }
9606 }
9608 }
9609 \f
9610 /* Return zero if something is declared to be a member of type
9611 CTYPE when in the context of CUR_TYPE. STRING is the error
9612 message to print in that case. Otherwise, quietly return 1. */
9614 static int
9616 {
9618 {
9621 else
9624 }
9626 }
9627 \f
9628 /* Subroutine of `grokdeclarator'. */
9630 /* Generate errors possibly applicable for a given set of specifiers.
9631 This is for ARM $7.1.2. */
9633 static void
9642 {
9644 {
9688 }
9692 && !flag_noexcept_type
9698 }
9700 /* DECL is a member function or static data member and is presently
9701 being defined. Check that the definition is taking place in a
9702 valid namespace. */
9704 static void
9706 {
9707 /* These checks only apply to member functions and static data
9708 members. */
9710 /* We check for problems with specializations in pt.c in
9711 check_specialization_namespace, where we can issue better
9712 diagnostics. */
9715 /* We check this in check_explicit_instantiation_namespace. */
9718 /* [class.mfct]
9720 A member function definition that appears outside of the
9721 class definition shall appear in a namespace scope enclosing
9722 the class definition.
9724 [class.static.data]
9726 The definition for a static data member shall appear in a
9727 namespace scope enclosing the member's class definition. */
9731 }
9733 /* Build a PARM_DECL for the "this" parameter of FN. TYPE is the
9734 METHOD_TYPE for a non-static member function; QUALS are the
9735 cv-qualifiers that apply to the function. */
9737 tree
9739 {
9740 tree this_type;
9741 tree qual_type;
9742 tree parm;
9743 cp_cv_quals this_quals;
9746 {
9747 this_type
9750 }
9751 else
9753 /* The `this' parameter is implicitly `const'; it cannot be
9754 assigned to. */
9760 }
9762 /* DECL is a static member function. Complain if it was declared
9763 with function-cv-quals. */
9765 static void
9767 {
9770 decl);
9771 }
9773 // Check that FN takes no arguments and returns bool.
9774 static void
9776 {
9777 // A constraint is nullary.
9782 // The declared return type of the concept shall be bool, and
9783 // it shall not be deduced from it definition.
9791 }
9793 /* Helper function. Replace the temporary this parameter injected
9794 during cp_finish_omp_declare_simd with the real this parameter. */
9796 static tree
9798 {
9807 }
9809 /* CTYPE is class type, or null if non-class.
9810 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
9811 or METHOD_TYPE.
9812 DECLARATOR is the function's name.
9813 PARMS is a chain of PARM_DECLs for the function.
9814 VIRTUALP is truthvalue of whether the function is virtual or not.
9815 FLAGS are to be passed through to `grokclassfn'.
9816 QUALS are qualifiers indicating whether the function is `const'
9817 or `volatile'.
9818 RAISES is a list of exceptions that this function can raise.
9819 CHECK is 1 if we must find this method in CTYPE, 0 if we should
9820 not look, and -1 if we should not call `grokclassfn' at all.
9822 SFK is the kind of special function (if any) for the new function.
9824 Returns `NULL_TREE' if something goes wrong, after issuing
9825 applicable error messages. */
9827 static tree
9829 tree type,
9830 tree declarator,
9831 tree parms,
9832 tree orig_declarator,
9834 tree decl_reqs,
9837 cp_cv_quals quals,
9838 cp_ref_qualifier rqual,
9839 tree raises,
9845 special_function_kind sfk,
9849 tree in_namespace,
9851 location_t location)
9852 {
9853 tree decl;
9855 tree t;
9860 /* Was the concept specifier present? */
9863 /* Concept declarations must have a corresponding definition. */
9865 {
9868 }
9874 /* Set the constraints on the declaration. */
9876 {
9881 && (current_template_depth
9884 {
9886 /* If there are no template parameters, something must have
9887 gone wrong. */
9889 else
9891 }
9894 {
9897 }
9898 /* C++20 CA378: Remove non-templated constrained functions. */
9900 && (block_local
9901 || (!flag_concepts_ts
9902 && (!processing_template_decl
9904 {
9907 }
9909 }
9912 {
9917 /* Allocate space to hold the vptr bit if needed. */
9919 }
9925 /* Propagate volatile out from type to decl. */
9929 /* Setup decl according to sfk. */
9931 {
9944 }
9947 {
9951 orig_declarator);
9952 else
9953 {
9958 {
9959 /* Something like `template <class T> friend void f<T>()'. */
9961 "invalid use of template-id %qD in declaration "
9963 orig_declarator);
9965 }
9968 /* A friend declaration of the form friend void f<>(). Record
9969 the information in the TEMPLATE_ID_EXPR. */
9978 {
9980 "default arguments are not allowed in declaration "
9982 decl);
9984 }
9987 {
9989 "%<inline%> is not allowed in declaration of friend "
9991 decl);
9993 }
9994 }
9995 }
9997 /* C++17 11.3.6/4: "If a friend declaration specifies a default argument
9998 expression, that declaration shall be a definition..." */
10000 {
10004 {
10006 "friend declaration of %qD specifies default "
10009 }
10010 }
10012 /* If this decl has namespace scope, set that up. */
10017 else
10020 /* `main' and builtins have implicit 'C' linkage. */
10035 /* Should probably propagate const out from type to decl I bet (mrs). */
10037 {
10040 }
10049 {
10065 }
10067 /* Members of anonymous types and local classes have no linkage; make
10068 them internal. If a typedef is made later, this will be changed. */
10074 {
10075 /* [basic.link]: A name with no linkage (notably, the name of a class
10076 or enumeration declared in a local scope) shall not be used to
10077 declare an entity with linkage.
10079 DR 757 relaxes this restriction for C++0x. */
10081 }
10085 {
10088 }
10090 /* If the declaration was declared inline, mark it as such. */
10092 {
10096 }
10100 {
10103 }
10105 // If the concept declaration specifier was found, check
10106 // that the declaration satisfies the necessary requirements.
10108 {
10111 }
10115 {
10118 TYPE_UNQUALIFIED,
10119 REF_QUAL_NONE);
10122 {
10126 decl);
10128 }
10131 {
10135 decl);
10137 }
10138 }
10141 {
10145 {
10150 }
10153 {
10157 }
10161 }
10166 {
10170 /* [over.literal]/6: Literal operators shall not have C linkage. */
10172 {
10176 }
10179 {
10182 {
10185 }
10189 {
10193 }
10195 {
10199 }
10200 /* 17.6.3.3.5 */
10204 "literal operator suffixes not preceded by %<_%>"
10206 }
10207 else
10208 {
10211 }
10212 }
10215 /* Make the init_value nonzero so pushdecl knows this is not
10216 tentative. error_mark_node is replaced later with the BLOCK. */
10223 {
10224 /* Adjust "omp declare simd" attributes. */
10227 {
10228 tree attr;
10231 {
10236 {
10238 cl = c_omp_declare_simd_clauses_to_numbers
10242 else
10244 }
10245 }
10246 }
10247 }
10249 /* Caller will do the rest of this. */
10256 /* 12.4/3 */
10266 template_count,
10278 {
10281 }
10283 /* Check main's type after attributes have been applied. */
10285 {
10287 integer_type_node))
10288 {
10290 tree newtype;
10295 }
10298 }
10301 {
10303 (current_template_depth
10305 ? current_template_parms
10312 {
10313 tree ok;
10314 tree pushed_scope;
10317 /* Because grokfndecl is always supposed to return a
10318 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
10319 here. We depend on our callers to figure out that its
10320 really a template that's being returned. */
10325 {
10326 /* Remove the `this' parm added by grokclassfn. */
10329 }
10331 {
10334 }
10336 {
10341 }
10343 /* Since we've smashed OLD_DECL to its
10344 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
10348 /* Attempt to merge the declarations. This can fail, in
10349 the case of some invalid specialization declarations. */
10355 {
10359 }
10363 }
10364 }
10376 }
10378 /* decl is a FUNCTION_DECL.
10379 specifiers are the parsed virt-specifiers.
10381 Set flags to reflect the virt-specifiers.
10383 Returns decl. */
10385 static tree
10387 {
10395 }
10397 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
10398 the linkage that DECL will receive in the object file. */
10400 static void
10402 {
10403 /* A static data member always has static storage duration and
10404 external linkage. Note that static data members are forbidden in
10405 local classes -- the only situation in which a class has
10406 non-external linkage. */
10409 /* For non-template classes, static data members are always put
10410 out in exactly those files where they are defined, just as
10411 with ordinary namespace-scope variables. */
10414 }
10416 /* Create a VAR_DECL named NAME with the indicated TYPE.
10418 If SCOPE is non-NULL, it is the class type or namespace containing
10419 the variable. If SCOPE is NULL, the variable should is created in
10420 the innermost enclosing scope. */
10422 static tree
10424 tree name,
10425 tree orig_declarator,
10432 tree scope,
10433 location_t location)
10434 {
10435 tree decl;
10436 tree explicit_scope;
10443 /* Compute the scope in which to place the variable, but remember
10444 whether or not that scope was explicitly specified by the user. */
10447 {
10448 /* An explicit "extern" specifier indicates a namespace-scope
10449 variable. */
10454 }
10458 template, we need DECL_LANG_SPECIFIC. */
10460 /* Similarly for namespace-scope variables with language linkage
10461 other than C++. */
10464 /* Similarly for static data members. */
10466 /* Similarly for explicit specializations. */
10467 || (orig_declarator
10470 else
10475 else
10479 {
10482 }
10485 {
10487 /* This function is only called with out-of-class definitions. */
10490 }
10491 /* At top level, either `static' or no s.c. makes a definition
10492 (perhaps tentative), and absence of `static' makes it public. */
10494 {
10497 || ! constp
10498 || volatilep
10501 }
10502 /* Not at top level, only `static' makes a static definition. */
10503 else
10504 {
10507 }
10512 {
10514 {
10518 }
10521 }
10523 /* If the type of the decl has no linkage, make sure that we'll
10524 notice that in mark_used. */
10533 {
10534 /* [basic.link]: A name with no linkage (notably, the name of a class
10535 or enumeration declared in a local scope) shall not be used to
10536 declare an entity with linkage.
10538 DR 757 relaxes this restriction for C++0x. */
10541 }
10542 else
10551 /* Check that the variable can be safely declared as a concept.
10552 Note that this also forbids explicit specializations. */
10554 {
10556 {
10560 }
10562 {
10566 }
10567 else
10573 {
10576 }
10577 }
10580 {
10585 }
10587 // Handle explicit specializations and instantiations of variable templates.
10593 }
10595 /* Create and return a canonical pointer to member function type, for
10596 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
10598 tree
10600 {
10602 tree t;
10607 /* Make sure that we always have the unqualified pointer-to-member
10608 type first. */
10610 {
10613 }
10615 /* If a canonical type already exists for this type, use it. We use
10616 this method instead of type_hash_canon, because it only does a
10617 simple equality check on the list of field members. */
10625 /* Let the front end know this is a pointer to member function. */
10633 delta_type_node);
10640 /* Zap out the name so that the back end will give us the debugging
10641 information for this anonymous RECORD_TYPE. */
10644 /* Cache this pointer-to-member type so that we can find it again
10645 later. */
10654 }
10656 /* Create and return a pointer to data member type. */
10658 tree
10660 {
10662 {
10667 }
10668 else
10669 {
10672 }
10673 }
10675 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
10676 Check to see that the definition is valid. Issue appropriate error
10677 messages. */
10679 static void
10681 {
10682 /* Avoid redundant diagnostics on out-of-class definitions. */
10684 ;
10685 /* Can't check yet if we don't know the type. */
10687 ;
10688 /* If DECL is declared constexpr, we'll do the appropriate checks
10689 in check_initializer. Similarly for inline static data members. */
10693 ;
10695 {
10698 "in-class initialization of static data member %q#D of "
10702 "%<constexpr%> needed for in-class initialization of "
10704 else
10706 "in-class initialization of static data member %q#D of "
10708 }
10709 /* Motion 10 at San Diego: If a static const integral data member is
10710 initialized with an integral constant expression, the initializer
10711 may appear either in the declaration (within the class), or in
10712 the definition, but not both. If it appears in the class, the
10713 member is a member constant. The file-scope definition is always
10714 required. */
10717 "invalid in-class initialization of static data member "
10719 type);
10722 "ISO C++ forbids in-class initialization of non-const "
10724 decl);
10727 "ISO C++ forbids initialization of member constant "
10729 }
10731 /* *expr_p is part of the TYPE_SIZE of a variably-sized array. If any
10732 SAVE_EXPRs in *expr_p wrap expressions with side-effects, break those
10733 expressions out into temporary variables so that walk_tree doesn't
10734 step into them (c++/15764). */
10736 static tree
10738 {
10742 {
10748 }
10752 }
10754 /* Entry point for the above. */
10756 static void
10758 {
10760 /* Break out any function calls into temporary variables. */
10762 }
10764 /* Reduce a SIZEOF_EXPR to its value. */
10766 tree
10768 {
10769 tree r;
10778 else
10785 }
10787 /* Given the SIZE (i.e., number of elements) in an array, compute
10788 an appropriate index type for the array. If non-NULL, NAME is
10789 the name of the entity being declared. */
10791 static tree
10793 tsubst_flags_t complain)
10794 {
10798 /* The type of the index being computed. */
10799 tree itype;
10801 /* The original numeric size as seen in the source code before
10802 conversion to size_t. */
10808 {
10813 /* In C++98, we mark a non-constant array bound with a magic
10815 else
10816 {
10818 /* Pedantically a constant expression is required here and so
10819 __builtin_is_constant_evaluated () should fold to true if it
10820 is successfully folded into a constant. */
10826 }
10831 /* The array bound must be an integer type. */
10834 {
10840 else
10843 }
10844 }
10846 /* A type is dependent if it is...an array type constructed from any
10847 dependent type or whose size is specified by a constant expression
10848 that is value-dependent. */
10849 /* We can only call value_dependent_expression_p on integral constant
10850 expressions. */
10854 {
10855 /* Just build the index type and mark that it requires
10856 structural equality checks. */
10857 in_template:
10864 }
10867 {
10870 {
10874 else
10877 }
10879 /* We might have lost the TREE_CONSTANT flag e.g. when we are
10880 folding a conversion from a pointer to integral type. In that
10882 else
10883 /* Use the folded result for VLAs, too; it will have resolved
10884 SIZEOF_EXPR. */
10886 }
10888 /* Normally, the array-bound will be a constant. */
10890 {
10891 /* The size to use in diagnostics that reflects the constant
10892 size used in the source, rather than SIZE massaged above. */
10895 /* If the original size before conversion to size_t was signed
10896 and negative, convert it to ssizetype to restore the sign. */
10900 {
10903 /* Clear the overflow bit that may have been set as a result
10904 of the conversion from the sizetype of the new size to
10905 ssizetype. */
10907 }
10909 /* Verify that the array has a positive number of elements
10910 and issue the appropriate diagnostic if it doesn't. */
10912 {
10916 }
10917 /* As an extension we allow zero-sized arrays. */
10919 {
10921 /* We must fail if performing argument deduction (as
10922 indicated by the state of complain), so that
10923 another substitution can be found. */
10928 else
10931 }
10932 }
10934 /* We don't allow VLAs at non-function scopes, or during
10935 tentative template substitution. */
10938 {
10941 /* `(int) &fn' is not a valid array bound. */
10945 name);
10946 else
10949 }
10951 {
10955 else
10958 }
10960 {
10964 else
10967 }
10971 else
10972 {
10974 {
10975 /* A variable sized array. Arrange for the SAVE_EXPR on the inside
10976 of the MINUS_EXPR, which allows the -1 to get folded with the +1
10977 that happens when building TYPE_SIZE. */
10980 }
10982 /* Compute the index of the largest element in the array. It is
10983 one less than the number of elements in the array. We save
10984 and restore PROCESSING_TEMPLATE_DECL so that computations in
10985 cp_build_binary_op will be appropriately folded. */
10986 {
10987 processing_template_decl_sentinel s;
10989 MINUS_EXPR,
10992 complain),
10993 complain);
10995 }
10998 {
11001 {
11002 /* We have to add 1 -- in the ubsan routine we generate
11003 LE_EXPR rather than LT_EXPR. */
11008 }
11009 }
11010 /* Make sure that there was no overflow when creating to a signed
11011 index type. (For example, on a 32-bit machine, an array with
11012 size 2^32 - 1 is too big.) */
11015 {
11020 }
11021 }
11023 /* Create and return the appropriate index type. */
11026 /* If the index type were dependent, we would have returned early, so
11027 remember that it isn't. */
11031 }
11033 tree
11035 {
11037 }
11039 /* Returns the scope (if any) in which the entity declared by
11040 DECLARATOR will be located. If the entity was declared with an
11041 unqualified name, NULL_TREE is returned. */
11043 tree
11045 {
11049 /* If the declarator-id is a SCOPE_REF, the scope in which the
11050 declaration occurs is the first operand. */
11055 /* Otherwise, the declarator is not a qualified name; the entity will
11056 be declared in the current scope. */
11058 }
11060 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
11061 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
11062 with this type. */
11064 static tree
11066 {
11069 /* If things have already gone awry, bail now. */
11073 /* If there are some types which cannot be array elements,
11074 issue an error-message and return. */
11076 {
11080 else
11087 else
11094 else
11101 name);
11102 else
11108 }
11114 /* [dcl.array]
11116 The constant expressions that specify the bounds of the arrays
11117 can be omitted only for the first member of the sequence. */
11119 {
11123 name);
11124 else
11129 }
11131 /* Figure out the index type for the array. */
11134 tf_warning_or_error);
11137 }
11139 /* Returns the smallest location that is not UNKNOWN_LOCATION. */
11141 static location_t
11143 {
11149 }
11151 /* Returns the smallest location != UNKNOWN_LOCATION among the
11152 three stored in LOCATIONS[ds_const], LOCATIONS[ds_volatile],
11153 and LOCATIONS[ds_restrict]. */
11155 static location_t
11157 {
11170 }
11172 /* Returns the smallest among the latter and locations[ds_type_spec]. */
11174 static location_t
11176 {
11179 }
11181 static location_t
11183 {
11186 }
11188 /* Check that it's OK to declare a function with the indicated TYPE
11189 and TYPE_QUALS. SFK indicates the kind of special function (if any)
11190 that this function is. OPTYPE is the type given in a conversion
11191 operator declaration, or the class type for a constructor/destructor.
11192 Returns the actual return type of the function; that may be different
11193 than TYPE if an error occurs, or for certain special functions. */
11195 static tree
11197 tree type,
11198 tree optype,
11201 {
11203 {
11214 else
11226 /* We can't use the proper return type here because we run into
11227 problems with ambiguous bases and covariant returns. */
11230 else
11240 "qualifiers are not allowed on declaration of "
11252 "qualifiers are not allowed on declaration of "
11255 {
11259 }
11260 else
11270 }
11273 }
11275 /* A variable or data member (whose unqualified name is IDENTIFIER)
11276 has been declared with the indicated TYPE. If the TYPE is not
11277 acceptable, issue an error message and return a type to use for
11278 error-recovery purposes. */
11280 tree
11282 {
11284 {
11288 {
11291 identifier);
11292 }
11293 else
11296 }
11299 }
11301 /* Handle declaring DECL as an inline variable. */
11303 static void
11305 {
11308 {
11312 }
11317 {
11320 }
11321 }
11324 /* Assign a typedef-given name to a class or enumeration type declared
11325 as anonymous at first. This was split out of grokdeclarator
11326 because it is also used in libcc1. */
11328 void
11330 {
11333 /* Replace the anonymous decl with the real decl. Be careful not to
11334 rename other typedefs (such as the self-reference) of type. */
11340 /* If this is a typedef within a template class, the nested
11341 type is a (non-primary) template. The name for the
11342 template needs updating as well. */
11346 /* Adjust linkage now that we aren't unnamed anymore. */
11349 /* FIXME remangle member functions; member functions of a
11350 type with external linkage have external linkage. */
11352 /* Check that our job is done, and that it would fail if we
11353 attempted to do it again. */
11355 }
11357 /* Check that decltype(auto) was well-formed: only plain decltype(auto)
11358 is allowed. TYPE might contain a decltype(auto). Returns true if
11359 there was a problem, false otherwise. */
11361 static bool
11363 {
11365 {
11367 {
11369 {
11373 }
11375 {
11378 }
11379 }
11380 }
11382 }
11384 /* Given declspecs and a declarator (abstract or otherwise), determine
11385 the name and type of the object declared and construct a DECL node
11386 for it.
11388 DECLSPECS points to the representation of declaration-specifier
11389 sequence that precedes declarator.
11391 DECL_CONTEXT says which syntactic context this declaration is in:
11392 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
11393 FUNCDEF for a function definition. Like NORMAL but a few different
11394 error messages in each case. Return value may be zero meaning
11395 this definition is too screwy to try to parse.
11396 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
11397 handle member functions (which have FIELD context).
11398 Return value may be zero meaning this definition is too screwy to
11399 try to parse.
11400 PARM for a parameter declaration (either within a function prototype
11401 or before a function body). Make a PARM_DECL, or return void_type_node.
11402 TPARM for a template parameter declaration.
11403 CATCHPARM for a parameter declaration before a catch clause.
11404 TYPENAME if for a typename (in a cast or sizeof).
11405 Don't make a DECL node; just return the ..._TYPE node.
11406 FIELD for a struct or union field; make a FIELD_DECL.
11407 BITFIELD for a field with specified width.
11409 INITIALIZED is as for start_decl.
11411 ATTRLIST is a pointer to the list of attributes, which may be NULL
11412 if there are none; *ATTRLIST may be modified if attributes from inside
11413 the declarator should be applied to the declaration.
11415 When this function is called, scoping variables (such as
11416 CURRENT_CLASS_TYPE) should reflect the scope in which the
11417 declaration occurs, not the scope in which the new declaration will
11418 be placed. For example, on:
11420 void S::f() { ... }
11422 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
11423 should not be `S'.
11425 Returns a DECL (if a declarator is present), a TYPE (if there is no
11426 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
11427 error occurs. */
11429 tree
11435 {
11448 /* True if this declarator is a function definition. */
11452 #if 0
11453 /* See the code below that used this. */
11455 #endif
11457 /* Keep track of what sort of function is being processed
11458 so that we can warn about default return values, or explicit
11459 return values which do not match prescribed defaults. */
11465 /* cv-qualifiers that apply to the declarator, for a declaration of
11466 a member function. */
11468 /* virt-specifiers that apply to the declarator, for a declaration of
11469 a member function. */
11471 /* ref-qualifier that applies to the declarator, for a declaration of
11472 a member function. */
11474 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
11481 /* The unqualified name of the declarator; either an
11482 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
11483 tree unqualified_id;
11484 /* The class type, if any, in which this entity is located,
11485 or NULL_TREE if none. Note that this value may be different from
11486 the current class type; for example if an attempt is made to declare
11487 "A::f" inside "B", this value will be "A". */
11489 /* The NAMESPACE_DECL for the namespace in which this entity is
11490 located. If an unqualified name is used to declare the entity,
11491 this value will be NULL_TREE, even if the entity is located at
11492 namespace scope. */
11494 cp_storage_class storage_class;
11517 // Was concept_p specified? Note that ds_concept
11518 // implies ds_constexpr!
11540 location_t id_loc;
11541 location_t init_loc;
11543 {
11546 }
11547 else
11550 /* Look inside a declarator for the name being declared
11551 and get it as a string, for an error message. */
11553 id_declarator;
11555 {
11560 {
11564 {
11568 }
11572 {
11578 {
11583 {
11584 /* [dcl.meaning]
11586 A declarator-id shall not be qualified except
11587 for ...
11589 None of the cases are permitted in block
11590 scope. */
11593 decl);
11597 else
11601 }
11603 {
11606 {
11610 }
11612 && current_class_type
11614 current_class_type))
11615 {
11620 }
11621 }
11624 }
11626 {
11628 {
11630 {
11634 }
11637 {
11641 }
11648 }
11652 {
11658 }
11659 /* Fall through. */
11666 {
11668 dname);
11670 }
11673 else
11674 {
11681 else
11683 }
11688 }
11690 }
11707 }
11710 }
11712 /* [dcl.fct.edf]
11714 The declarator in a function-definition shall have the form
11715 D1 ( parameter-declaration-clause) ... */
11717 {
11720 }
11725 {
11728 }
11731 {
11734 {
11737 }
11740 {
11742 {
11745 }
11747 {
11750 }
11751 }
11752 }
11754 /* Anything declared one level down from the top level
11755 must be one of the parameters of a function
11756 (because the body is at least two levels down). */
11758 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
11759 by not allowing C++ class definitions to specify their parameters
11760 with xdecls (must be spec.d in the parmlist).
11762 Since we now wait to push a class scope until we are sure that
11763 we are in a legitimate method context, we must set oldcname
11764 explicitly (since current_class_name is not yet alive).
11766 We also want to avoid calling this a PARM if it is in a namespace. */
11769 {
11775 }
11781 {
11785 }
11788 {
11792 }
11795 {
11799 }
11802 {
11806 }
11809 {
11813 }
11815 /* [dcl.spec]/2 "At most one of the constexpr, consteval, and constinit
11816 keywords shall appear in a decl-specifier-seq." */
11818 {
11822 "can use at most one of the %<constinit%> and %<constexpr%> "
11825 }
11827 /* If there were multiple types specified in the decl-specifier-seq,
11828 issue an error message. */
11830 {
11834 }
11837 {
11842 }
11844 /* Extract the basic type from the decl-specifier-seq. */
11847 {
11850 }
11852 /* Ignore erroneous attributes. */
11856 /* An object declared as __attribute__((unavailable)) suppresses
11857 any reports of being declared with unavailable or deprecated
11858 items. An object declared as __attribute__((deprecated))
11859 suppresses warnings of uses of other deprecated items. */
11868 {
11874 }
11875 /* No type at all: default to `int', and set DEFAULTED_INT
11876 because it was not a user-defined typedef. */
11878 {
11880 {
11881 /* These imply 'int'. */
11884 }
11885 /* If we just have "complex", it is equivalent to "complex double". */
11888 {
11891 "ISO C++ does not support plain %<complex%> meaning "
11893 }
11894 }
11895 /* Gather flags. */
11899 #if 0
11900 /* See the code below that used this. */
11903 #endif
11908 else
11912 {
11914 ctor_return_type,
11915 type_quals,
11918 }
11920 {
11925 /* We handle `main' specially here, because 'main () { }' is so
11926 common. With no options, it is allowed. With -Wreturn-type,
11927 it is a warning. It is only an error with -pedantic-errors. */
11928 is_main = (funcdef_flag
11941 name);
11945 else
11950 /* FIXME we should be able to propagate the error_mark_node as is
11951 for other contexts too. */
11953 else
11955 }
11960 {
11962 {
11967 }
11968 /* Don't pedwarn if the alternate "__intN__" form has been used instead
11969 of "__intN". */
11974 }
11976 /* Now process the modifiers that were specified
11977 and check for invalid combinations. */
11979 /* Long double is a special combination. */
11981 {
11985 }
11987 /* Check all other uses of type modifiers. */
11990 {
11991 location_t loc;
11994 {
11997 }
11999 {
12002 }
12004 {
12007 }
12009 {
12012 }
12014 {
12017 }
12022 {
12027 }
12029 {
12033 }
12043 {
12045 {
12049 }
12052 else
12054 }
12055 else
12058 /* Discard the type modifiers if they are invalid. */
12060 {
12066 }
12067 }
12069 /* Decide whether an integer type is signed or not.
12070 Optionally treat bitfields as signed by default. */
12072 /* [class.bit]
12074 It is implementation-defined whether a plain (neither
12075 explicitly signed or unsigned) char, short, int, or long
12076 bit-field is signed or unsigned.
12078 Naturally, we extend this to long long as well. Note that
12079 this does not include wchar_t. */
12081 && !signed_p
12082 /* A typedef for plain `int' without `signed' can be
12083 controlled just like plain `int', but a typedef for
12084 `signed int' cannot be so controlled. */
12085 && !(typedef_decl
12089 {
12102 else
12104 }
12117 {
12121 /* If a modifier is specified, the resulting complex is the complex
12122 form of TYPE. E.g, "complex short" is "complex short int". */
12131 else
12133 }
12135 /* If we're using the injected-class-name to form a compound type or a
12136 declaration, replace it with the underlying class so we don't get
12137 redundant typedefs in the debug output. But if we are returning the
12138 type unchanged, leave it alone so that it's available to
12139 maybe_get_template_decl_from_type_decl. */
12147 type = cp_build_qualified_type_real
12151 /* We might have ignored or rejected some of the qualifiers. */
12158 {
12163 }
12174 /* Treat class-scope deduction guides as static member functions
12175 so that they get a FUNCTION_TYPE instead of a METHOD_TYPE. */
12179 {
12181 {
12188 }
12190 {
12194 "declared both %<virtual%> and %<constexpr%> only in "
12196 }
12197 }
12200 /* Issue errors about use of storage classes for parameters. */
12202 {
12204 {
12208 }
12210 {
12214 name);
12216 }
12220 {
12225 }
12227 /* Function parameters cannot be concept. */
12229 {
12234 }
12235 /* Function parameters cannot be constexpr. If we saw one, moan
12236 and pretend it wasn't there. */
12238 {
12242 }
12244 {
12248 }
12250 {
12254 }
12255 }
12257 /* Give error if `virtual' is used outside of class declaration. */
12260 {
12264 }
12267 {
12284 "structured binding declaration can be %qs only in "
12286 declspecs->gnu_thread_keyword_p
12291 /* [dcl.struct.bind] "A cv that includes volatile is deprecated." */
12296 {
12306 "structured binding declaration can be %qs only in "
12323 }
12326 {
12328 {
12332 "type must be cv-qualified %<auto%> or reference to "
12334 }
12337 }
12344 {
12347 }
12348 }
12350 /* Static anonymous unions are dealt with here. */
12356 /* Warn about storage classes that are invalid for certain
12357 kinds of declarations (parameters, typenames, etc.). */
12359 && ((storage_class
12363 {
12364 location_t loc
12369 }
12374 {
12378 ;
12380 ;
12382 /* C++ allows static class elements. */
12384 /* C++ also allows inlines and signed and unsigned elements,
12385 but in those cases we don't come in here. */
12386 ;
12387 else
12388 {
12389 location_t loc
12396 else
12403 }
12404 }
12409 {
12413 }
12417 {
12423 /* When thread_local is applied to a variable of block scope the
12424 storage-class-specifier static is implied if it does not appear
12425 explicitly. */
12428 }
12431 {
12434 "storage class specifiers invalid in friend function "
12438 }
12442 else
12443 {
12446 {
12459 }
12460 }
12463 {
12468 }
12470 /* Determine the type of the entity declared by recurring on the
12471 declarator. */
12473 {
12475 tree attrs;
12482 {
12494 /* Assume that any attributes that get applied late to
12495 templates will DTRT when applied to the declaration
12496 as a whole. */
12500 attr_flags);
12502 }
12506 /* We don't want to warn in parameter context because we don't
12507 yet know if the parse will succeed, and this might turn out
12508 to be a constructor call. */
12511 && !typedef_p
12513 /* If the type is class-like and the inner name used a
12514 global namespace qualifier, we need the parens.
12515 Unfortunately all we can tell is whether a qualified name
12516 was used or not. */
12517 && !(inner_declarator
12522 {
12525 name))
12526 {
12531 }
12532 }
12537 {
12548 /* [dcl.array]/1:
12550 The optional attribute-specifier-seq appertains to the
12551 array. */
12557 {
12558 tree arg_types;
12561 /* Declaring a function type. */
12563 /* Pick up type qualifiers which should be applied to `this'. */
12565 /* Pick up virt-specifiers. */
12567 /* And ref-qualifier, too */
12569 /* And tx-qualifier. */
12571 /* Pick up the exception specifications. */
12573 /* If the exception-specification is ill-formed, let's pretend
12574 there wasn't one. */
12582 /* Say it's a definition only for the CALL_EXPR
12583 closest to the identifier. */
12586 /* Handle a late-specified return type. */
12589 {
12591 {
12598 {
12600 "%<auto%> type specifier without "
12603 "deduced return type only available "
12605 }
12607 {
12611 }
12612 }
12614 {
12616 "return type has %qT as its type rather "
12619 }
12621 {
12624 "%qs function with trailing return type "
12625 "has %<decltype(auto)%> as its type "
12627 else
12631 }
12637 {
12639 {
12646 }
12648 {
12650 "for %qT must have trailing return "
12655 }
12661 else
12665 }
12666 }
12669 {
12673 /* Not using maybe_warn_cpp0x because this should
12674 always be an error. */
12676 "trailing return type only available "
12678 else
12680 "return type not declared with %<auto%> "
12683 }
12689 {
12692 }
12695 {
12699 /* [dcl.fct] "A volatile-qualified return type is
12700 deprecated." */
12703 "%<volatile%>-qualified return type is "
12706 /* We now know that the TYPE_QUALS don't apply to the
12707 decl, but to its return type. */
12709 }
12711 /* Error about some types functions can't return. */
12714 {
12718 }
12720 {
12724 }
12726 {
12728 "%<constinit%> on function return type is not "
12731 }
12738 && funcdecl_p
12744 {
12745 /* We are within a class's scope. If our declarator name
12746 is the same as the class name, and we are defining
12747 a function, then it is a constructor/destructor, and
12748 therefore returns a void type. */
12750 /* ISO C++ 12.4/2. A destructor may not be declared
12751 const or volatile. A destructor may not be static.
12752 A destructor may not be declared with ref-qualifier.
12754 ISO C++ 12.1. A constructor may not be declared
12755 const or volatile. A constructor may not be
12756 virtual. A constructor may not be static.
12757 A constructor may not be declared with ref-qualifier. */
12766 {
12771 }
12774 {
12780 }
12784 current_class_type,
12785 flags))
12789 {
12790 /* It's a constructor. */
12794 {
12798 }
12802 }
12805 }
12807 {
12809 {
12810 /* Cannot be both friend and virtual. */
12815 }
12820 {
12822 "cannot define friend function %qs in a local "
12825 }
12826 /* [class.friend]/6: A function can be defined in a friend
12827 declaration if the function name is unqualified. */
12829 {
12832 "friend function definition %qs cannot have "
12834 else
12836 "friend function definition %qs cannot have "
12838 in_namespace);
12839 }
12840 }
12842 {
12844 {
12847 }
12850 }
12852 {
12855 }
12862 pushed_scope
12874 {
12879 }
12885 {
12887 /* transaction_safe applies to the type, but
12888 transaction_safe_dynamic applies to the function. */
12891 else
12893 }
12895 /* [dcl.fct]/2:
12897 The optional attribute-specifier-seq appertains to
12898 the function type. */
12903 }
12909 /* Filter out pointers-to-references and references-to-references.
12910 We can get these if a TYPE_DECL is used. */
12913 {
12915 {
12918 }
12920 /* In C++0x, we allow reference to reference declarations
12921 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
12922 and template type arguments [14.3.1/4 temp.arg.type]. The
12923 check for direct reference to reference declarations, which
12924 are still forbidden, occurs below. Reasoning behind the change
12925 can be found in DR106, DR540, and the rvalue reference
12926 proposals. */
12928 {
12931 }
12932 }
12934 {
12939 }
12941 /* We now know that the TYPE_QUALS don't apply to the decl,
12942 but to the target of the pointer. */
12945 /* This code used to handle METHOD_TYPE, but I don't think it's
12946 possible to get it here anymore. */
12950 {
12954 memfn_quals,
12955 rqual);
12961 }
12969 type);
12971 /* When the pointed-to type involves components of variable size,
12972 care must be taken to ensure that the size evaluation code is
12973 emitted early enough to dominate all the possible later uses
12974 and late enough for the variables on which it depends to have
12975 been assigned.
12977 This is expected to happen automatically when the pointed-to
12978 type has a name/declaration of it's own, but special attention
12979 is required if the type is anonymous.
12981 We handle the NORMAL and FIELD contexts here by inserting a
12982 dummy statement that just evaluates the size at a safe point
12983 and ensures it is not deferred until e.g. within a deeper
12984 conditional context (c++/43555).
12986 We expect nothing to be needed here for PARM or TYPENAME.
12987 Evaluating the size at this point for TYPENAME would
12988 actually be incorrect, as we might be in the middle of an
12989 expression with side effects on the pointed-to type size
12990 "arguments" prior to the pointer declaration point and the
12991 size evaluation could end up prior to the side effects. */
12997 {
13001 }
13004 {
13005 /* In C++0x, the type we are creating a reference to might be
13006 a typedef which is itself a reference type. In that case,
13007 we follow the reference collapsing rules in
13008 [7.1.3/8 dcl.typedef] to create the final reference type:
13010 "If a typedef TD names a type that is a reference to a type
13011 T, an attempt to create the type 'lvalue reference to cv TD'
13012 creates the type 'lvalue reference to T,' while an attempt
13013 to create the type "rvalue reference to cv TD' creates the
13014 type TD."
13015 */
13019 {
13022 else
13024 }
13025 else
13026 type = cp_build_reference_type
13029 /* In C++0x, we need this check for direct reference to
13030 reference declarations, which are forbidden by
13031 [8.3.2/5 dcl.ref]. Reference to reference declarations
13032 are only allowed indirectly through typedefs and template
13033 type arguments. Example:
13035 void foo(int & &); // invalid ref-to-ref decl
13037 typedef int & int_ref;
13038 void foo(int_ref &); // valid ref-to-ref decl
13039 */
13043 }
13047 {
13051 /* We will already have complained. */
13053 else
13055 type);
13056 }
13057 else
13060 /* Process a list of type modifier keywords (such as
13061 const or volatile) that were given inside the `*' or `&'. */
13064 {
13065 type
13069 }
13071 /* Apply C++11 attributes to the pointer, and not to the
13072 type pointed to. This is unlike what is done for GNU
13073 attributes above. It is to comply with [dcl.ptr]/1:
13075 [the optional attribute-specifier-seq (7.6.1) appertains
13076 to the pointer and not to the object pointed to]. */
13089 }
13090 }
13095 /* Don't check this if it can be the artifical decltype(auto)
13096 we created when building a constraint in a compound-requirement:
13097 that the type-constraint is plain is going to be checked in
13098 cp_parser_compound_requirement. */
13103 /* A `constexpr' specifier used in an object declaration declares
13104 the object as `const'. */
13106 {
13107 /* DR1688 says that a `constexpr' specifier in combination with
13108 `volatile' is valid. */
13111 {
13114 }
13115 }
13120 {
13122 unqualified_id);
13124 }
13126 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
13127 qualified with a class-name, turn it into a METHOD_TYPE, unless
13128 we know that the function is static. We take advantage of this
13129 opportunity to do other processing that pertains to entities
13130 explicitly declared to be class members. Note that if DECLARATOR
13131 is non-NULL, we know it is a cdk_id declarator; otherwise, we
13132 would not have exited the loop above. */
13137 {
13143 {
13145 {
13147 "member functions are implicitly "
13150 }
13151 else
13154 }
13156 can skip the following checks. */
13159 qualifying type must certainly be complete. */
13160 funcdef_flag
13161 /* A friend declaration of "T::f" is OK, even if
13162 "T" is a template parameter. But, if this
13163 function is not a friend, the qualifying type
13164 must be a class. */
13166 /* For a declaration, the type need not be
13167 complete, if either it is dependent (since there
13168 is no meaningful definition of complete in that
13169 case) or the qualifying class is currently being
13170 defined. */
13173 /* Check that the qualifying type is complete. */
13177 {
13180 {
13188 }
13189 }
13191 {
13195 }
13196 }
13201 /* Now TYPE has the actual type. */
13204 {
13207 else
13209 }
13215 {
13216 /* [dcl.meaning]/1: The optional attribute-specifier-seq following
13217 a declarator-id appertains to the entity that is declared. */
13220 else
13221 /* We should have already diagnosed the issue (c++/78344). */
13223 }
13225 /* Handle parameter packs. */
13227 {
13229 /* Turn the type into a pack expansion.*/
13231 else
13233 }
13236 && !processing_template_decl
13238 {
13242 else
13246 }
13249 {
13250 /* [dcl.fct.spec] (C++11) The explicit specifier shall be used only
13251 in the declaration of a constructor or conversion function within
13252 a class definition. */
13259 else
13261 "only declarations of constructors and conversion operators "
13264 }
13267 {
13270 {
13272 name);
13274 }
13276 {
13279 name);
13281 }
13283 {
13285 name);
13287 }
13289 {
13291 name);
13293 }
13295 {
13297 name);
13299 }
13301 {
13303 name);
13305 }
13306 }
13308 /* If this is declaring a typedef name, return a TYPE_DECL. */
13310 {
13312 tree decl;
13315 {
13319 else
13323 }
13325 /* This declaration:
13327 typedef void f(int) const;
13329 declares a function type which is not a member of any
13330 particular class, but which is cv-qualified; for
13331 example "f S::*" declares a pointer to a const-qualified
13332 member function of S. We record the cv-qualification in the
13333 function type. */
13335 {
13338 /* We have now dealt with these qualifiers. */
13341 }
13344 {
13348 else
13352 }
13358 {
13361 }
13365 else
13369 {
13373 /* The TYPE_DECL is "abstract" because there will be
13374 clones of this constructor/destructor, and there will
13375 be copies of this TYPE_DECL generated in those
13376 clones. The decloning optimization (for space) may
13377 revert this subsequently if it determines that
13378 the clones should share a common implementation. */
13382 }
13387 unqualified_id);
13389 /* If the user declares "typedef struct {...} foo" then the
13390 struct will have an anonymous name. Fill that name in now.
13391 Nothing can refer to it, so nothing needs know about the name
13392 change. */
13394 && unqualified_id
13413 /* Acknowledge that this was written:
13414 `using analias = atype;'. */
13418 }
13420 /* Detect the case of an array type of unspecified size
13421 which came, as such, direct from a typedef name.
13422 We must copy the type, so that the array's domain can be
13423 individually set by the object's initializer. */
13430 /* Detect where we're using a typedef of function type to declare a
13431 function. PARMS will not be set, so we must create it now. */
13434 {
13436 tree args;
13441 {
13447 }
13452 {
13453 /* The qualifiers on the function type become the qualifiers on
13454 the non-static member function. */
13459 }
13460 }
13462 /* If this is a type name (such as, in a cast or sizeof),
13463 compute the type and return it now. */
13466 {
13467 /* Note that here we don't care about type_quals. */
13469 /* Special case: "friend class foo" looks like a TYPENAME context. */
13471 {
13473 {
13476 }
13479 {
13480 /* Don't allow friend declaration without a class-key. */
13487 else
13490 type);
13491 }
13493 /* Only try to do this stuff if we didn't already give up. */
13495 {
13496 /* A friendly class? */
13500 else
13502 type);
13505 }
13506 }
13508 {
13515 /* Core issue #547: need to allow this in template type args.
13516 Allow it in general in C++11 for alias-declarations. */
13520 else
13522 }
13528 }
13532 && ! bitfield
13534 {
13537 }
13540 {
13541 /* Only functions may be declared using an operator-function-id. */
13543 {
13546 }
13551 type);
13552 }
13554 /* We don't check parameter types here because we can emit a better
13555 error message later. */
13557 {
13561 }
13563 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
13564 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
13567 {
13573 {
13575 {
13580 {
13581 auto_diagnostic_group g;
13583 "class template placeholder %qE not permitted "
13588 }
13589 else
13592 }
13593 else
13596 }
13598 /* A parameter declared as an array of T is really a pointer to T.
13599 One declared as a function is really a pointer to a function.
13600 One declared as a member is really a pointer to member. */
13603 {
13604 /* Transfer const-ness of array into that of type pointed to. */
13608 }
13611 }
13614 && !(unqualified_id
13617 {
13623 }
13625 {
13629 {
13637 }
13639 {
13642 {
13648 else
13652 }
13654 /* The C99 flexible array extension. */
13657 {
13661 {
13664 }
13665 else
13666 {
13667 /* Array is a flexible member. */
13671 else
13675 /* Flexible array member has a null domain. */
13677 }
13678 }
13681 {
13682 /* Happens when declaring arrays of sizes which
13683 are error_mark_node, for example. */
13685 }
13687 {
13688 /* Something like struct S { int N::j; }; */
13691 }
13693 {
13695 tree function_context;
13698 {
13699 /* This should never happen in pure C++ (the check
13700 could be an assert). It could happen in
13701 Objective-C++ if someone writes invalid code that
13702 uses a function declaration for an instance
13703 variable or property (instance variables and
13704 properties are parsed as FIELD_DECLs, but they are
13705 part of an Objective-C class, not a C++ class).
13706 That code is invalid and is caught by this
13707 check. */
13709 {
13711 unqualified_id);
13713 }
13715 /* ``A union may [ ... ] not [ have ] virtual functions.''
13716 ARM 9.5 */
13718 {
13721 unqualified_id);
13723 }
13728 {
13730 "%qD cannot be declared %<virtual%>, since it "
13733 }
13734 }
13736 /* Check that the name used for a destructor makes sense. */
13738 {
13742 {
13747 }
13750 {
13754 }
13756 {
13760 }
13762 {
13764 "%<constexpr%> destructors only available"
13767 }
13769 {
13773 }
13774 }
13776 {
13781 }
13784 {
13788 }
13790 {
13794 }
13798 {
13802 }
13805 {
13808 {
13814 }
13815 }
13817 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
13818 function_context
13827 parms,
13828 unqualified_id,
13829 declspecs,
13830 reqs,
13842 #if 0
13843 /* This clobbers the attrs stored in `decl' from `attrlist'. */
13844 /* The decl and setting of decl_attr is also turned off. */
13846 #endif
13848 /* [class.conv.ctor]
13850 A constructor declared without the function-specifier
13851 explicit that can be called with a single parameter
13852 specifies a conversion from the type of its first
13853 parameter to the type of its class. Such a constructor
13854 is called a converting constructor. */
13860 }
13862 && ((current_class_type
13868 {
13871 {
13873 {
13877 }
13878 else
13883 }
13884 }
13886 staticp
13887 ? TCTX_STATIC_STORAGE
13889 {
13892 }
13893 else
13894 {
13896 {
13899 "%qE is neither function nor member function; "
13901 else
13905 }
13907 }
13910 {
13911 /* Packages tend to use GNU attributes on friends, so we only
13912 warn for standard attributes. */
13914 {
13919 }
13920 /* Friends are treated specially. */
13924 {
13928 /* Kludge: We need funcdef_flag to be true in do_friend for
13929 in-class defaulted functions, but that breaks grokfndecl.
13930 So set it here. */
13934 {
13935 decl = check_explicit_specialization
13940 }
13945 }
13946 else
13948 }
13950 /* Structure field. It may not be a function, except for C++. */
13953 {
13955 {
13956 /* C++ allows static class members. All other work
13957 for this is done by grokfield. */
13966 {
13968 "%<constexpr%> static data member %qD must "
13971 }
13982 /* Even if there is an in-class initialization, DECL
13983 is considered undefined until an out-of-class
13984 definition is provided, unless this is an inline
13985 variable. */
13989 {
13995 }
13997 /* Set the constraints on the declaration. */
14001 {
14002 tree tmpl_reqs
14006 }
14007 }
14008 else
14009 {
14011 {
14017 }
14019 {
14024 }
14026 {
14031 }
14033 {
14038 }
14045 {
14048 }
14051 {
14052 /* An attempt is being made to initialize a non-static
14053 member. This is new in C++11. */
14056 /* If this has been parsed with static storage class, but
14057 errors forced staticp to be cleared, ensure NSDMI is
14058 not present. */
14061 }
14062 }
14069 }
14070 }
14072 {
14073 tree original_name;
14081 else
14083 // FIXME:gcc_assert (original_name == dname);
14091 name);
14093 {
14097 name);
14098 else
14100 "storage class %<thread_local%> invalid for "
14102 }
14107 /* Function declaration not at top level.
14108 Storage classes other than `extern' are not allowed
14109 and `extern' makes no difference. */
14114 {
14117 "%<static%> specifier invalid for function %qs "
14119 else
14121 "%<inline%> specifier invalid for function %qs "
14123 }
14126 {
14128 {
14131 }
14134 {
14139 }
14140 }
14144 {
14148 }
14150 /* Record whether the function is public. */
14155 declspecs,
14158 publicp,
14162 sfk,
14163 funcdef_flag,
14164 late_return_type_p,
14166 id_loc);
14173 {
14176 /* Don't allow a static member function in a class, and forbid
14177 declaring main to be static. */
14179 {
14183 }
14185 {
14186 /* 7.1.1: There can be no static function declarations within a
14187 block. */
14191 }
14194 {
14197 }
14198 }
14201 }
14202 else
14203 {
14204 /* It's a variable. */
14206 /* An uninitialized decl with `extern' is a reference. */
14208 declspecs,
14209 initialized,
14210 type_quals,
14211 inlinep,
14212 concept_p,
14213 template_count,
14215 id_loc);
14225 {
14228 {
14230 "%<static%> may not be used when defining "
14234 }
14236 {
14239 }
14241 {
14243 "cannot explicitly declare member %q#D to have "
14246 }
14247 }
14249 {
14251 "declaration of %<constexpr%> variable %qD "
14254 }
14256 {
14260 }
14265 {
14270 }
14271 }
14276 {
14280 }
14283 {
14285 {
14286 /* It's common practice (and completely valid) to have a const
14287 be initialized and declared extern. */
14291 }
14292 else
14293 {
14297 }
14298 }
14300 /* Record `register' declaration for warnings on &
14301 and in case doing stupid register allocation. */
14304 {
14306 /* Warn about register storage specifiers on PARM_DECLs. */
14308 {
14311 "ISO C++17 does not allow %<register%> storage "
14313 else
14316 }
14317 }
14324 {
14325 /* Set constexpr flag on vars (functions got it in grokfndecl). */
14328 /* And the constinit flag (which only applies to variables). */
14331 }
14333 /* Record constancy and volatility on the DECL itself . There's
14334 no need to do this when processing a template; we'll do this
14335 for the instantiated declaration based on the type of DECL. */
14340 }
14341 }
14342 \f
14343 /* Subroutine of start_function. Ensure that each of the parameter
14344 types (as listed in PARMS) is complete, as is required for a
14345 function definition. */
14347 static void
14349 {
14351 {
14356 {
14363 }
14364 else
14365 /* grokparms or complete_type_or_else will have already issued
14366 an error. */
14368 }
14369 }
14371 /* Returns nonzero if T is a local variable. */
14373 int
14375 {
14384 }
14386 /* Like local_variable_p, but suitable for use as a tree-walking
14387 function. */
14389 static tree
14392 {
14394 {
14395 /* DR 2082 permits local variables in unevaluated contexts
14396 within a default argument. */
14399 }
14408 }
14410 /* Check that ARG, which is a default-argument expression for a
14411 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
14412 something goes wrong. DECL may also be a _TYPE node, rather than a
14413 DECL, if there is no DECL available. */
14415 tree
14417 {
14418 tree var;
14419 tree decl_type;
14422 /* We get a DEFERRED_PARSE when looking at an in-class declaration
14423 with a default argument. Ignore the argument for now; we'll
14424 deal with it after the class is complete. */
14428 {
14431 }
14432 else
14439 /* Something already went wrong. There's no need to check
14440 further. */
14443 /* [dcl.fct.default]
14445 A default argument expression is implicitly converted to the
14446 parameter type. */
14448 /* Avoid digest_init clobbering the initializer. */
14451 LOOKUP_IMPLICIT);
14454 /* Avoid redundant -Wzero-as-null-pointer-constant warnings at
14455 the call sites. */
14458 /* Don't lose side-effects as in PR90473. */
14462 /* [dcl.fct.default]
14464 Local variables shall not be used in default argument
14465 expressions.
14467 The keyword `this' shall not be used in a default argument of a
14468 member function. */
14471 {
14473 {
14477 else
14479 }
14481 }
14483 /* All is well. */
14485 }
14487 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
14489 static tree
14491 {
14496 {
14499 else
14500 {
14503 }
14504 }
14506 /* Do warn about using typedefs to a deprecated class. */
14518 return type_is_deprecated
14522 }
14524 /* Returns an unavailable type used within TYPE, or NULL_TREE if none. */
14526 static tree
14528 {
14533 {
14536 else
14537 {
14540 }
14541 }
14543 /* Do warn about using typedefs to a deprecated class. */
14555 return type_is_unavailable
14559 }
14561 /* Decode the list of parameter types for a function type.
14562 Given the list of things declared inside the parens,
14563 return a list of types.
14565 If this parameter does not end with an ellipsis, we append
14566 void_list_node.
14568 *PARMS is set to the chain of PARM_DECLs created. */
14570 tree
14572 {
14575 tree parm;
14579 {
14588 {
14591 }
14595 {
14597 && !init
14600 /* DR 577: A parameter list consisting of a single
14601 unnamed parameter of non-dependent type 'void'. */
14605 "invalid use of cv-qualified type %qT in "
14607 else
14609 "invalid use of type %<void%> in parameter "
14611 /* It's not a good idea to actually create parameters of
14612 type `void'; other parts of the compiler assume that a
14613 void type terminates the parameter list. */
14616 }
14619 {
14621 {
14625 }
14628 {
14632 }
14634 /* [dcl.fct] "A parameter with volatile-qualified type is
14635 deprecated." */
14638 "%<volatile%>-qualified parameter is "
14641 /* Top-level qualifiers on the parameters are
14642 ignored for function types. */
14645 {
14649 }
14651 {
14652 /* Before C++17 DR 393:
14653 [dcl.fct]/6, parameter types cannot contain pointers
14654 (references) to arrays of unknown bound. */
14659 {
14667 }
14670 ptr
14676 }
14680 }
14685 }
14695 /* We had parm errors, recover by giving the function (...) type. */
14699 }
14701 \f
14702 /* D is a constructor or overloaded `operator='.
14704 Let T be the class in which D is declared. Then, this function
14705 returns:
14707 -1 if D's is an ill-formed constructor or copy assignment operator
14708 whose first parameter is of type `T'.
14709 0 if D is not a copy constructor or copy assignment
14710 operator.
14711 1 if D is a copy constructor or copy assignment operator whose
14712 first parameter is a reference to non-const qualified T.
14713 2 if D is a copy constructor or copy assignment operator whose
14714 first parameter is a reference to const qualified T.
14716 This function can be used as a predicate. Positive values indicate
14717 a copy constructor and nonzero values indicate a copy assignment
14718 operator. */
14720 int
14722 {
14723 tree args;
14724 tree arg_type;
14732 /* Instantiations of template member functions are never copy
14733 functions. Note that member functions of templated classes are
14734 represented as template functions internally, and we must
14735 accept those as copy functions. */
14751 {
14752 /* Pass by value copy assignment operator. */
14754 }
14758 {
14761 }
14762 else
14768 /* There are more non-optional args. */
14772 }
14774 /* D is a constructor or overloaded `operator='.
14776 Let T be the class in which D is declared. Then, this function
14777 returns true when D is a move constructor or move assignment
14778 operator, false otherwise. */
14780 bool
14782 {
14786 /* There are no move constructors if we are in C++98 mode. */
14792 /* Instantiations of template member functions are never move
14793 functions. Note that member functions of templated classes are
14794 represented as template functions internally, and we must
14795 accept those as move functions. */
14799 }
14801 /* D is a constructor or overloaded `operator='.
14803 Then, this function returns true when D has the same signature as a move
14804 constructor or move assignment operator (because either it is such a
14805 ctor/op= or it is a template specialization with the same signature),
14806 false otherwise. */
14808 bool
14810 {
14811 tree args;
14812 tree arg_type;
14836 /* There are more non-optional args. */
14840 }
14842 /* Remember any special properties of member function DECL. */
14844 void
14846 {
14847 tree class_type;
14855 {
14862 {
14863 /* [class.copy]
14865 A non-template constructor for class X is a copy
14866 constructor if its first parameter is of type X&, const
14867 X&, volatile X& or const volatile X&, and either there
14868 are no other parameters or else all other parameters have
14869 default arguments. */
14873 }
14884 }
14886 {
14887 /* [class.copy]
14889 A non-template assignment operator for class X is a copy
14890 assignment operator if its parameter is of type X, X&, const
14891 X&, volatile X& or const volatile X&. */
14896 {
14900 }
14901 }
14905 /* Destructors are handled in check_methods. */
14906 }
14908 /* Check a constructor DECL has the correct form. Complains
14909 if the class has a constructor of the form X(X). */
14911 bool
14913 {
14917 {
14918 /* [class.copy]
14920 A declaration of a constructor for a class X is ill-formed if
14921 its first parameter is of type (optionally cv-qualified) X
14922 and either there are no other parameters or else all other
14923 parameters have default arguments.
14925 We *don't* complain about member template instantiations that
14926 have this form, though; they can occur as we try to decide
14927 what constructor to use during overload resolution. Since
14928 overload resolution will never prefer such a constructor to
14929 the non-template copy constructor (which is either explicitly
14930 or implicitly defined), there's no need to worry about their
14931 existence. Theoretically, they should never even be
14932 instantiated, but that's hard to forestall. */
14937 }
14940 }
14942 /* DECL is a declaration for an overloaded or conversion operator. If
14943 COMPLAIN is true, errors are issued for invalid declarations. */
14945 bool
14947 {
14957 tree_code operator_code;
14960 {
14961 /* Conversion operators are TYPE_EXPR for the purposes of this
14962 function. */
14965 }
14966 else
14967 {
14974 }
14977 {
14978 /* operator new and operator delete are quite special. */
14981 {
15000 }
15002 /* [basic.std.dynamic.allocation]/1:
15004 A program is ill-formed if an allocation function is declared
15005 in a namespace scope other than global scope or declared
15006 static in global scope.
15008 The same also holds true for deallocation functions. */
15010 {
15012 {
15014 decl);
15016 }
15019 {
15022 }
15023 }
15026 {
15029 }
15030 else
15031 {
15034 }
15037 }
15039 /* An operator function must either be a non-static member function
15040 or have at least one parameter of a class, a reference to a class,
15041 an enumeration, or a reference to an enumeration. 13.4.0.6 */
15043 {
15049 {
15052 }
15055 {
15059 }
15062 {
15064 {
15069 }
15075 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
15076 because these checks are performed even on template
15077 functions. */
15081 }
15082 }
15085 /* There are no further restrictions on the arguments to an overloaded
15086 "operator ()". */
15090 {
15091 /* 13.4.0.3 */
15094 }
15096 /* Count the number of arguments and check for ellipsis. */
15099 {
15101 {
15102 /* Variadic. */
15104 decl);
15106 }
15108 }
15110 /* Verify correct number of arguments. */
15112 {
15115 {
15116 /* We have a unary instance of an ambi-ary op. Remap to the
15117 unary one. */
15123 }
15125 {
15126 /* This was an ambiguous operator but is invalid. */
15128 methodp
15132 }
15135 && ! processing_template_decl
15136 /* x++ and x--'s second argument must be an int. */
15138 integer_type_node))
15139 {
15141 methodp
15144 decl);
15146 }
15151 {
15153 methodp
15157 }
15162 {
15166 methodp
15170 }
15175 }
15177 /* There can be no default arguments. */
15180 {
15184 }
15186 /* At this point the declaration is well-formed. It may not be
15187 sensible though. */
15189 /* Check member function warnings only on the in-class declaration.
15190 There's no point warning on an out-of-class definition. */
15194 /* Warn about conversion operators that will never be used. */
15198 {
15209 {
15212 ref
15217 class_type);
15218 /* Don't force t to be complete here. */
15223 ref
15229 }
15230 }
15235 /* Effective C++ rules below. */
15237 /* More Effective C++ rule 7. */
15244 /* More Effective C++ rule 6. */
15249 {
15258 {
15263 }
15264 else
15265 {
15269 }
15270 }
15272 /* Effective C++ rule 23. */
15283 }
15284 \f
15285 /* Return a string giving the keyword associate with CODE. */
15289 {
15291 {
15304 }
15305 }
15307 /* Name lookup in an elaborated-type-specifier (after the keyword
15308 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
15309 elaborated-type-specifier is invalid, issue a diagnostic and return
15310 error_mark_node; otherwise, return the *_TYPE to which it referred.
15311 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
15313 tree
15315 tree decl,
15317 {
15318 tree type;
15320 /* In the case of:
15322 struct S { struct S *p; };
15324 name lookup will find the TYPE_DECL for the implicit "S::S"
15325 typedef. Adjust for that here. */
15331 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
15332 is false for this case as well. */
15334 {
15338 }
15339 /* Accept template template parameters. */
15343 ;
15344 /* [dcl.type.elab]
15346 If the identifier resolves to a typedef-name or the
15347 simple-template-id resolves to an alias template
15348 specialization, the elaborated-type-specifier is ill-formed.
15350 In other words, the only legitimate declaration to use in the
15351 elaborated type specifier is the implicit typedef created when
15352 the type is declared. */
15356 {
15360 else
15365 }
15370 {
15374 }
15377 {
15381 }
15385 {
15386 /* If a class template appears as elaborated type specifier
15387 without a template header such as:
15389 template <class T> class C {};
15390 void f(class C); // No template header here
15392 then the required template argument is missing. */
15397 }
15400 }
15402 /* Lookup NAME of an elaborated type specifier according to SCOPE and
15403 issue diagnostics if necessary. Return *_TYPE node upon success,
15404 NULL_TREE when the NAME is not found, and ERROR_MARK_NODE for type
15405 error. */
15407 static tree
15410 {
15411 tree decl;
15413 {
15414 /* First try ordinary name lookup, ignoring hidden class name
15415 injected via friend declaration. */
15418 /* If that fails, the name will be placed in the smallest
15419 non-class, non-function-prototype scope according to 3.3.1/5.
15420 We may already have a hidden name declared as friend in this
15421 scope. So lookup again but not ignoring hidden names.
15422 If we find one, that name will be made visible rather than
15423 creating a new tag. */
15426 }
15427 else
15431 /* We found nothing. */
15435 {
15439 }
15442 /* If scope is TAG_how::CURRENT_ONLY we're defining a class,
15443 so ignore a template template parameter. */
15448 /* Found not-a-type. */
15451 /* Look for invalid nested type:
15452 class C {
15453 class C {};
15454 }; */
15456 {
15460 }
15462 /* Two cases we need to consider when deciding if a class
15463 template is allowed as an elaborated type specifier:
15464 1. It is a self reference to its own class.
15465 2. It comes with a template header.
15467 For example:
15469 template <class T> class C {
15470 class C *c1; // DECL_SELF_REFERENCE_P is true
15471 class D;
15472 };
15473 template <class U> class C; // template_header_p is true
15474 template <class T> class C<T>::D {
15475 class C *c2; // DECL_SELF_REFERENCE_P is true
15476 }; */
15479 template_header_p
15484 {
15493 }
15496 }
15498 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
15499 Define the tag as a forward-reference if it is not defined.
15501 If a declaration is given, process it here, and report an error if
15502 multiple declarations are not identical.
15504 SCOPE is TS_CURRENT when this is also a definition. Only look in
15505 the current frame for the name (since C++ allows new names in any
15506 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
15507 declaration. Only look beginning from the current scope outward up
15508 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
15510 TEMPLATE_HEADER_P is true when this declaration is preceded by
15511 a set of template parameters. */
15513 tree
15516 {
15525 {
15538 }
15540 /* In case of anonymous name, xref_tag is only called to
15541 make type node and push name. Name lookup is not required. */
15552 {
15556 /* Since HOW is not TAG_how::CURRENT_ONLY, we are not looking at
15557 a definition of this tag. Since, in addition, we are
15558 currently processing a (member) template declaration of a
15559 template class, we must be very careful; consider:
15561 template <class X> struct S1
15563 template <class U> struct S2
15564 {
15565 template <class V> friend struct S1;
15566 };
15568 Here, the S2::S1 declaration should not be confused with the
15569 outer declaration. In particular, the inner version should
15570 have a template parameter of level 2, not level 1.
15572 On the other hand, when presented with:
15574 template <class T> struct S1
15575 {
15576 template <class U> struct S2 {};
15577 template <class U> friend struct S2;
15578 };
15580 the friend must find S1::S2 eventually. We accomplish this
15581 by making sure that the new type we create to represent this
15582 declaration has the right TYPE_CONTEXT. */
15585 }
15588 {
15589 /* If no such tag is yet defined, create a forward-reference node
15590 and record it as the "definition".
15591 When a real declaration of this type is found,
15592 the forward-reference will be altered into a real type. */
15594 {
15597 }
15602 /* Mark it as a lambda type right now. Our caller will
15603 correct the value. */
15606 }
15607 else
15608 {
15610 {
15611 /* Check that we aren't trying to overload a class with different
15612 constraints. */
15615 {
15618 }
15621 }
15625 {
15629 }
15633 {
15636 {
15640 }
15649 {
15650 /* Push it into this TU's symbol slot. */
15653 /* We're in the template parm binding level.
15654 Pushtag has logic to slide under that, but we're
15655 not pushing a *new* type. */
15661 }
15664 }
15665 }
15668 }
15670 /* Create the binfo hierarchy for REF with (possibly NULL) base list
15671 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
15672 access_* node, and the TREE_VALUE is the type of the base-class.
15673 Non-NULL TREE_TYPE indicates virtual inheritance. */
15675 void
15677 {
15684 tree default_access;
15690 /* The base of a derived class is private by default, all others are
15691 public. */
15696 /* First, make sure that any templates in base-classes are
15697 instantiated. This ensures that if we call ourselves recursively
15698 we do not get confused about which classes are marked and which
15699 are not. */
15702 {
15705 /* The dependent_type_p call below should really be dependent_scope_p
15706 so that we give a hard error about using an incomplete type as a
15707 base, but we allow it with a pedwarn for backward
15708 compatibility. */
15714 /* An incomplete type. Remove it from the list. */
15716 else
15717 {
15718 max_bases++;
15720 max_dvbases++;
15724 }
15725 }
15730 /* The binfo slot should be empty, unless this is an (ill-formed)
15731 redefinition. */
15742 /* Apply base-class info set up to the variants of this type. */
15746 {
15748 /* A C++98 POD cannot have base classes. */
15752 {
15755 }
15756 }
15763 {
15764 /* An aggregate can't have virtual base classes. */
15772 }
15775 {
15783 /* Before C++17, an aggregate cannot have base classes. In C++17, an
15784 aggregate can't have virtual, private, or protected base classes. */
15795 {
15797 basetype);
15799 }
15803 {
15805 /* The original basetype could have been a typedef'd type. */
15808 /* Inherit flags from the base. */
15819 }
15821 /* We must do this test after we've seen through a typedef
15822 type. */
15824 {
15827 else
15830 }
15833 /* Regenerate the pack expansion for the bases. */
15847 dropped_base:
15848 /* Update max_vbases to reflect the reality that we are dropping
15849 this base: if it reaches zero we want to undo the vec_alloc
15850 above to avoid inconsistencies during error-recovery: eg, in
15851 build_special_member_call, CLASSTYPE_VBASECLASSES non null
15852 and vtt null (c++/27952). */
15854 max_vbases--;
15856 max_vbases
15858 }
15865 /* If we didn't get max_vbases vbases, we must have shared at
15866 least one of them, and are therefore diamond shaped. */
15869 /* Unmark all the types. */
15874 /* Now see if we have a repeated base type. */
15876 {
15879 {
15881 {
15884 }
15886 }
15891 else
15893 }
15894 }
15896 \f
15897 /* Copies the enum-related properties from type SRC to type DST.
15898 Used with the underlying type of an enum and the enum itself. */
15899 static void
15901 {
15902 tree t;
15904 {
15914 else
15918 }
15919 }
15921 /* Begin compiling the definition of an enumeration type.
15922 NAME is its name,
15924 if ENUMTYPE is not NULL_TREE then the type has alredy been found.
15926 UNDERLYING_TYPE is the type that will be used as the storage for
15927 the enumeration type. This should be NULL_TREE if no storage type
15928 was specified.
15930 ATTRIBUTES are any attributes specified after the enum-key.
15932 SCOPED_ENUM_P is true if this is a scoped enumeration type.
15934 if IS_NEW is not NULL, gets TRUE iff a new type is created.
15936 Returns the type object, as yet incomplete.
15937 Also records info about it so that build_enumerator
15938 may be used to declare the individual values as they are read. */
15940 tree
15943 {
15949 /* [C++0x dcl.enum]p5:
15951 If not explicitly specified, the underlying type of a scoped
15952 enumeration type is int. */
15959 /* If this is the real definition for a previous forward reference,
15960 fill in the contents in the same object that used to be the
15961 forward reference. */
15967 /* In case of a template_decl, the only check that should be deferred
15968 to instantiation time is the comparison of underlying types. */
15970 {
15972 {
15978 }
15980 {
15986 }
15990 {
15996 }
15999 {
16001 {
16007 }
16009 }
16010 }
16014 {
16015 /* In case of error, make a dummy enum to allow parsing to
16016 continue. */
16018 {
16021 }
16023 /* enumtype may be an ENUMERAL_TYPE if this is a redefinition
16024 of an opaque enum, or an opaque enum of an already defined
16025 enumeration (C++11).
16026 In any other case, it'll be NULL_TREE. */
16028 {
16031 }
16034 /* Do not push the decl more than once. */
16037 {
16041 /* std::byte aliases anything. */
16046 }
16047 else
16053 /* The enum is considered opaque until the opening '{' of the
16054 enumerator list. */
16057 }
16064 {
16066 /* We already checked that it matches, don't change it to a different
16069 {
16072 }
16075 else
16078 }
16080 /* If into a template class, the returned enum is always the first
16081 declaration (opaque or not) seen. This way all the references to
16082 this type will be to the same declaration. The following ones are used
16083 only to check for definition errors. */
16086 else
16088 }
16090 /* After processing and defining all the values of an enumeration type,
16091 install their decls in the enumeration type.
16092 ENUMTYPE is the type object. */
16094 void
16096 {
16097 tree values;
16098 tree underlying_type;
16099 tree decl;
16100 tree value;
16102 tree t;
16104 bool fixed_underlying_type_p
16107 /* We built up the VALUES in reverse order. */
16110 /* For an enum defined in a template, just set the type of the values;
16111 all further processing is postponed until the template is
16112 instantiated. We need to set the type so that tsubst of a CONST_DECL
16113 works. */
16115 {
16117 values;
16121 }
16123 /* Determine the minimum and maximum values of the enumerators. */
16125 {
16129 values;
16131 {
16134 /* [dcl.enum]: Following the closing brace of an enum-specifier,
16135 each enumerator has the type of its enumeration. Prior to the
16136 closing brace, the type of each enumerator is the type of its
16137 initializing value. */
16140 /* Update the minimum and maximum values, if appropriate. */
16144 /* Figure out what the minimum and maximum values of the
16145 enumerators are. */
16152 }
16153 }
16154 else
16155 /* [dcl.enum]
16157 If the enumerator-list is empty, the underlying type is as if
16158 the enumeration had a single enumerator with value 0. */
16162 {
16163 /* Compute the number of bits require to represent all values of the
16164 enumeration. We must do this before the type of MINNODE and
16165 MAXNODE are transformed, since tree_int_cst_min_precision relies
16166 on the TREE_TYPE of the value it is passed. */
16174 /* Determine the underlying type of the enumeration.
16176 [dcl.enum]
16178 The underlying type of an enumeration is an integral type that
16179 can represent all the enumerator values defined in the
16180 enumeration. It is implementation-defined which integral type is
16181 used as the underlying type for an enumeration except that the
16182 underlying type shall not be larger than int unless the value of
16183 an enumerator cannot fit in an int or unsigned int.
16185 We use "int" or an "unsigned int" as the underlying type, even if
16186 a smaller integral type would work, unless the user has
16187 explicitly requested that we use the smallest possible type. The
16188 user can request that for all enumerations with a command line
16189 flag, or for just one enumeration with an attribute. */
16191 use_short_enum = flag_short_enums
16194 /* If the precision of the type was specified with an attribute and it
16195 was too small, give an error. Otherwise, use it. */
16197 {
16200 else
16201 {
16204 }
16205 }
16209 itk++)
16210 {
16216 }
16218 {
16219 /* DR 377
16221 IF no integral type can represent all the enumerator values, the
16222 enumeration is ill-formed. */
16227 }
16229 /* [dcl.enum]
16231 The value of sizeof() applied to an enumeration type, an object
16232 of an enumeration type, or an enumerator, is the value of sizeof()
16233 applied to the underlying type. */
16236 /* Compute the minimum and maximum values for the type.
16238 [dcl.enum]
16240 For an enumeration where emin is the smallest enumerator and emax
16241 is the largest, the values of the enumeration are the values of the
16242 underlying type in the range bmin to bmax, where bmin and bmax are,
16243 respectively, the smallest and largest values of the smallest bit-
16244 field that can store emin and emax. */
16246 /* The middle-end currently assumes that types with TYPE_PRECISION
16247 narrower than their underlying type are suitably zero or sign
16248 extended to fill their mode. Similarly, it assumes that the front
16249 end assures that a value of a particular type must be within
16250 TYPE_MIN_VALUE and TYPE_MAX_VALUE.
16252 We used to set these fields based on bmin and bmax, but that led
16253 to invalid assumptions like optimizing away bounds checking. So
16254 now we just set the TYPE_PRECISION, TYPE_MIN_VALUE, and
16255 TYPE_MAX_VALUE to the values for the mode above and only restrict
16256 the ENUM_UNDERLYING_TYPE for the benefit of diagnostics. */
16260 set_min_and_max_values_for_integral_type
16263 /* If -fstrict-enums, still constrain TYPE_MIN/MAX_VALUE. */
16266 }
16267 else
16270 /* If the enum is exported, mark the consts too. */
16275 /* Convert each of the enumerators to the type of the underlying
16276 type of the enumeration. */
16278 {
16282 /* If the enumeration type has a fixed underlying type, we
16283 already checked all of the enumerator values. */
16285 else
16288 tf_warning_or_error);
16289 /* Do not clobber shared ints. */
16291 {
16295 }
16299 }
16301 /* Fix up all variant types of this enum type. */
16308 {
16310 /* TYPE_FIELDS needs fixup. */
16312 }
16314 /* Finish debugging output for this type. */
16317 /* Each enumerator now has the type of its enumeration. Clear the cache
16318 so that this change in types doesn't confuse us later on. */
16320 }
16322 /* Finishes the enum type. This is called only the first time an
16323 enumeration is seen, be it opaque or odinary.
16324 ENUMTYPE is the type object. */
16326 void
16328 {
16330 {
16334 }
16336 /* If this is a forward declaration, there should not be any variants,
16337 though we can get a variant in the middle of an enum-specifier with
16338 wacky code like 'enum E { e = sizeof(const E*) };' */
16342 }
16344 /* Build and install a CONST_DECL for an enumeration constant of the
16345 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
16346 Apply ATTRIBUTES if available. LOC is the location of NAME.
16347 Assignment of sequential values by default is handled here. */
16349 void
16351 location_t loc)
16352 {
16353 tree decl;
16354 tree context;
16355 tree type;
16357 /* scalar_constant_value will pull out this expression, so make sure
16358 it's folded as appropriate. */
16362 /* If the VALUE was erroneous, pretend it wasn't there; that will
16363 result in the enum being assigned the next value in sequence. */
16367 /* Remove no-op casts from the value. */
16372 {
16373 /* Validate and default VALUE. */
16375 {
16377 {
16382 }
16385 value = perform_implicit_conversion_flags
16393 {
16396 {
16398 "enumerator value for %qD must have integral or "
16401 }
16402 else
16403 {
16407 {
16411 }
16412 }
16413 }
16414 }
16416 /* Default based on previous value. */
16418 {
16420 {
16421 tree prev_value;
16423 /* C++03 7.2/4: If no initializer is specified for the first
16424 enumerator, the type is an unspecified integral
16425 type. Otherwise the type is the same as the type of the
16426 initializing value of the preceding enumerator unless the
16427 incremented value is not representable in that type, in
16428 which case the type is an unspecified integral type
16429 sufficient to contain the incremented value. */
16433 else
16434 {
16441 {
16444 {
16447 {
16453 }
16460 }
16463 else
16465 }
16468 {
16471 }
16472 }
16473 }
16474 else
16476 }
16478 /* Remove no-op casts from the value. */
16481 /* If the underlying type of the enum is fixed, check whether
16482 the enumerator values fits in the underlying type. If it
16483 does not fit, the program is ill-formed [C++0x dcl.enum]. */
16485 && value
16487 {
16492 /* Convert the value to the appropriate type. */
16494 }
16495 }
16497 /* C++ associates enums with global, function, or class declarations. */
16500 /* Build the actual enumeration constant. Note that the enumeration
16501 constants have the underlying type of the enum (if it is fixed)
16502 or the type of their initializer (if the underlying type of the
16503 enum is not fixed):
16505 [ C++0x dcl.enum ]
16507 If the underlying type is fixed, the type of each enumerator
16508 prior to the closing brace is the underlying type; if the
16509 initializing value of an enumerator cannot be represented by
16510 the underlying type, the program is ill-formed. If the
16511 underlying type is not fixed, the type of each enumerator is
16512 the type of its initializing value.
16514 If the underlying type is not fixed, it will be computed by
16515 finish_enum and we will reset the type of this enumerator. Of
16516 course, if we're processing a template, there may be no value. */
16530 {
16531 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
16532 on the TYPE_FIELDS list for `S'. (That's so that you can say
16533 things like `S::i' later.) */
16535 /* The enumerator may be getting declared outside of its enclosing
16536 class, like so:
16538 class S { public: enum E : int; }; enum S::E : int { i = 7; };
16540 For which case we need to make sure that the access of `S::i'
16541 matches the access of `S::E'. */
16545 }
16546 else
16549 /* Add this enumeration constant to the list for this type. */
16551 }
16553 /* Look for an enumerator with the given NAME within the enumeration
16554 type ENUMTYPE. This routine is used primarily for qualified name
16555 lookup into an enumerator in C++0x, e.g.,
16557 enum class Color { Red, Green, Blue };
16559 Color color = Color::Red;
16561 Returns the value corresponding to the enumerator, or
16562 NULL_TREE if no such enumerator was found. */
16563 tree
16565 {
16566 tree e;
16571 }
16573 /* Implement LANG_HOOKS_SIMULATE_ENUM_DECL. */
16575 tree
16578 {
16585 {
16590 }
16604 }
16606 /* Implement LANG_HOOKS_SIMULATE_RECORD_DECL. */
16608 tree
16611 {
16618 {
16621 }
16640 }
16641 \f
16642 /* We're defining DECL. Make sure that its type is OK. */
16644 static void
16646 {
16650 /* In a function definition, arg types must be complete. */
16657 {
16662 /* Make it return void instead. */
16665 void_type_node,
16667 else
16669 fntype = (cp_build_type_attribute_variant
16673 }
16674 else
16675 {
16679 }
16680 }
16682 /* True iff FN is an implicitly-defined default constructor. */
16684 static bool
16686 {
16690 }
16692 /* Clobber the contents of *this to let the back end know that the object
16693 storage is dead when we enter the constructor or leave the destructor. */
16695 static tree
16697 {
16698 /* Clobbering an empty base is pointless, and harmful if its one byte
16699 TYPE_SIZE overlays real data. */
16703 /* If we have virtual bases, clobber the whole object, but only if we're in
16704 charge. If we don't have virtual bases, clobber the as-base type so we
16705 don't mess with tail padding. */
16716 {
16719 }
16726 }
16728 /* Create the FUNCTION_DECL for a function definition.
16729 DECLSPECS and DECLARATOR are the parts of the declaration;
16730 they describe the function's name and the type it returns,
16731 but twisted together in a fashion that parallels the syntax of C.
16733 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
16734 DECLARATOR is really the DECL for the function we are about to
16735 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
16736 indicating that the function is an inline defined in-class.
16738 This function creates a binding context for the function body
16739 as well as setting up the FUNCTION_DECL in current_function_decl.
16741 For C++, we must first check whether that datum makes any sense.
16742 For example, "class A local_a(1,2);" means that variable local_a
16743 is an aggregate of type A, which should have a constructor
16744 applied to it with the argument list [1, 2].
16746 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
16747 or may be a BLOCK if the function has been defined previously
16748 in this translation unit. On exit, DECL_INITIAL (decl1) will be
16749 error_mark_node if the function has never been defined, or
16750 a BLOCK if the function has been defined somewhere. */
16752 bool
16754 {
16758 /* Sanity check. */
16765 else
16766 {
16771 }
16778 /* Handle gnu_inline attribute. */
16780 {
16785 }
16788 /* This is a constructor, we must ensure that any default args
16789 introduced by this definition are propagated to the clones
16790 now. The clones are used directly in overload resolution. */
16793 /* Sometimes we don't notice that a function is a static member, and
16794 build a METHOD_TYPE for it. Fix that up now. */
16798 /* Set up current_class_type, and enter the scope of the class, if
16799 appropriate. */
16805 /* Now that we have entered the scope of the class, we must restore
16806 the bindings for any template parameters surrounding DECL1, if it
16807 is an inline member template. (Order is important; consider the
16808 case where a template parameter has the same name as a field of
16809 the class.) It is not until after this point that
16810 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
16814 /* Effective C++ rule 15. */
16822 /* Make the init_value nonzero so pushdecl knows this is not tentative.
16823 error_mark_node is replaced below (in poplevel) with the BLOCK. */
16827 /* This function exists in static storage.
16828 (This does not mean `static' in the C sense!) */
16831 /* We must call push_template_decl after current_class_type is set
16832 up. (If we are processing inline definitions after exiting a
16833 class scope, current_class_type will be NULL_TREE until set above
16834 by push_nested_class.) */
16836 {
16839 {
16843 }
16845 }
16847 /* Make sure the parameter and return types are reasonable. When
16848 you declare a function, these types can be incomplete, but they
16849 must be complete when you define the function. */
16852 /* Build the return declaration for the function. */
16856 {
16857 tree resdecl;
16865 }
16867 /* Record the decl so that the function name is defined.
16868 If we already have a decl for this name, and it is a FUNCTION_DECL,
16869 use the old decl. */
16871 {
16872 /* A specialization is not used to guide overload resolution. */
16876 {
16880 /* If something went wrong when registering the declaration,
16881 use DECL1; we have to have a FUNCTION_DECL to use when
16882 parsing the body of the function. */
16883 ;
16884 else
16885 {
16886 /* Otherwise, OLDDECL is either a previous declaration
16887 of the same function or DECL1 itself. */
16894 {
16895 tree context;
16897 /* Check whether DECL1 is in an anonymous
16898 namespace. */
16900 context;
16902 {
16906 }
16910 OPT_Wmissing_declarations,
16912 }
16915 }
16916 }
16917 else
16918 {
16919 /* We need to set the DECL_CONTEXT. */
16922 }
16926 /* If #pragma weak applies, mark the decl appropriately now.
16927 The pragma only applies to global functions. Because
16928 determining whether or not the #pragma applies involves
16929 computing the mangled name for the declaration, we cannot
16930 apply the pragma until after we have merged this declaration
16931 with any previous declarations; if the original declaration
16932 has a linkage specification, that specification applies to
16933 the definition as well, and may affect the mangled name. */
16936 }
16938 /* We are now in the scope of the function being defined. */
16941 /* Save the parm names or decls from this function's declarator
16942 where store_parm_decls will find them. */
16945 /* Let the user know we're compiling this function. */
16950 /* This function may already have been parsed, in which case just
16951 return; our caller will skip over the body without parsing. */
16955 /* Initialize RTL machinery. We cannot do this until
16956 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
16957 even when processing a template; this is how we get
16958 CFUN set up, and our per-function variables initialized.
16959 FIXME factor out the non-RTL stuff. */
16963 /* Initialize the language data structures. Whenever we start
16964 a new function, we destroy temporaries in the usual way. */
16969 /* If we are (erroneously) defining a function that we have already
16970 defined before, wipe out what we knew before. */
16976 {
16979 }
16981 /* Start the statement-tree, start the tree now. */
16985 {
16986 /* We know that this was set up by `grokclassfn'. We do not
16987 wait until `store_parm_decls', since evil parse errors may
16988 never get us to that point. Here we keep the consistency
16989 between `current_class_type' and `current_class_ptr'. */
16995 cp_function_chain->x_current_class_ref
16997 /* Set this second to avoid shortcut in cp_build_indirect_ref. */
17000 /* Constructors and destructors need to know whether they're "in
17001 charge" of initializing virtual base classes. */
17004 {
17007 }
17009 {
17012 }
17013 }
17016 /* Implicitly-defined methods (like the
17017 destructor for a class in which no destructor
17018 is explicitly declared) must not be defined
17019 until their definition is needed. So, we
17020 ignore interface specifications for
17021 compiler-generated functions. */
17029 {
17036 /* This is a function in a local class in an extern inline
17037 or template function. */
17039 }
17040 /* If this function belongs to an interface, it is public.
17041 If it belongs to someone else's interface, it is also external.
17042 This only affects inlines and template instantiations. */
17044 {
17047 {
17051 && ! flag_implement_inlines
17054 /* For WIN32 we also want to put these in linkonce sections. */
17056 }
17057 else
17060 /* If this function is in an interface implemented in this file,
17061 make sure that the back end knows to emit this function
17062 here. */
17065 }
17068 {
17069 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
17070 interface, we will have both finfo->interface_unknown and
17071 finfo->interface_only set. In that case, we don't want to
17072 use the normal heuristics because someone will supply a
17073 #pragma implementation elsewhere, and deducing it here would
17074 produce a conflict. */
17079 }
17080 else
17081 {
17082 /* This is a definition, not a reference.
17083 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
17091 else
17093 }
17095 /* Determine the ELF visibility attribute for the function. We must not
17096 do this before calling "pushdecl", as we must allow "duplicate_decls"
17097 to merge any attributes appropriately. We also need to wait until
17098 linkage is set. */
17112 {
17115 }
17127 /* Clobbering an empty base is harmful if it overlays real data. */
17129 /* We can't clobber safely for an implicitly-defined default constructor
17130 because part of the initialization might happen before we enter the
17131 constructor, via AGGR_INIT_ZERO_FIRST (c++/68006). */
17146 }
17149 /* Like start_preparsed_function, except that instead of a
17150 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
17152 Returns true on success. If the DECLARATOR is not suitable
17153 for a function, we return false, which tells the parser to
17154 skip the entire function. */
17156 bool
17159 tree attrs)
17160 {
17161 tree decl1;
17169 /* main must return int. grokfndecl should have corrected it
17170 (and issued a diagnostic) if the user got it wrong. */
17172 integer_type_node));
17175 }
17176 \f
17177 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
17178 FN. */
17180 static bool
17182 {
17184 && !processing_template_decl
17185 /* We insert the EH_SPEC_BLOCK only in the original
17186 function; then, it is copied automatically to the
17187 clones. */
17189 /* Implicitly-generated constructors and destructors have
17190 exception specifications. However, those specifications
17191 are the union of the possible exceptions specified by the
17192 constructors/destructors for bases and members, so no
17193 unallowed exception will ever reach this function. By
17194 not creating the EH_SPEC_BLOCK we save a little memory,
17195 and we avoid spurious warnings about unreachable
17196 code. */
17199 }
17201 /* Helper function to push ARGS into the current lexical scope. DECL
17202 is the function declaration. NONPARMS is used to handle enum
17203 constants. */
17205 void
17207 {
17208 /* If we're doing semantic analysis, then we'll call pushdecl
17209 for each of these. We must do them in reverse order so that
17210 they end in the correct forward order. */
17213 tree next;
17215 {
17220 {
17221 /* If we find an enum constant or a type tag, put it aside for
17222 the moment. */
17225 }
17226 }
17228 /* Get the decls in their original chain order and record in the
17229 function. This is all and only the PARM_DECLs that were
17230 pushed into scope by the loop above. */
17232 }
17234 /* Store the parameter declarations into the current function declaration.
17235 This is called after parsing the parameter declarations, before
17236 digesting the body of the function.
17238 Also install to binding contour return value identifier, if any. */
17240 static void
17242 {
17245 /* This is a chain of any other decls that came in among the parm
17246 declarations. If a parm is declared with enum {foo, bar} x;
17247 then CONST_DECLs for foo and bar are put here. */
17251 {
17252 /* This case is when the function was defined with an ANSI prototype.
17253 The parms already have decls, so we need not do anything here
17254 except record them as in effect
17255 and complain if any redundant old-style parm decls were written. */
17259 /* Must clear this because it might contain TYPE_DECLs declared
17260 at class level. */
17264 }
17265 else
17268 /* Now store the final chain of decls for the arguments
17269 as the decl-chain of the current lexical scope.
17270 Put the enumerators in as well, at the front so that
17271 DECL_ARGUMENTS is not modified. */
17276 }
17278 \f
17279 /* Set the return value of the constructor (if present). */
17281 static void
17283 {
17284 tree val;
17285 tree exprstmt;
17288 {
17289 /* Any return from a constructor will end up here. */
17295 /* Return the address of the object. */
17298 }
17299 }
17301 /* Do all the processing for the beginning of a destructor; set up the
17302 vtable pointers and cleanups for bases and members. */
17304 static void
17306 {
17307 tree compound_stmt;
17309 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
17310 issued an error message. We still want to try to process the
17311 body of the function, but initialize_vtbl_ptrs will crash if
17312 TYPE_BINFO is NULL. */
17314 {
17316 /* Make all virtual function table pointers in non-virtual base
17317 classes point to CURRENT_CLASS_TYPE's virtual function
17318 tables. */
17323 /* Clobbering an empty base is harmful if it overlays real data. */
17325 {
17329 {
17331 tree ref
17338 tf_warning_or_error);
17339 /* If the vptr is shared with some virtual nearly empty base,
17340 don't clear it if not in charge, the dtor of the virtual
17341 nearly empty base will do that later. */
17343 {
17346 {
17348 {
17350 tf_warning_or_error);
17353 }
17355 }
17356 }
17358 }
17359 else
17361 }
17363 /* And insert cleanups for our bases and members so that they
17364 will be properly destroyed if we throw. */
17366 }
17367 }
17369 /* At the end of every destructor we generate code to delete the object if
17370 necessary. Do that now. */
17372 static void
17374 {
17375 tree exprstmt;
17377 /* Any return from a destructor will end up here; that way all base
17378 and member cleanups will be run when the function returns. */
17382 {
17383 tree val;
17388 /* Return the address of the object. */
17391 }
17392 }
17394 /* Do the necessary processing for the beginning of a function body, which
17395 in this case includes member-initializers, but not the catch clauses of
17396 a function-try-block. Currently, this means opening a binding level
17397 for the member-initializers (in a ctor), member cleanups (in a dtor),
17398 and capture proxies (in a lambda operator()). */
17400 tree
17402 {
17408 else
17409 /* Always keep the BLOCK node associated with the outermost pair of
17410 curly braces of a function. These are needed for correct
17411 operation of dwarfout.c. */
17422 }
17424 /* Do the processing for the end of a function body. Currently, this means
17425 closing out the cleanups for fully-constructed bases and members, and in
17426 the case of the destructor, deleting the object if desired. Again, this
17427 is only meaningful for [cd]tors, since they are the only functions where
17428 there is a significant distinction between the main body and any
17429 function catch clauses. Handling, say, main() return semantics here
17430 would be wrong, as flowing off the end of a function catch clause for
17431 main() would also need to return 0. */
17433 void
17435 {
17439 /* Close the block. */
17448 }
17450 /* Given a function, returns the BLOCK corresponding to the outermost level
17451 of curly braces, skipping the artificial block created for constructor
17452 initializers. */
17454 tree
17456 {
17466 }
17468 /* If FNDECL is a class's key method, add the class to the list of
17469 keyed classes that should be emitted. */
17471 static void
17473 {
17477 {
17481 }
17482 }
17484 /* Attempt to add a fix-it hint to RICHLOC suggesting the insertion
17485 of "return *this;" immediately before its location, using FNDECL's
17486 first statement (if any) to give the indentation, if appropriate. */
17488 static void
17490 {
17497 indent);
17498 }
17500 /* This function carries out the subset of finish_function operations needed
17501 to emit the compiler-generated outlined helper functions used by the
17502 coroutines implementation. */
17504 static void
17506 {
17507 /* This is a partial set of the operations done by finish_function()
17508 plus emitting the result. */
17518 /* We must start each function with a clear fold cache. */
17523 /* This function has coroutine IFNs that we should handle in middle
17524 end lowering. */
17528 }
17530 /* Finish up a function declaration and compile that function
17531 all the way to assembler language output. The free the storage
17532 for the function definition. INLINE_P is TRUE if we just
17533 finished processing the body of an in-class inline function
17534 definition. (This processing will have taken place after the
17535 class definition is complete.) */
17537 tree
17539 {
17544 && !processing_template_decl
17548 /* When we get some parse errors, we can end up without a
17549 current_function_decl, so cope. */
17563 /* TREE_READONLY (fndecl) = 1;
17564 This caused &foo to be of type ptr-to-const-function
17565 which then got a warning when stored in a ptr-to-function variable. */
17568 /* The current function is being defined, so its DECL_INITIAL should
17569 be set, and unless there's a multiple definition, it should be
17570 error_mark_node. */
17574 {
17575 /* Only try to emit the coroutine outlined helper functions if the
17576 transforms succeeded. Otherwise, treat errors in the same way as
17577 a regular function. */
17580 /* We should handle coroutine IFNs in middle end lowering. */
17583 /* Do not try to process the ramp's EH unless outlining succeeded. */
17587 current_eh_spec_block);
17588 }
17589 else
17590 /* For a cloned function, we've already got all the code we need;
17591 there's no need to add any extra bits. */
17593 {
17594 /* Make it so that `main' always returns 0 by default. */
17601 current_eh_spec_block);
17602 }
17604 /* If we're saving up tree structure, tie off the function now. */
17609 /* If this function can't throw any exceptions, remember that. */
17612 && !flag_non_call_exceptions
17617 /* This must come after expand_function_end because cleanups might
17618 have declarations (from inline functions) that need to go into
17619 this function's blocks. */
17621 /* If the current binding level isn't the outermost binding level
17622 for this function, either there is a bug, or we have experienced
17623 syntax errors and the statement tree is malformed. */
17625 {
17626 /* Make sure we have already experienced errors. */
17629 /* Throw away the broken statement tree and extra binding
17630 levels. */
17634 {
17637 else
17639 }
17640 }
17643 /* Statements should always be full-expressions at the outermost set
17644 of curly braces for a function. */
17647 /* If there are no return statements in a function with auto return type,
17648 the return type is void. But if the declared type is something like
17649 auto*, this is an error. */
17652 {
17654 && !current_function_returns_value
17656 {
17657 /* We haven't applied return type deduction because we haven't
17658 seen any return statements. Do that now. */
17662 adc_return_type);
17666 }
17669 {
17674 }
17675 }
17677 /* Remember that we were in class scope. */
17682 {
17686 }
17688 // If this is a concept, check that the definition is reasonable.
17697 /* Complain if there's just no return statement. */
17704 /* Don't complain if we abort or throw. */
17705 && !current_function_returns_abnormally
17706 /* Don't complain if there's an infinite loop. */
17707 && !current_function_infinite_loop
17708 /* Don't complain if we are declared noreturn. */
17712 /* Structor return values (if any) are set by the compiler. */
17716 {
17718 /* Potentially add a "return *this;" fix-it hint for
17719 assignment operators. */
17721 {
17724 && current_class_ref
17725 && same_type_ignoring_top_level_qualifiers_p
17731 }
17737 "no return statement in function returning "
17740 }
17742 /* Lambda closure members are implicitly constexpr if possible. */
17746 = ((processing_template_decl
17750 /* Save constexpr function body before it gets munged by
17751 the NRV transformation. */
17754 /* Invoke the pre-genericize plugin before we start munging things. */
17758 /* Perform delayed folding before NRV transformation. */
17764 /* Set up the named return value optimization, if we can. Candidate
17765 variables are selected in check_return_expr. */
17767 {
17769 tree outer;
17772 /* This is only worth doing for fns that return in memory--and
17773 simpler, since we don't have to worry about promoted modes. */
17775 /* Only allow this for variables declared in the outer scope of
17776 the function so we know that their lifetime always ends with a
17777 return; see g++.dg/opt/nrv6.C. We could be more flexible if
17778 we were to do this optimization in tree-ssa. */
17784 }
17786 /* Must mark the RESULT_DECL as being in this function. */
17789 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
17790 to the FUNCTION_DECL node itself. */
17793 /* Store the end of the function, so that we get good line number
17794 info for the epilogue. */
17797 /* Complain about parameters that are only set, but never otherwise used. */
17799 && !processing_template_decl
17802 {
17803 tree decl;
17806 decl;
17820 OPT_Wunused_but_set_parameter,
17823 }
17825 /* Complain about locally defined typedefs that are not used in this
17826 function. */
17829 /* Possibly warn about unused parameters. */
17831 && !processing_template_decl
17835 /* Genericize before inlining. */
17841 /* Emit the resumer and destroyer functions now, providing that we have
17842 not encountered some fatal error. */
17844 {
17847 }
17849 cleanup:
17850 /* We're leaving the context of this function, so zap cfun. It's still in
17851 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
17855 /* If this is an in-class inline definition, we may have to pop the
17856 bindings for the template parameters that we added in
17857 maybe_begin_member_template_processing when start_function was
17858 called. */
17862 /* Leave the scope of the class. */
17868 /* Clean up. */
17873 }
17874 \f
17875 /* Create the FUNCTION_DECL for a function definition.
17876 DECLSPECS and DECLARATOR are the parts of the declaration;
17877 they describe the return type and the name of the function,
17878 but twisted together in a fashion that parallels the syntax of C.
17880 This function creates a binding context for the function body
17881 as well as setting up the FUNCTION_DECL in current_function_decl.
17883 Returns a FUNCTION_DECL on success.
17885 If the DECLARATOR is not suitable for a function (it defines a datum
17886 instead), we return 0, which tells yyparse to report a parse error.
17888 May return void_type_node indicating that this method is actually
17889 a friend. See grokfield for more details.
17891 Came here with a `.pushlevel' .
17893 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
17894 CHANGES TO CODE IN `grokfield'. */
17896 tree
17899 {
17909 /* Pass friends other than inline friend functions back. */
17914 {
17919 }
17923 /* p1779 ABI-Isolation makes inline not a default for in-class
17924 definitions in named module purview. If the user explicitly
17925 made it inline, grokdeclarator will already have done the right
17926 things. */
17928 || flag_module_implicit_inline
17929 /* Lambda's operator function remains inline. */
17931 /* If the user explicitly asked for this to be inline, we don't
17932 need to do more, but more importantly we want to warn if we
17933 can't inline it. */
17935 {
17939 /* It's ok if we can't inline this. */
17941 }
17943 /* We process method specializations in finish_struct_1. */
17945 {
17946 /* Avoid calling decl_spec_seq... until we have to. */
17951 }
17954 {
17957 }
17963 }
17964 \f
17966 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
17967 we can lay it out later, when and if its type becomes complete.
17969 Also handle constexpr variables where the initializer involves
17970 an unlowered PTRMEM_CST because the class isn't complete yet. */
17972 void
17974 {
17977 /* Keep track of variables with incomplete types. */
17980 {
17988 /* RTTI TD entries are created while defining the type_info. */
17991 {
17994 }
17998 {
17999 /* When the outermost open class is complete we can resolve any
18000 pointers-to-members. */
18004 }
18005 }
18006 }
18008 /* Called when a class type (given by TYPE) is defined. If there are
18009 any existing VAR_DECLs whose type has been completed by this
18010 declaration, update them now. */
18012 void
18014 {
18019 {
18021 {
18028 {
18029 /* Complete the type of the variable. */
18034 }
18036 /* Remove this entry from the list. */
18038 }
18039 else
18040 ix++;
18041 }
18042 }
18044 /* If DECL is of a type which needs a cleanup, build and return an
18045 expression to perform that cleanup here. Return NULL_TREE if no
18046 cleanup need be done. DECL can also be a _REF when called from
18047 split_nonconstant_init_1. */
18049 tree
18051 {
18052 tree type;
18053 tree attr;
18054 tree cleanup;
18056 /* Assume no cleanup is required. */
18062 /* Handle "__attribute__((cleanup))". We run the cleanup function
18063 before the destructor since the destructor is what actually
18064 terminates the lifetime of the object. */
18067 else
18070 {
18071 tree id;
18072 tree fn;
18073 tree arg;
18075 /* Get the name specified by the user for the cleanup function. */
18077 /* Look up the name to find the cleanup function to call. It is
18078 important to use lookup_name here because that is what is
18079 used in c-common.c:handle_cleanup_attribute when performing
18080 initial checks on the attribute. Note that those checks
18081 include ensuring that the function found is not an overloaded
18082 function, or an object with an overloaded call operator,
18083 etc.; we can rely on the fact that the function found is an
18084 ordinary FUNCTION_DECL. */
18092 }
18093 /* Handle ordinary C++ destructors. */
18096 {
18098 tree addr;
18099 tree call;
18103 else
18117 else
18119 }
18121 /* build_delete sets the location of the destructor call to the
18122 current location, even though the destructor is going to be
18123 called later, at the end of the current scope. This can lead to
18124 a "jumpy" behavior for users of debuggers when they step around
18125 the end of the block. So let's unset the location of the
18126 destructor call instead. */
18134 /* Treat objects with destructors as used; the destructor may do
18135 something substantive. */
18144 }
18146 \f
18147 /* Return the FUNCTION_TYPE that corresponds to MEMFNTYPE, which can be a
18148 FUNCTION_DECL, METHOD_TYPE, FUNCTION_TYPE, pointer or reference to
18149 METHOD_TYPE or FUNCTION_TYPE, or pointer to member function. */
18151 tree
18153 {
18154 tree fntype;
18155 tree args;
18168 fntype = (cp_build_type_attribute_variant
18172 }
18174 /* DECL was originally constructed as a non-static member function,
18175 but turned out to be static. Update it accordingly. */
18177 void
18179 {
18192 }
18194 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
18195 one of the language-independent trees. */
18197 enum cp_tree_node_structure_enum
18199 {
18201 {
18219 }
18220 }
18222 /* Build the void_list_node (void_type_node having been created). */
18223 tree
18225 {
18228 }
18230 bool
18232 {
18233 /* A missing noreturn is ok for the `main' function. */
18235 }
18237 /* Return the decl used to identify the COMDAT group into which DECL should
18238 be placed. */
18240 tree
18242 {
18243 /* Virtual tables, construction virtual tables, and virtual table
18244 tables all go in a single COMDAT group, named after the primary
18245 virtual table. */
18248 /* For all other DECLs, the COMDAT group is the mangled name of the
18249 declaration itself. */
18250 else
18251 {
18253 {
18254 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
18255 into the same section as the target function. In that case
18256 we must return target's name. */
18262 else
18264 }
18265 }
18268 }
18270 /* Returns the return type for FN as written by the user, which may include
18271 a placeholder for a deduced return type. */
18273 tree
18275 {
18281 }
18283 /* Returns true iff DECL is a variable or function declared with an auto type
18284 that has not yet been deduced to a real type. */
18286 bool
18288 {
18295 }
18297 /* Complain if DECL has an undeduced return type. */
18299 bool
18301 {
18303 {
18310 }
18312 }
18314 /* Create a representation of the explicit-specifier with
18315 constant-expression of EXPR. COMPLAIN is as for tsubst. */
18317 tree
18319 {
18324 /* Wait for instantiation, tsubst_function_decl will handle it. */
18331 }