| blob | 6b686d75a49f9d368ec70a735b3ed5143faa3bfa |
1 /* Process declarations and variables for -*- C++ -*- compiler.
2 Copyright (C) 1988-2024 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
10 any later version.
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
22 /* Process declarations and symbol lookup for C++ front end.
23 Also constructs types; the standard scalar types at initialization,
24 and structure, union, array and enum types when they are declared. */
26 /* ??? not all decl nodes are given the most useful possible
27 line numbers. For example, the CONST_DECLs for enum values. */
30 #define INCLUDE_MEMORY
64 /* Possible cases of bad specifiers type used by bad_specifiers. */
69 BSP_FIELD /* field */
70 };
100 static tree check_special_function_return_type
111 /* The following symbols are subsumed in the cp_global_trees array, and
112 listed here individually for documentation purposes.
114 C++ extensions
115 tree wchar_decl_node;
117 tree vtable_entry_type;
118 tree delta_type_node;
119 tree __t_desc_type_node;
121 tree class_type_node;
122 tree unknown_type_node;
124 Array type `vtable_entry_type[]'
126 tree vtbl_type_node;
127 tree vtbl_ptr_type_node;
129 Namespaces,
131 tree std_node;
132 tree abi_node;
134 A FUNCTION_DECL which can call `abort'. Not necessarily the
135 one that the user will declare, but sufficient to be called
136 by routines that want to abort the program.
138 tree abort_fndecl;
140 Used by RTTI
141 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
142 tree tinfo_var_id; */
146 /* A list of objects which have constructors or destructors
147 which reside in namespace scope. The decl is stored in
148 the TREE_VALUE slot and the initializer is stored
149 in the TREE_PURPOSE slot. */
150 tree static_aggregates;
152 /* Like static_aggregates, but for thread_local variables. */
153 tree tls_aggregates;
155 /* A hash-map mapping from variable decls to the dynamic initializer for
156 the decl. This is currently only used by OpenMP. */
159 /* -- end of C++ */
161 /* A node for the integer constant 2. */
163 tree integer_two_node;
165 /* vector of static decls. */
168 /* vector of keyed classes. */
171 /* Used only for jumps to as-yet undefined labels, since jumps to
172 defined labels can have their validity checked immediately. */
176 /* The binding level to which this entry is *currently* attached.
177 This is initially the binding level in which the goto appeared,
178 but is modified as scopes are closed. */
180 /* The head of the names list that was current when the goto appeared,
181 or the inner scope popped. These are the decls that will *not* be
182 skipped when jumping to the label. */
183 tree names_in_scope;
184 /* If the use is a possible destination of a computed goto, a vec of decls
185 that aren't destroyed, filled in by poplevel_named_label_1. */
187 /* The location of the goto, for error reporting. */
188 location_t o_goto_locus;
189 /* True if an OpenMP structured block scope has been closed since
190 the goto appeared. This means that the branch from the label will
191 illegally exit an OpenMP scope. */
193 };
195 /* A list of all LABEL_DECLs in the function that have names. Here so
196 we can clear out their names' definitions at the end of the
197 function, and so we can check the validity of jumps to these labels. */
207 /* The binding level to which the label is *currently* attached.
208 This is initially set to the binding level in which the label
209 is defined, but is modified as scopes are closed. */
212 /* The head of the names list that was current when the label was
213 defined, or the inner scope popped. These are the decls that will
214 be skipped when jumping to the label. */
215 tree names_in_scope;
217 /* A vector of all decls from all binding levels that would be
218 crossed by a backward branch to the label. */
221 /* A list of uses of the label, before the label is defined. */
224 /* True if we've seen &&label. Appalently we can't use TREE_ADDRESSABLE for
225 this, it has a more specific meaning for LABEL_DECL. */
228 /* The following bits are set after the label is defined, and are
229 updated as scopes are popped. They indicate that a jump to the
230 label will illegally enter a scope of the given flavor. */
238 };
240 #define named_labels cp_function_chain->x_named_labels
241 \f
242 /* The number of function bodies which we are currently processing.
243 (Zero if we are at namespace scope, one inside the body of a
244 function, two inside the body of a function in a local class, etc.) */
247 /* Whether the exception-specifier is part of a function type (i.e. C++17). */
250 /* States indicating how grokdeclarator() should handle declspecs marked
251 with __attribute__((deprecated)). An object declared as
252 __attribute__((deprecated)) suppresses warnings of uses of other
253 deprecated items. */
256 \f
257 /* A list of VAR_DECLs whose type was incomplete at the time the
258 variable was declared. */
261 tree decl;
262 tree incomplete_type;
263 };
267 \f
268 /* Returns the kind of template specialization we are currently
269 processing, given that it's declaration contained N_CLASS_SCOPES
270 explicit scope qualifications. */
272 tmpl_spec_kind
274 {
280 /* Scan through the template parameter scopes. */
284 {
285 /* If we see a specialization scope inside a parameter scope,
286 then something is wrong. That corresponds to a declaration
287 like:
289 template <class T> template <> ...
291 which is always invalid since [temp.expl.spec] forbids the
292 specialization of a class member template if the enclosing
293 class templates are not explicitly specialized as well. */
295 {
298 else
300 }
305 }
307 /* Handle explicit instantiations. */
309 {
311 /* We've seen a template parameter list during an explicit
312 instantiation. For example:
314 template <class T> template void f(int);
316 This is erroneous. */
318 else
320 }
323 /* We've not seen enough template headers to match all the
324 specialized classes present. For example:
326 template <class T> void R<T>::S<T>::f(int);
328 This is invalid; there needs to be one set of template
329 parameters for each class. */
332 /* We're processing a non-template declaration (even though it may
333 be a member of a template class.) For example:
335 template <class T> void S<T>::f(int);
337 The `class T' matches the `S<T>', leaving no template headers
338 corresponding to the `f'. */
341 /* We've got too many template headers. For example:
343 template <> template <class T> void f (T);
345 There need to be more enclosing classes. */
347 else
348 /* This must be a template. It's of the form:
350 template <class T> template <class U> void S<T>::f(U);
352 This is a specialization if the innermost level was a
353 specialization; otherwise it's just a definition of the
354 template. */
356 }
358 /* Exit the current scope. */
360 void
362 {
364 }
366 /* When a label goes out of scope, check to see if that label was used
367 in a valid manner, and issue any appropriate warnings or errors. */
369 static void
371 {
373 {
375 {
376 location_t location;
380 /* FIXME want (LOCATION_FILE (input_location), (line)0) */
381 /* Avoid crashing later. */
383 }
384 else
386 }
387 }
389 /* Helper function to sort named label entries in a vector by DECL_UID. */
391 static int
393 {
397 /* DECL_UIDs can never be equal. */
399 }
401 /* At the end of a function, all labels declared within the function
402 go out of scope. BLOCK is the top-level block for the
403 function. */
405 static void
407 {
411 /* We need to add the labels to the block chain, so debug
412 information is emitted. But, we want the order to be stable so
413 need to sort them first. Otherwise the debug output could be
414 randomly ordered. I guess it's mostly stable, unless the hash
415 table implementation changes. */
420 {
427 }
432 {
439 }
440 }
442 /* At the end of a block with local labels, restore the outer definition. */
444 static void
446 {
454 else
455 {
458 }
460 }
462 /* The following two routines are used to interface to Objective-C++.
463 The binding level is purposely treated as an opaque type. */
467 {
469 }
471 /* The following routine is used by the NeXT-style SJLJ exceptions;
472 variables get marked 'volatile' so as to not be clobbered by
473 _setjmp()/_longjmp() calls. All variables in the current scope,
474 as well as parent scopes up to (but not including) ENCLOSING_BLK
475 shall be thusly marked. */
477 void
479 {
485 {
486 tree decl;
491 /* Do not climb up past the current function. */
494 }
495 }
497 /* True if B is the level for the condition of a constexpr if. */
499 static bool
501 {
505 }
507 /* True if B is the level for the condition of a consteval if. */
509 static bool
511 {
515 }
517 /* True if T is a non-static VAR_DECL that has a non-trivial destructor.
518 See [stmt.dcl]/2. */
520 static bool
522 {
529 }
531 /* Update data for defined and undefined labels when leaving a scope. */
533 int
535 {
540 {
541 tree decl;
543 /* ENT->NAMES_IN_SCOPE may contain a mixture of DECLs and
544 TREE_LISTs representing OVERLOADs, so be careful. */
554 {
578 }
579 }
581 {
586 {
588 {
594 }
600 }
601 }
604 }
606 /* Saved errorcount to avoid -Wunused-but-set-{parameter,variable} warnings
607 when errors were reported, except for -Werror-unused-but-set-*. */
610 /* Exit a binding level.
611 Pop the level off, and restore the state of the identifier-decl mappings
612 that were in effect when this level was entered.
614 If KEEP == 1, this level had explicit declarations, so
615 and create a "block" (a BLOCK node) for the level
616 to record its declarations and subblocks for symbol table output.
618 If FUNCTIONBODY is nonzero, this level is the body of a function,
619 so create a block as if KEEP were set and also clear out all
620 label names.
622 If REVERSE is nonzero, reverse the order of decls before putting
623 them into the BLOCK. */
625 tree
627 {
628 tree link;
629 /* The chain of decls was accumulated in reverse order.
630 Put it into forward order, just for cleanliness. */
631 tree decls;
632 tree subblocks;
633 tree block;
634 tree decl;
635 scope_kind kind;
638 restart:
651 /* We used to use KEEP == 2 to indicate that the new block should go
652 at the beginning of the list of blocks at this binding level,
653 rather than the end. This hack is no longer used. */
659 /* Any uses of undefined labels, and any defined labels, now operate
660 under constraints of next binding contour. */
665 /* Get the decls in the order they were written.
666 Usually current_binding_level->names is in reverse order.
667 But parameter decls were previously put in forward order. */
671 {
674 }
676 /* If there were any declarations or structure tags in that level,
677 or if this level is a function body,
678 create a BLOCK to record them for the life of this function. */
680 /* Avoid function body block if possible. */
686 {
689 }
691 /* In each subblock, record that this is its superior. */
696 /* Before we remove the declarations first check for unused variables. */
701 {
702 /* There are cases where D itself is a TREE_LIST. See in
703 push_local_binding where the list of decls returned by
704 getdecls is built. */
712 /* For structured bindings, consider only real variables, not
713 subobjects. */
716 /* Don't warn about name-independent declarations. */
723 {
725 {
728 OPT_Wunused_variable,
732 OPT_Wunused_variable,
734 else
738 }
740 // For -Wunused-but-set-variable leave references alone.
743 {
748 else
750 OPT_Wunused_but_set_variable,
753 }
754 }
755 }
757 /* Remove declarations for all the DECLs in this level. */
759 {
760 tree name;
762 {
766 }
767 else
768 {
771 }
773 /* Remove the binding. */
776 else
778 }
780 /* Restore the IDENTIFIER_TYPE_VALUEs. */
785 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
786 list if a `using' declaration put them there. The debugging
787 back ends won't understand OVERLOAD, so we remove them here.
788 Because the BLOCK_VARS are (temporarily) shared with
789 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
790 popped all the bindings. Also remove undeduced 'auto' decls,
791 which LTO doesn't understand, and can't have been used by anything. */
793 {
797 {
799 || (!processing_template_decl
802 else
804 }
805 }
807 /* If the level being exited is the top level of a function,
808 check over all the labels. */
810 {
812 {
813 /* Since this is the top level block of a function, the vars are
814 the function's parameters. Don't leave them in the BLOCK
815 because they are found in the FUNCTION_DECL instead. */
818 }
819 else
821 }
825 {
826 tree stmt;
828 /* If this is a temporary binding created for a cleanup, then we'll
829 have pushed a statement list level. Pop that, create a new
830 BIND_EXPR for the block, and insert it into the stream. */
834 }
838 {
839 /* The current function is being defined, so its DECL_INITIAL
840 should be error_mark_node. */
844 {
846 {
849 }
850 else
852 }
853 }
855 current_binding_level->blocks
858 /* If we did not make a block for the level just exited,
859 any blocks made for inner levels
860 (since they cannot be recorded as subblocks in that level)
861 must be carried forward so they will later become subblocks
862 of something else. */
864 current_binding_level->blocks
867 /* Each and every BLOCK node created here in `poplevel' is important
868 (e.g. for proper debugging information) so if we created one
869 earlier, mark it as "used". */
873 /* All temporary bindings created for cleanups are popped silently. */
878 }
880 /* Call wrapup_globals_declarations for the globals in NAMESPACE. */
881 /* Diagnose odr-used extern inline variables without definitions
882 in the current TU. */
884 int
886 {
888 {
890 {
900 OPT_Wunused_function,
909 }
911 /* Clear out the list, so we don't rescan next time. */
914 /* Write out any globals that need to be output. */
917 }
919 }
920 \f
921 /* In C++, you don't have to write `struct S' to refer to `S'; you
922 can just use `S'. We accomplish this by creating a TYPE_DECL as
923 if the user had written `typedef struct S S'. Create and return
924 the TYPE_DECL for TYPE. */
926 tree
928 {
929 tree decl;
933 /* There are other implicit type declarations, like the one *within*
934 a class that allows you to write `S::S'. We must distinguish
935 amongst these. */
941 }
943 /* Function-scope local entities that need discriminators. Each entry
944 is a {decl,name} pair. VAR_DECLs for anon unions get their name
945 smashed, so we cannot rely on DECL_NAME. */
949 /* Determine the mangling discriminator of local DECL. There are
950 generally very few of these in any particular function. */
952 void
954 {
964 {
972 {
978 /* Replace the saved decl. */
982 }
983 }
986 {
990 }
991 }
993 \f
994 /* True if DECL is a constrained hidden friend as per [temp.friend]/9:
996 A non-template friend declaration with a requires-clause shall be a
997 definition. A friend function template with a constraint that depends on a
998 template parameter from an enclosing template shall be a definition. Such a
999 constrained friend function or function template declaration does not
1000 declare the same function or function template as a declaration in any other
1001 scope.
1003 The ABI calls this a "member-like constrained friend" and mangles it like a
1004 member function to avoid collisions. */
1006 bool
1008 {
1015 || (uses_outer_template_parms_in_constraints
1017 }
1019 /* Returns true if functions FN1 and FN2 have equivalent trailing
1020 requires clauses. */
1022 static bool
1024 {
1025 /* [temp.friend]/9 "Such a constrained friend function does not declare the
1026 same function as a declaration in any other scope." So no need to
1027 actually compare the requirements. */
1032 /* Compare only trailing requirements. */
1038 /* Substitution is needed when friends are involved. */
1043 }
1045 /* Two functions of the same name correspond [basic.scope.scope] if
1047 + both declare functions with the same non-object-parameter-type-list,
1048 equivalent ([temp.over.link]) trailing requires-clauses (if any, except as
1049 specified in [temp.friend]), and, if both are non-static members, they have
1050 corresponding object parameters, or
1052 + both declare function templates with equivalent
1053 non-object-parameter-type-lists, return types (if any), template-heads, and
1054 trailing requires-clauses (if any), and, if both are non-static members,
1055 they have corresponding object parameters.
1057 This is a subset of decls_match: it identifies declarations that cannot be
1058 overloaded with one another. This function does not consider DECL_NAME. */
1060 bool
1062 {
1067 {
1072 }
1080 /* If only one is a non-static member function, ignore ref-quals. */
1083 /* Two non-static member functions have corresponding object parameters if:
1084 + exactly one is an implicit object member function with no ref-qualifier
1085 and the types of their object parameters ([dcl.fct]), after removing
1086 top-level references, are the same, or
1087 + their object parameters have the same type. */
1088 /* ??? We treat member functions of different classes as corresponding even
1089 though that means the object parameters have different types. */
1096 {
1100 }
1102 /* Two function declarations match if either has a requires-clause
1103 then both have a requires-clause and their constraints-expressions
1104 are equivalent. */
1109 }
1111 /* Subroutine of duplicate_decls: return truthvalue of whether
1112 or not types of these decls match.
1114 For C++, we must compare the parameter list so that `int' can match
1115 `int&' in a parameter position, but `int&' is not confused with
1116 `const int&'. */
1118 int
1120 {
1127 /* If the two DECLs are not even the same kind of thing, we're not
1128 interested in their types. */
1134 {
1135 /* Specializations of different templates are different functions
1136 even if they have the same type. */
1151 /* A new declaration doesn't match a built-in one unless it
1152 is also extern "C". */
1162 /* A declaration with deduced return type should use its pre-deduction
1163 type for declaration matching. */
1167 /* For memchr et al, allow const void* return type (as specified by C++)
1168 when we expect void* (as in C). */
1181 {
1184 {
1188 }
1189 else
1190 types_match =
1196 }
1197 else
1200 /* Two function declarations match if either has a requires-clause
1201 then both have a requires-clause and their constraints-expressions
1202 are equivalent. */
1206 /* The decls dont match if they correspond to two different versions
1207 of the same function. Disallow extern "C" functions to be
1208 versions for now. */
1213 {
1219 }
1220 }
1222 {
1232 /* Two template types match if they are the same. Otherwise, compare
1233 the underlying declarations. */
1236 else
1238 }
1239 else
1240 {
1241 /* Need to check scope for variable declaration (VAR_DECL).
1242 For typedef (TYPE_DECL), scope is ignored. */
1245 /* [dcl.link]
1246 Two declarations for an object with C language linkage
1247 with the same name (ignoring the namespace that qualify
1248 it) that appear in different namespace scopes refer to
1249 the same object. */
1259 else
1262 COMPARE_REDECLARATION);
1263 }
1266 }
1268 /* Mark DECL as versioned if it isn't already. */
1270 static void
1272 {
1274 {
1276 /* If DECL_ASSEMBLER_NAME has already been set, re-mangle
1277 to include the version marker. */
1280 }
1281 }
1283 /* NEWDECL and OLDDECL have identical signatures. If they are
1284 different versions adjust them and return true.
1285 If RECORD is set to true, record function versions. */
1287 bool
1289 {
1295 {
1298 }
1302 {
1303 /* Unfortunately, we can get here before pushdecl naturally calls
1304 push_local_extern_decl_alias, so we need to call it directly. */
1309 }
1315 }
1317 /* If NEWDECL is `static' and an `extern' was seen previously,
1318 warn about it. OLDDECL is the previous declaration.
1320 Note that this does not apply to the C++ case of declaring
1321 a variable `extern const' and then later `const'.
1323 Don't complain about built-in functions, since they are beyond
1324 the user's control. */
1326 void
1328 {
1335 /* Don't get confused by static member functions; that's a different
1336 use of `static'. */
1341 /* If the old declaration was `static', or the new one isn't, then
1342 everything is OK. */
1346 /* It's OK to declare a builtin function as `static'. */
1351 auto_diagnostic_group d;
1356 }
1358 /* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1359 function templates. If their exception specifications do not
1360 match, issue a diagnostic. */
1362 static void
1364 tree old_decl)
1365 {
1369 /* Two default specs are equivalent, don't force evaluation. */
1375 {
1378 }
1382 /* [except.spec]
1384 If any declaration of a function has an exception-specification,
1385 all declarations, including the definition and an explicit
1386 specialization, of that function shall have an
1387 exception-specification with the same set of type-ids. */
1391 {
1396 auto_diagnostic_group d;
1400 /* We used to silently permit mismatched eh specs with
1401 -fno-exceptions, so make them a pedwarn now. */
1403 else
1408 }
1409 }
1411 /* Return true if OLD_DECL and NEW_DECL agree on constexprness.
1412 Otherwise issue diagnostics. */
1414 static bool
1416 {
1424 {
1430 }
1432 {
1433 /* With -fimplicit-constexpr, ignore changes in the constexpr
1434 keyword. */
1440 {
1441 /* Hide a built-in declaration. */
1447 }
1448 /* 7.1.5 [dcl.constexpr]
1449 Note: An explicit specialization can differ from the template
1450 declaration with respect to the constexpr specifier. */
1460 "redeclaration %qD differs in %qs "
1462 kind);
1466 }
1468 }
1470 // If OLDDECL and NEWDECL are concept declarations with the same type
1471 // (i.e., and template parameters), but different requirements,
1472 // emit diagnostics and return true. Otherwise, return false.
1475 {
1487 {
1492 {
1495 }
1496 }
1498 }
1500 /* DECL is a redeclaration of a function or function template. If
1501 it does have default arguments issue a diagnostic. Note: this
1502 function is used to enforce the requirements in C++11 8.3.6 about
1503 no default arguments in redeclarations. */
1505 static void
1507 {
1513 {
1515 "redeclaration of %q#D may not have default "
1518 }
1519 }
1521 /* NEWDECL is a redeclaration of a function or function template OLDDECL,
1522 in any case represented as FUNCTION_DECLs (the DECL_TEMPLATE_RESULTs of
1523 the TEMPLATE_DECLs in case of function templates). This function is used
1524 to enforce the final part of C++17 11.3.6/4, about a single declaration:
1525 "If a friend declaration specifies a default argument expression, that
1526 declaration shall be a definition and shall be the only declaration of
1527 the function or function template in the translation unit." */
1529 static void
1531 {
1541 {
1542 auto_diagnostic_group d;
1544 "friend declaration of %q#D specifies default "
1549 }
1550 }
1552 /* Merge tree bits that correspond to attributes noreturn, nothrow,
1553 const, malloc, and pure from NEWDECL with those of OLDDECL. */
1555 static void
1557 {
1574 }
1576 #define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn) \
1578 DECL_ATTRIBUTES (fn)))
1580 /* A subroutine of duplicate_decls. Emits a diagnostic when newdecl
1581 ambiguates olddecl. Returns true if an error occurs. */
1583 static bool
1585 {
1588 /* Function template declarations can be differentiated by parameter
1589 and return type. */
1594 {
1595 /* ... and also by their template-heads and requires-clauses. */
1598 {
1603 }
1605 /* FIXME: The types are the same but the are differences
1606 in either the template heads or function requirements.
1607 We should be able to diagnose a set of common errors
1608 stemming from these declarations. For example:
1610 template<typename T> requires C void f(...);
1611 template<typename T> void f(...) requires C;
1613 These are functionally equivalent but not equivalent. */
1614 }
1617 }
1619 /* OLD_PARMS is the innermost set of template parameters for some template
1620 declaration, and NEW_PARMS is the corresponding set of template parameters
1621 for a redeclaration of that template. Merge the default arguments within
1622 these two sets of parameters. CLASS_P is true iff the template in
1623 question is a class template. */
1625 bool
1627 {
1631 {
1639 {
1640 auto_diagnostic_group d;
1645 }
1647 /* Update the previous template parameters (which are the ones
1648 that will really count) with the new default value. */
1651 /* Update the new parameters, too; they'll be used as the
1652 parameters for any members. */
1654 }
1656 }
1658 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1659 If the redeclaration is invalid, a diagnostic is issued, and the
1660 error_mark_node is returned. Otherwise, OLDDECL is returned.
1662 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1663 returned.
1665 HIDING is true if the new decl is being hidden. WAS_HIDDEN is true
1666 if the old decl was hidden.
1668 Hidden decls can be anticipated builtins, injected friends, or
1669 (coming soon) injected from a local-extern decl. */
1671 tree
1673 {
1677 tree new_template_info;
1686 /* If either the type of the new decl or the type of the old decl is an
1687 error_mark_node, then that implies that we have already issued an
1688 error (earlier) for some bogus type specification, and in that case,
1689 it is rather pointless to harass the user with yet more error message
1690 about the same declaration, so just pretend the types match here. */
1695 /* Check for redeclaration and other discrepancies. */
1698 {
1700 {
1701 /* Avoid warnings redeclaring built-ins which have not been
1702 explicitly declared. */
1704 {
1708 OPT_Wbuiltin_declaration_mismatch,
1710 newdecl);
1712 }
1714 /* If you declare a built-in or predefined function name as static,
1715 the old definition is overridden, but optionally warn this was a
1716 bad choice of name. */
1718 {
1720 OPT_Wshadow,
1724 /* Discard the old built-in function. */
1726 }
1727 /* If the built-in is not ansi, then programs can override
1728 it even globally without an error. */
1733 else
1735 "declaration of %q#D conflicts with built-in "
1738 }
1740 {
1741 /* Avoid warnings redeclaring built-ins which have not been
1742 explicitly declared. */
1744 {
1747 /* A new declaration doesn't match a built-in one unless it
1748 is also extern "C". */
1758 {
1761 /* FILE, tm types are not known at the time
1762 we create the builtins. */
1768 {
1775 {
1785 }
1787 }
1791 next_arg:;
1792 }
1795 OPT_Wbuiltin_declaration_mismatch,
1796 "declaration of %q#D conflicts with built-in "
1798 }
1803 {
1804 /* Don't really override olddecl for __* prefixed builtins
1805 except for __[^b]*_chk, the compiler might be using those
1806 explicitly. */
1808 {
1819 {
1821 {
1823 "definition of %q#D ambiguates built-in "
1826 }
1827 auto_diagnostic_group d;
1829 "new declaration %q#D ambiguates built-in"
1835 }
1836 }
1838 /* A near match; override the builtin. */
1842 OPT_Wbuiltin_declaration_mismatch,
1843 "new declaration %q#D ambiguates built-in "
1845 else
1850 }
1851 else
1852 /* Discard the old built-in function. */
1855 /* Replace the old RTL to avoid problems with inlining. */
1857 }
1858 else
1859 {
1860 /* Even if the types match, prefer the new declarations type
1861 for built-ins which have not been explicitly declared,
1862 for exception lists, etc... */
1869 }
1871 /* If a function is explicitly declared "throw ()", propagate that to
1872 the corresponding builtin. */
1874 && was_hidden
1877 {
1882 }
1884 /* Whether or not the builtin can throw exceptions has no
1885 bearing on this declarator. */
1889 {
1890 /* If a builtin function is redeclared as `static', merge
1891 the declarations, but make the original one static. */
1895 /* Make the old declaration consistent with the new one so
1896 that all remnants of the builtin-ness of this function
1897 will be banished. */
1900 }
1901 }
1903 {
1904 /* C++ Standard, 3.3, clause 4:
1905 "[Note: a namespace name or a class template name must be unique
1906 in its declarative region (7.3.2, clause 14). ]" */
1927 {
1928 /* One is a function and the other is a template
1929 function. */
1933 /* There can only be one! */
1937 "literal operator %q#D conflicts with"
1941 "raw literal operator %q#D conflicts with"
1943 else
1948 }
1953 /* One is an implicit typedef, that's ok. */
1960 }
1962 {
1964 /* These are certainly not duplicate declarations; they're
1965 from different scopes. */
1969 {
1973 /* The name of a class template may not be declared to refer to
1974 any other template, class, function, object, namespace, value,
1975 or type in the same scope. */
1978 {
1984 }
1988 {
1992 }
1996 }
1998 {
2000 {
2003 newdecl);
2007 }
2008 /* For function versions, params and types match, but they
2009 are not ambiguous. */
2012 /* Let constrained hidden friends coexist for now, we'll
2013 check satisfaction later. */
2016 // The functions have the same parameter types.
2019 // And the same constraints.
2021 {
2027 }
2028 else
2030 }
2031 else
2032 {
2037 }
2038 }
2041 {
2042 /* OMP UDRs are never duplicates. */
2049 }
2059 /* It's OK to have a template specialization and a non-template
2060 with the same type, or to have specializations of two
2061 different templates with the same type. Note that if one is a
2062 specialization, and the other is an instantiation of the same
2063 template, that we do not exit at this point. That situation
2064 can occur if we instantiate a template class, and then
2065 specialize one of its methods. This situation is valid, but
2066 the declarations must be merged in the usual way. */
2073 /* One of the declarations is a template instantiation, and the
2074 other is not a template at all. That's OK. */
2077 {
2078 /* In [namespace.alias] we have:
2080 In a declarative region, a namespace-alias-definition can be
2081 used to redefine a namespace-alias declared in that declarative
2082 region to refer only to the namespace to which it already
2083 refers.
2085 Therefore, if we encounter a second alias directive for the same
2086 alias, we can just ignore the second directive. */
2092 /* Leave it to update_binding to merge or report error. */
2094 }
2095 else
2096 {
2099 {
2100 auto_diagnostic_group d;
2111 {
2116 {
2119 "structured binding at namespace scope is not "
2123 "static structured binding is not "
2127 "extern structured binding is not "
2129 }
2144 }
2146 }
2151 {
2152 /* Prototype decl follows defn w/o prototype. */
2153 auto_diagnostic_group d;
2158 }
2161 {
2162 /* [dcl.link]
2163 If two declarations of the same function or object
2164 specify different linkage-specifications ..., the program
2165 is ill-formed.... Except for functions with C++ linkage,
2166 a function declaration without a linkage specification
2167 shall not precede the first linkage specification for
2168 that function. A function can be declared without a
2169 linkage specification after an explicit linkage
2170 specification has been seen; the linkage explicitly
2171 specified in the earlier declaration is not affected by
2172 such a function declaration.
2174 DR 563 raises the question why the restrictions on
2175 functions should not also apply to objects. Older
2176 versions of G++ silently ignore the linkage-specification
2177 for this example:
2179 namespace N {
2180 extern int i;
2181 extern "C" int i;
2182 }
2184 which is clearly wrong. Therefore, we now treat objects
2185 like functions. */
2187 {
2188 /* There is no explicit linkage-specification, so we use
2189 the linkage from the previous declaration. */
2192 }
2193 else
2194 {
2195 auto_diagnostic_group d;
2202 }
2203 }
2206 ;
2208 {
2209 /* Note: free functions, as TEMPLATE_DECLs, are handled below. */
2212 as FUNCTION_DECLs. */
2214 /* C++11 8.3.6/6.
2215 Default arguments for a member function of a class
2216 template shall be specified on the initial declaration
2217 of the member function within the class template. */
2219 {
2224 {
2228 tree old_parms
2232 }
2233 }
2234 else
2235 {
2243 {
2246 {
2247 auto_diagnostic_group d;
2249 "default argument given for parameter "
2253 olddecl);
2254 }
2255 else
2256 {
2257 auto_diagnostic_group d;
2259 "default argument given for parameter %d "
2263 olddecl);
2264 }
2265 }
2267 /* C++17 11.3.6/4: "If a friend declaration specifies a default
2268 argument expression, that declaration... shall be the only
2269 declaration of the function or function template in the
2270 translation unit." */
2272 }
2273 }
2274 }
2276 /* Do not merge an implicit typedef with an explicit one. In:
2278 class A;
2279 ...
2280 typedef class A A __attribute__ ((foo));
2282 the attribute should apply only to the typedef. */
2297 {
2302 {
2303 /* The old declaration should match the exportingness of the new
2304 declaration. But hidden friend declarations just keep the
2305 exportingness of the old declaration; see CWG2588. */
2309 /* Typedefs are not entities and so are OK to be redeclared
2310 as exported: see [module.interface]/p6. */
2312 {
2315 {
2316 auto_diagnostic_group d;
2320 }
2321 }
2324 }
2325 }
2327 /* We have committed to returning OLDDECL at this point. */
2329 /* If new decl is `static' and an `extern' was seen previously,
2330 warn about it. */
2333 /* True to merge attributes between the declarations, false to
2334 set OLDDECL's attributes to those of NEWDECL (for template
2335 explicit specializations that specify their own attributes
2336 independent of those specified for the primary template). */
2342 {
2344 {
2350 /* [dcl.attr.noreturn]: The first declaration of a function shall
2351 specify the noreturn attribute if any declaration of that function
2352 specifies the noreturn attribute. */
2353 tree a;
2356 /* This applies to [[noreturn]] only, not its GNU variants. */
2360 {
2364 }
2365 }
2367 /* Now that functions must hold information normally held
2368 by field decls, there is extra work to do so that
2369 declaration information does not get destroyed during
2370 definition. */
2392 /* Optionally warn about more than one declaration for the same
2393 name, but don't warn about a function declaration followed by a
2394 definition. */
2397 /* Don't warn about extern decl followed by definition. */
2399 /* Don't warn if at least one is/was hidden. */
2401 /* Don't warn about declaration followed by specialization. */
2404 {
2405 auto_diagnostic_group d;
2407 OPT_Wredundant_decls,
2409 newdecl))
2412 }
2414 /* [dcl.fct.def.delete] A deleted definition of a function shall be the
2415 first declaration of the function or, for an explicit specialization
2416 of a function template, the first declaration of that
2417 specialization. */
2420 {
2422 {
2423 auto_diagnostic_group d;
2428 }
2434 }
2435 }
2437 /* Deal with C++: must preserve virtual function table size. */
2439 {
2449 }
2451 /* Copy all the DECL_... slots specified in the new decl except for
2452 any that we copy here from the old type. */
2456 else
2460 {
2465 /* The new decl should not already have gathered any
2466 specializations. */
2469 /* Make sure the contracts are equivalent. */
2472 /* Remove contracts from old_result so they aren't appended to
2473 old_result by the merge function. */
2480 {
2483 {
2484 /* Per C++11 8.3.6/4, default arguments cannot be added in
2485 later declarations of a function template. */
2487 /* C++17 11.3.6/4: "If a friend declaration specifies a default
2488 argument expression, that declaration... shall be the only
2489 declaration of the function or function template in the
2490 translation unit." */
2491 check_no_redeclaration_friend_default_args
2498 }
2506 {
2509 else
2520 }
2521 else
2522 {
2530 }
2531 }
2533 /* If the new declaration is a definition, update the file and
2534 line information on the declaration, and also make
2535 the old declaration the same definition. */
2537 {
2543 {
2550 }
2551 }
2554 }
2557 {
2561 /* Automatically handles default parameters. */
2563 tree newtype;
2565 /* For typedefs use the old type, as the new type's DECL_NAME points
2566 at newdecl, which will be ggc_freed. */
2568 {
2569 /* But NEWTYPE might have an attribute, honor that. */
2574 {
2578 }
2580 /* And remove the new type from the variants list. */
2582 {
2585 {
2587 /* If remove is the main variant, no need to remove that
2588 from the list. One of the DECL_ORIGINAL_TYPE
2589 variants, e.g. created for aligned attribute, might still
2590 refer to the newdecl TYPE_DECL though, so remove that one
2591 in that case. */
2597 {
2601 }
2602 }
2603 else
2607 {
2610 }
2611 }
2612 }
2615 else
2619 {
2621 /* For already initialized vars, TREE_READONLY could have been
2622 cleared in cp_finish_decl, because the var needs runtime
2623 initialization or destruction. Make sure not to set
2624 TREE_READONLY on it again. */
2641 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
2644 {
2645 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
2648 }
2649 }
2651 /* An explicit specialization of a function template or of a member
2652 function of a class template can be declared transaction_safe
2653 independently of whether the corresponding template entity is declared
2654 transaction_safe. */
2667 /* Lay the type out, unless already done. */
2681 /* Merge deprecatedness. */
2685 /* Merge unavailability. */
2689 /* Preserve function specific target and optimization options */
2691 {
2704 }
2705 else
2706 {
2707 /* Merge the const type qualifier. */
2710 /* Merge the volatile type qualifier. */
2713 }
2715 /* Merge the initialization information. */
2718 {
2722 {
2725 }
2726 }
2729 {
2742 else
2743 {
2744 /* Merge the noreturn bit. */
2750 }
2751 /* Keep the old RTL. */
2753 }
2756 {
2757 /* Keep the old RTL. We cannot keep the old RTL if the old
2758 declaration was for an incomplete object and the new
2759 declaration is not since many attributes of the RTL will
2760 change. */
2762 }
2763 }
2764 /* If cannot merge, then use the new type and qualifiers,
2765 and don't preserve the old rtl. */
2766 else
2767 {
2768 /* Clean out any memory we had of the old declaration. */
2778 }
2780 /* Merge the storage class information. */
2792 {
2794 /* This can happen if olddecl was brought in from the
2795 enclosing namespace via a using-decl. The new decl is
2796 then not a block-scope extern at all. */
2798 else
2799 {
2804 {
2809 }
2810 }
2811 }
2815 {
2827 {
2831 }
2834 {
2839 /* If the OLDDECL is an instantiation and/or specialization,
2840 then the NEWDECL must be too. But, it may not yet be marked
2841 as such if the caller has created NEWDECL, but has not yet
2842 figured out that it is a redeclaration. */
2849 }
2851 /* Don't really know how much of the language-specific
2852 values we should copy from old to new. */
2856 {
2859 {
2863 /* Remember the presence of explicit specialization args. */
2866 }
2868 /* We don't want to copy template info from a non-templated friend
2869 (PR105761), but these shouldn't have DECL_TEMPLATE_INFO now. */
2873 }
2876 {
2877 /* Only functions have these fields. */
2882 /* DECL_THUNKS is only valid for virtual functions,
2883 otherwise it is a DECL_FRIEND_CONTEXT. */
2888 }
2890 {
2891 /* Only variables have this field. */
2894 }
2895 }
2898 {
2899 tree parm;
2901 /* Merge parameter attributes. */
2906 {
2910 }
2914 {
2915 /* If newdecl is not a specialization, then it is not a
2916 template-related function at all. And that means that we
2917 should have exited above, returning 0. */
2921 /* From [temp.expl.spec]:
2923 If a template, a member template or the member of a class
2924 template is explicitly specialized then that
2925 specialization shall be declared before the first use of
2926 that specialization that would cause an implicit
2927 instantiation to take place, in every translation unit in
2928 which such a use occurs. */
2930 olddecl);
2936 /* Don't propagate visibility from the template to the
2937 specialization here. We'll do that in determine_visibility if
2938 appropriate. */
2941 /* [temp.expl.spec/14] We don't inline explicit specialization
2942 just because the primary template says so. */
2952 }
2954 {
2955 /* Never inline re-defined extern inline functions.
2956 FIXME: this could be better handled by keeping both
2957 function as separate declarations. */
2959 }
2960 else
2961 {
2963 {
2967 }
2969 ;
2983 }
2985 /* Preserve abstractness on cloned [cd]tors. */
2988 /* Update newdecl's parms to point at olddecl. */
2994 {
2998 }
3000 {
3001 /* These are the final DECL_ARGUMENTS that will be used within the
3002 body; update any references to old DECL_ARGUMENTS in the
3003 contracts, if present. */
3007 /* These need to be copied so that the names are available.
3008 Note that if the types do match, we'll preserve inline
3009 info and other bits, but if not, we won't. */
3013 /* In some cases, duplicate_contracts will remove contracts from
3014 OLDDECL, to avoid duplications. Sometimes, the contracts end up
3015 shared. If we removed them, re-add them. */
3018 }
3019 /* If redeclaring a builtin function, it stays built in
3020 if newdecl is a gnu_inline definition, or if newdecl is just
3021 a declaration. */
3024 {
3026 /* If we're keeping the built-in definition, keep the rtl,
3027 regardless of declaration matches. */
3030 {
3033 {
3034 /* A compatible prototype of these builtin functions
3035 is seen, assume the runtime implements it with
3036 the expected semantics. */
3038 {
3045 }
3046 }
3049 }
3050 }
3052 /* If defining a function declared with other language
3053 linkage, use the previously declared language linkage. */
3056 {
3058 /* Don't clear out the arguments if we're just redeclaring a
3059 function. */
3061 {
3062 /* If we removed contracts from previous definition, re-attach
3063 them. Otherwise, rewrite the contracts so they match the
3064 parameters of the new declaration. */
3069 else
3070 {
3071 /* Temporarily undo the re-contexting of parameters so we can
3072 actually remap parameters. The inliner won't replace
3073 parameters if we don't do this. */
3078 /* Save new argument names for use in contracts parsing,
3079 unless we've already started parsing the body of olddecl
3080 (particular issues arise when newdecl is from a prior
3081 friend decl with no argument names, see
3082 modules/contracts-tpl-friend-1). */
3086 /* And reverse this operation again. */
3089 }
3092 }
3093 }
3094 }
3098 /* Now preserve various other info from the definition. */
3104 /* Warn about conflicting visibility specifications. */
3108 {
3109 auto_diagnostic_group d;
3111 "%qD: visibility attribute ignored because it "
3115 }
3116 /* Choose the declaration which specified visibility. */
3118 {
3121 }
3122 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
3123 so keep this behavior. */
3125 {
3128 }
3129 /* Likewise for DECL_ALIGN, DECL_USER_ALIGN and DECL_PACKED. */
3131 {
3134 }
3147 /* Merge module entity mapping information. */
3151 {
3155 }
3157 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
3158 with that from NEWDECL below. */
3160 {
3164 }
3166 /* Merge the USED information. */
3173 {
3178 }
3185 /* Merge the DECL_FUNCTION_VERSIONED information. newdecl will be copied
3186 to olddecl and deleted. */
3189 {
3190 /* Set the flag for newdecl so that it gets copied to olddecl. */
3192 /* newdecl will be purged after copying to olddecl and is no longer
3193 a version. */
3195 }
3198 {
3212 /* Preserve symtab node mapping. */
3216 /* If newdecl is a template instantiation, it is possible that
3217 the following sequence of events has occurred:
3219 o A friend function was declared in a class template. The
3220 class template was instantiated.
3222 o The instantiation of the friend declaration was
3223 recorded on the instantiation list, and is newdecl.
3225 o Later, however, instantiate_class_template called pushdecl
3226 on the newdecl to perform name injection. But, pushdecl in
3227 turn called duplicate_decls when it discovered that another
3228 declaration of a global function with the same name already
3229 existed.
3231 o Here, in duplicate_decls, we decided to clobber newdecl.
3233 If we're going to do that, we'd better make sure that
3234 olddecl, and not newdecl, is on the list of
3235 instantiations so that if we try to do the instantiation
3236 again we won't get the clobbered declaration. */
3238 new_template_info,
3239 olddecl);
3240 }
3241 else
3242 {
3250 {
3258 {
3271 }
3279 }
3280 }
3283 {
3287 {
3288 /* Merge the section attribute.
3289 We want to issue an error if the sections conflict but that must be
3290 done later in decl_attributes since we are called before attributes
3291 are assigned. */
3296 {
3300 else
3304 }
3305 }
3309 {
3313 }
3314 }
3318 /* NEWDECL contains the merged attribute lists.
3319 Update OLDDECL to be the same. */
3322 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
3323 so that encode_section_info has a chance to look at the new decl
3324 flags and attributes. */
3331 /* The NEWDECL will no longer be needed. Because every out-of-class
3332 declaration of a member results in a call to duplicate_decls,
3333 freeing these nodes represents in a significant savings.
3335 Before releasing the node, be sore to remove function from symbol
3336 table that might have been inserted there to record comdat group.
3337 Be sure to however do not free DECL_STRUCT_FUNCTION because this
3338 structure is shared in between newdecl and oldecl. */
3342 {
3346 }
3349 {
3350 tree clone;
3352 {
3355 }
3356 }
3358 /* Remove the associated constraints for newdecl, if any, before
3359 reclaiming memory. */
3363 /* And similarly for any module tracking data. */
3370 }
3371 \f
3372 /* Return zero if the declaration NEWDECL is valid
3373 when the declaration OLDDECL (assumed to be for the same name)
3374 has already been seen.
3375 Otherwise return an error message format string with a %s
3376 where the identifier should go. */
3380 {
3382 {
3383 /* Because C++ can put things into name space for free,
3384 constructs like "typedef struct foo { ... } foo"
3385 would look like an erroneous redeclaration. */
3388 else
3390 }
3392 {
3393 /* If this is a pure function, its olddecl will actually be
3394 the original initialization to `0' (which we force to call
3395 abort()). Don't complain about redefinition in this case. */
3400 /* If both functions come from different namespaces, this is not
3401 a redeclaration - this is a conflict with a used function. */
3407 /* We'll complain about linkage mismatches in
3408 warn_extern_redeclared_static. */
3410 /* Defining the same name twice is no good. */
3413 {
3419 }
3422 {
3427 {
3431 else
3434 }
3435 }
3437 /* [class.compare.default]: A definition of a comparison operator as
3438 defaulted that appears in a class shall be the first declaration of
3439 that function. */
3445 check_abi_tag_redeclaration
3450 }
3452 {
3476 {
3481 {
3485 else
3488 }
3489 }
3491 /* Core issue #226 (C++11):
3493 If a friend function template declaration specifies a
3494 default template-argument, that declaration shall be a
3495 definition and shall be the only declaration of the
3496 function template in the translation unit. */
3507 }
3514 {
3515 /* Only variables can be thread-local, and all declarations must
3516 agree on this property. */
3520 else
3523 }
3525 {
3526 /* The objects have been declared at namespace scope. If either
3527 is a member of an anonymous union, then this is an invalid
3528 redeclaration. For example:
3530 int i;
3531 union { int i; };
3533 is invalid. */
3537 /* If at least one declaration is a reference, there is no
3538 conflict. For example:
3540 int i = 3;
3541 extern int i;
3543 is valid. */
3547 /* Static data member declared outside a class definition
3548 if the variable is defined within the class with constexpr
3549 specifier is declaration rather than definition (and
3550 deprecated). */
3556 {
3558 /* For now, only warn with explicit -Wdeprecated. */
3560 {
3561 auto_diagnostic_group d;
3563 "redundant redeclaration of %<constexpr%> "
3567 }
3569 }
3571 /* Reject two definitions. */
3573 }
3574 else
3575 {
3576 /* Objects declared with block scope: */
3577 /* Reject two definitions, and reject a definition
3578 together with an external reference. */
3582 }
3583 }
3584 \f
3586 /* Hash and equality functions for the named_label table. */
3588 hashval_t
3590 {
3592 }
3594 bool
3596 {
3598 }
3600 /* Look for a label named ID in the current function. If one cannot
3601 be found, create one. Return the named_label_entry, or NULL on
3602 failure. */
3606 {
3609 /* You can't use labels at global scope. */
3611 {
3614 }
3620 named_label_entry **slot
3625 {
3630 {
3634 }
3635 }
3637 /* We are making a new decl, create or reuse the named_label_entry */
3641 else
3642 {
3647 }
3649 /* Now create the LABEL_DECL. */
3655 {
3659 }
3664 }
3666 /* Wrapper for lookup_label_1. */
3668 tree
3670 {
3673 }
3675 /* Remember that we've seen &&ID. */
3677 void
3679 {
3682 }
3684 tree
3686 {
3689 }
3691 /* Returns true if it is ill-formed to jump past the declaration of DECL. */
3693 static bool
3695 {
3696 /* [stmt.dcl]/3: A program that jumps from a point where a local variable
3697 with automatic storage duration is not in scope to a point where it is
3698 in scope is ill-formed unless the variable has scalar type, class type
3699 with a trivial default constructor and a trivial destructor, a
3700 cv-qualified version of one of these types, or an array of one of the
3701 preceding types and is declared without an initializer (8.5). */
3709 }
3711 /* A subroutine of check_previous_goto_1 and check_goto to identify a branch
3712 to the user. */
3714 static bool
3717 {
3720 bool complained
3725 {
3728 else
3730 }
3732 }
3734 /* Check that a single previously seen jump to a newly defined label
3735 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
3736 the jump context; NAMES are the names in scope in LEVEL at the jump
3737 context; LOCUS is the source position of the jump or 0. COMPUTED
3738 is a vec of decls if the jump is a computed goto. Returns
3739 true if all is well. */
3741 static bool
3745 {
3753 {
3755 computed);
3760 }
3763 {
3769 {
3775 {
3777 computed);
3779 }
3783 }
3791 {
3824 {
3828 }
3830 {
3834 }
3839 }
3842 {
3845 computed);
3849 }
3850 }
3853 {
3856 computed);
3860 {
3865 }
3866 }
3869 }
3871 static void
3873 {
3877 }
3879 static bool
3881 {
3884 }
3886 /* Check that a new jump to a label ENT is OK. COMPUTED is true
3887 if this is a possible target of a computed goto. */
3889 void
3891 {
3894 /* If the label hasn't been defined yet, defer checking. */
3896 {
3897 /* Don't bother creating another use if the last goto had the
3898 same data, and will therefore create the same set of errors. */
3903 named_label_use_entry *new_use
3914 }
3918 tree bad;
3925 {
3934 }
3937 {
3941 {
3942 /* Can't skip init of __exception_info. */
3944 {
3948 }
3952 }
3956 }
3959 {
3972 }
3975 {
3978 }
3981 {
3985 {
3987 {
3991 computed);
3993 }
3997 }
3998 }
4000 /* Warn if a computed goto might involve a local variable going out of scope
4001 without being cleaned up. */
4003 {
4007 {
4009 {
4011 {
4012 complained
4016 }
4020 }
4023 {
4025 {
4027 {
4028 complained
4032 }
4036 }
4037 }
4040 }
4041 }
4042 }
4044 /* Check that a new jump to a label DECL is OK. Called by
4045 finish_goto_stmt. */
4047 void
4049 {
4053 {
4054 /* We don't know where a computed goto is jumping,
4055 so check all addressable labels. */
4059 {
4063 }
4064 }
4065 else
4066 {
4068 named_label_entry **slot
4072 }
4073 }
4075 /* Check that a return is ok wrt OpenMP structured blocks.
4076 Called by finish_return_stmt. Returns true if all is well. */
4078 bool
4080 {
4083 {
4086 }
4090 }
4092 /* Define a label, specifying the location in the source file.
4093 Return the LABEL_DECL node for the label. */
4095 tree
4097 {
4100 /* After labels, make any new cleanups in the function go into their
4101 own new (temporary) binding contour. */
4111 {
4114 }
4115 else
4116 {
4117 /* Mark label as having been defined. */
4119 /* Say where in the source. */
4128 }
4131 }
4133 struct cp_switch
4134 {
4137 /* The SWITCH_STMT being built. */
4138 tree switch_stmt;
4139 /* A splay-tree mapping the low element of a case range to the high
4140 element, or NULL_TREE if there is no high element. Used to
4141 determine whether or not a new case label duplicates an old case
4142 label. We need a tree, rather than simply a hash table, because
4143 of the GNU case range extension. */
4144 splay_tree cases;
4145 /* Remember whether a default: case label has been seen. */
4147 /* Remember whether a BREAK_STMT has been seen in this SWITCH_STMT. */
4149 /* Set if inside of {FOR,DO,WHILE}_BODY nested inside of a switch,
4150 where BREAK_STMT doesn't belong to the SWITCH_STMT. */
4152 };
4154 /* A stack of the currently active switch statements. The innermost
4155 switch statement is on the top of the stack. There is no need to
4156 mark the stack for garbage collection because it is only active
4157 during the processing of the body of a function, and we never
4158 collect at that point. */
4162 /* Called right after a switch-statement condition is parsed.
4163 SWITCH_STMT is the switch statement being parsed. */
4165 void
4167 {
4177 }
4179 void
4181 {
4184 /* Emit warnings as needed. */
4187 const bool bool_cond_p
4193 bool_cond_p);
4195 /* For the benefit of block_may_fallthru remember if the switch body
4196 case labels cover all possible values and if there are break; stmts. */
4198 || (!processing_template_decl
4204 /* Now that we're done with the switch warnings, set the switch type
4205 to the type of the condition if the index type was of scoped enum type.
4206 (Such types don't participate in the integer promotions.) We do this
4207 because of bit-fields whose declared type is a scoped enum type:
4208 gimplification will use the lowered index type, but convert the
4209 case values to SWITCH_STMT_TYPE, which would have been the declared type
4210 and verify_gimple_switch doesn't accept that. */
4217 }
4219 /* Note that a BREAK_STMT is about to be added. If it is inside of
4220 a SWITCH_STMT and not inside of a loop body inside of it, note
4221 in switch_stack we've seen a BREAK_STMT. */
4223 void
4225 {
4228 }
4230 /* Note the start of processing of an iteration statement's body.
4231 The note_break_stmt function will do nothing while processing it.
4232 Return a flag that should be passed to note_iteration_stmt_body_end. */
4234 bool
4236 {
4242 }
4244 /* Note the end of processing of an iteration statement's body. */
4246 void
4248 {
4251 }
4253 /* Convert a case constant VALUE in a switch to the type TYPE of the switch
4254 condition. Note that if TYPE and VALUE are already integral we don't
4255 really do the conversion because the language-independent
4256 warning/optimization code will work better that way. */
4258 static tree
4260 {
4270 /* The constant-expression VALUE shall be a converted constant expression
4271 of the adjusted type of the switch condition, which doesn't allow
4272 narrowing conversions. */
4279 else
4280 /* The already integral case. */
4284 }
4286 /* Note that we've seen a definition of a case label, and complain if this
4287 is a bad place for one. */
4289 tree
4291 {
4294 tree type;
4300 {
4301 tree label;
4303 /* For templates, just add the case label; we'll do semantic
4304 analysis at instantiation-time. */
4307 }
4309 /* Find the condition on which this switch statement depends. */
4326 /* After labels, make any new cleanups in the function go into their
4327 own new (temporary) binding contour. */
4334 }
4335 \f
4337 tree scope;
4338 tree name;
4339 tree template_id;
4342 };
4345 {
4348 /* Hash a TYPENAME_TYPE. */
4350 static hashval_t
4352 {
4357 }
4359 static hashval_t
4361 {
4363 }
4365 static hashval_t
4367 {
4369 }
4371 /* Compare two TYPENAME_TYPEs. */
4373 static bool
4375 {
4381 }
4382 };
4384 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
4385 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
4387 Returns the new TYPENAME_TYPE. */
4391 tree
4394 {
4395 typename_info ti;
4409 /* See if we already have this type. */
4414 else
4415 {
4416 /* Build the TYPENAME_TYPE. */
4423 /* Build the corresponding TYPE_DECL. */
4430 /* Store it in the hash table. */
4433 /* TYPENAME_TYPEs must always be compared structurally, because
4434 they may or may not resolve down to another type depending on
4435 the currently open classes. */
4437 }
4440 }
4442 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
4443 provided to name the type. Returns an appropriate type, unless an
4444 error occurs, in which case error_mark_node is returned. If we
4445 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
4446 return that, rather than the _TYPE it corresponds to, in other
4447 cases we look through the type decl. If TF_ERROR is set, complain
4448 about errors, otherwise be quiet. */
4450 tree
4452 tsubst_flags_t complain)
4453 {
4454 tree fullname;
4455 tree t;
4464 {
4469 else
4470 /* Create a TEMPLATE_ID_EXPR for the type. */
4474 }
4481 {
4486 {
4490 }
4491 }
4493 {
4497 }
4499 {
4503 }
4510 {
4514 }
4516 /* When the CONTEXT is a dependent type, NAME could refer to a
4517 dependent base class of CONTEXT. But look inside it anyway
4518 if CONTEXT is a currently open scope, in case it refers to a
4519 member of the current instantiation or a non-dependent base;
4520 lookup will stop when we hit a dependent base. */
4522 {
4523 /* We generally don't ignore non-types during TYPENAME_TYPE lookup
4524 (as per [temp.res.general]/3), unless
4525 - the tag corresponds to a class-key or 'enum' so
4526 [basic.lookup.elab] applies, or
4527 - the tag corresponds to scope_type or tf_qualifying_scope is
4528 set so [basic.lookup.qual]/1 applies.
4529 TODO: If we'd set/track the scope_type tag thoroughly on all
4530 TYPENAME_TYPEs that are followed by :: then we wouldn't need the
4531 tf_qualifying_scope flag. */
4535 }
4536 else
4545 {
4547 {
4550 else
4553 }
4555 }
4557 /* Pull out the template from an injected-class-name (or multiple). */
4562 {
4564 {
4567 }
4569 }
4572 {
4577 }
4579 {
4582 /* The caller permits this typename-specifier to name a template
4584 else
4585 {
4590 }
4591 }
4601 {
4608 }
4616 }
4618 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
4619 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
4620 in which case error_mark_node is returned.
4622 If PARM_LIST is non-NULL, also make sure that the template parameter
4623 list of TEMPLATE_DECL matches.
4625 If COMPLAIN zero, don't complain about any errors that occur. */
4627 tree
4629 tsubst_flags_t complain)
4630 {
4639 {
4649 {
4653 }
4657 {
4659 {
4663 }
4665 }
4668 complain))
4672 }
4675 }
4677 /* Build an UNBOUND_CLASS_TEMPLATE. */
4679 tree
4681 {
4682 /* Build the UNBOUND_CLASS_TEMPLATE. */
4688 /* Build the corresponding TEMPLATE_DECL. */
4697 }
4699 \f
4701 /* Push the declarations of builtin types into the global namespace.
4702 RID_INDEX is the index of the builtin type in the array
4703 RID_POINTERS. NAME is the name used when looking up the builtin
4704 type. TYPE is the _TYPE node for the builtin type.
4706 The calls to set_global_binding below should be
4707 eliminated. Built-in types should not be looked up name; their
4708 names are keywords that the parser can recognize. However, there
4709 is code in c-common.cc that uses identifier_global_value to look up
4710 built-in types by name. */
4712 void
4715 tree type)
4716 {
4720 {
4726 }
4731 {
4737 }
4740 {
4744 }
4745 }
4747 /* Push a type into the namespace so that the back ends ignore it. */
4749 static void
4751 {
4754 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
4761 }
4763 /* Create all the predefined identifiers. */
4765 static void
4767 {
4768 struct predefined_identifier
4769 {
4773 };
4775 /* A table of identifiers to create at startup. */
4779 /* Some of these names have a trailing space so that it is
4780 impossible for them to conflict with names written by users. */
4797 /* The demangler expects anonymous namespaces to be called
4798 something starting with '_GLOBAL__N_'. It no longer needs
4799 to be unique to the TU. */
4829 };
4833 {
4835 /* Some of these identifiers already have a special kind. */
4838 }
4839 }
4841 /* Create the predefined scalar types of C,
4842 and some nodes representing standard constants (0, 1, (void *)0).
4843 Initialize the global binding level.
4844 Make definitions for built-in primitive functions. */
4846 void
4848 {
4849 tree void_ftype;
4850 tree void_ftype_ptr;
4852 /* Create all the identifiers we need. */
4855 /* Create the global variables. */
4860 /* Enter the global namespace. */
4863 void_type_node);
4868 /* Remember whether we want the empty class passing ABI change warning
4869 in this TU. */
4872 debug_hooks->register_main_translation_unit
4880 /* Initially, C. */
4883 /* Create the `std' namespace. */
4893 tree decl
4899 /* The concrete return type of __builtin_source_location is
4900 const std::source_location::__impl*, but we can't form the type
4901 at this point. So we initially declare it with an auto return
4902 type which we then "deduce" from require_deduced_type upon first use. */
4910 NULL_TREE);
4911 decl
4913 bool_vaftype,
4914 CP_BUILT_IN_IS_CORRESPONDING_MEMBER,
4918 decl
4920 bool_vaftype,
4921 CP_BUILT_IN_IS_POINTER_INTERCONVERTIBLE_WITH_CLASS,
4927 /* Guess at the initial static decls size. */
4930 /* ... and keyed classes. */
4942 NULL_TREE);
4944 #if 0
4946 #endif
4955 void_ftype_ptr
4958 /* Create the conversion operator marker. This operator's DECL_NAME
4959 is in the identifier table, so we can use identifier equality to
4960 find it. */
4962 void_ftype);
4964 /* C++ extensions */
4969 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
4972 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
4973 result. */
4980 /* Used when parsing to distinguish parameter-lists () and (void). */
4983 {
4984 /* Make sure we get a unique function type, so we can give
4985 its pointer type a name. (This wins for gdb.) */
4992 }
4995 vtbl_type_node
5011 /* Now, C++. */
5016 {
5018 aligned_new_threshold);
5020 }
5026 {
5029 tree ptr_ftype_sizetype;
5030 tree new_eh_spec;
5032 ptr_ftype_sizetype
5035 {
5036 tree bad_alloc_id;
5037 tree bad_alloc_type_node;
5038 tree bad_alloc_decl;
5044 bad_alloc_decl
5049 new_eh_spec
5051 }
5052 else
5055 /* Ensure attribs.cc is initialized. */
5059 NULL_TREE);
5062 extvisattr);
5082 {
5083 /* Also push the sized deallocation variants:
5084 void operator delete(void*, std::size_t) throw();
5085 void operator delete[](void*, std::size_t) throw(); */
5086 tree void_ftype_ptr_size
5090 extvisattr);
5098 }
5101 {
5108 /* operator new (size_t, align_val_t); */
5122 /* operator delete (void *, align_val_t); */
5135 {
5136 /* operator delete (void *, size_t, align_val_t); */
5139 NULL_TREE);
5148 }
5149 }
5151 /* C++-specific nullptr initialization. */
5155 }
5160 abort_fndecl
5164 /* If no definition is available, resolve references to NULL. */
5167 /* Perform other language dependent initializations. */
5184 /* Show we use EH for cleanups. */
5188 /* Check that the hardware interference sizes are at least
5189 alignof(max_align_t), as required by the standard. */
5192 {
5198 "%<--param destructive-interference-size=%d%> "
5201 }
5206 /* else leave it unset. */
5209 {
5216 "%<--param constructive-interference-size=%d%> "
5219 }
5224 }
5226 /* Enter an abi node in global-module context. returns a cookie to
5227 give to pop_abi_namespace. */
5229 unsigned
5231 {
5237 }
5239 /* Pop an abi namespace, FLAGS is the cookie push_abi_namespace gave
5240 you. */
5242 void
5244 {
5248 }
5250 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give
5251 the decl, LOC is the location to give the decl, NAME is the
5252 initialization string and TYPE_DEP indicates whether NAME depended
5253 on the type of the function. We make use of that to detect
5254 __PRETTY_FUNCTION__ inside a template fn. This is being done lazily
5255 at the point of first use, so we mustn't push the decl now. */
5257 static tree
5259 {
5264 {
5271 {
5272 /* __FUNCTION__ */
5275 }
5276 else
5277 {
5278 /* __PRETTY_FUNCTION__ */
5281 }
5288 }
5295 else
5309 /* For decl_constant_var_p. */
5313 {
5318 }
5319 else
5320 {
5323 }
5326 }
5328 /* Install DECL as a builtin function at current global scope. Return
5329 the new decl (if we found an existing version). Also installs it
5330 into ::std, if it's not '_*'. */
5332 tree
5334 {
5339 /* Runtime library routines are, by definition, available in an
5340 external shared object. */
5348 /* In the user's namespace, it must be declared before use. */
5354 /* Treat __*_chk fortification functions as anticipated as well,
5355 unless they are __builtin_*_chk. */
5358 /* All builtins that don't begin with an '_' should additionally
5359 go in the 'std' namespace. */
5361 {
5368 }
5374 }
5376 /* Like cxx_builtin_function, but guarantee the function is added to the global
5377 scope. This is to allow function specific options to add new machine
5378 dependent builtins when the target ISA changes via attribute((target(...)))
5379 which saves space on program startup if the program does not use non-generic
5380 ISAs. */
5382 tree
5384 {
5390 }
5392 /* Implement LANG_HOOKS_SIMULATE_BUILTIN_FUNCTION_DECL. */
5394 tree
5396 {
5403 }
5405 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
5406 function. Not called directly. */
5408 static tree
5411 {
5419 /* Runtime library routines are, by definition, available in an
5420 external shared object. */
5425 }
5427 /* Returns the _DECL for a library function with C++ linkage. */
5429 static tree
5432 {
5437 }
5439 /* Like build_library_fn, but takes a C string instead of an
5440 IDENTIFIER_NODE. */
5442 tree
5444 {
5446 }
5448 /* Like build_cp_library_fn, but takes a C string instead of an
5449 IDENTIFIER_NODE. */
5451 tree
5453 {
5455 ecf_flags);
5456 }
5458 /* Like build_library_fn, but also pushes the function so that we will
5459 be able to find it via get_global_binding. Also, the function
5460 may throw exceptions listed in RAISES. */
5462 tree
5464 {
5470 }
5472 /* Like build_cp_library_fn, but also pushes the function so that it
5473 will be found by normal lookup. */
5475 static tree
5478 {
5485 }
5487 /* Like push_library_fn, but also note that this function throws
5488 and does not return. Used for __throw_foo and the like. */
5490 tree
5492 {
5496 }
5497 \f
5498 /* When we call finish_struct for an anonymous union, we create
5499 default copy constructors and such. But, an anonymous union
5500 shouldn't have such things; this function undoes the damage to the
5501 anonymous union type T.
5503 (The reason that we create the synthesized methods is that we don't
5504 distinguish `union { int i; }' from `typedef union { int i; } U'.
5505 The first is an anonymous union; the second is just an ordinary
5506 union type.) */
5508 void
5510 {
5511 /* Wipe out memory of synthesized methods. */
5519 /* Splice the implicitly generated functions out of TYPE_FIELDS and diagnose
5520 invalid members. */
5522 {
5525 else
5535 {
5536 /* We already complained about static data members in
5537 finish_static_data_member_decl. */
5539 {
5540 auto_diagnostic_group d;
5544 "only have public non-static data members"
5547 {
5550 {
5553 "this flexibility is deprecated and will be "
5555 }
5556 }
5557 }
5558 }
5559 }
5561 /* Splice all functions out of CLASSTYPE_MEMBER_VEC. */
5569 /* Wipe RTTI info. */
5572 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
5573 assignment operators (because they cannot have these methods themselves).
5574 For anonymous unions this is already checked because they are not allowed
5575 in any union, otherwise we have to check it. */
5577 {
5581 {
5583 /* Avoid ICE after error on anon-struct9.C. */
5585 }
5589 {
5592 {
5602 }
5603 }
5604 }
5605 }
5607 /* Warn for an attribute located at LOCATION that appertains to the
5608 class type CLASS_TYPE that has not been properly placed after its
5609 class-key, in it class-specifier. */
5611 void
5613 tree class_type)
5614 {
5617 auto_diagnostic_group d;
5619 "attribute ignored in declaration "
5624 }
5626 /* Returns the cv-qualifiers that apply to the type specified
5627 by the DECLSPECS. */
5629 static int
5631 {
5642 }
5644 /* Make sure that a declaration with no declarator is well-formed, i.e.
5645 just declares a tagged type or anonymous union.
5647 Returns the type declared; or NULL_TREE if none. */
5649 tree
5652 {
5655 /* If a class, struct, or enum type is declared by the DECLSPECS
5656 (i.e, if a class-specifier, enum-specifier, or non-typename
5657 elaborated-type-specifier appears in the DECLSPECS),
5658 DECLARED_TYPE is set to the corresponding type. */
5666 {
5672 }
5684 {
5686 "%<auto%> can only be specified for variables "
5689 }
5696 /* Check for an anonymous union. */
5699 {
5700 /* 7/3 In a simple-declaration, the optional init-declarator-list
5701 can be omitted only when declaring a class (clause 9) or
5702 enumeration (7.2), that is, when the decl-specifier-seq contains
5703 either a class-specifier, an elaborated-type-specifier with
5704 a class-key (9.1), or an enum-specifier. In these cases and
5705 whenever a class-specifier or enum-specifier is present in the
5706 decl-specifier-seq, the identifiers in these specifiers are among
5707 the names being declared by the declaration (as class-name,
5708 enum-names, or enumerators, depending on the syntax). In such
5709 cases, and except for the declaration of an unnamed bit-field (9.6),
5710 the decl-specifier-seq shall introduce one or more names into the
5711 program, or shall redeclare a name introduced by a previous
5712 declaration. [Example:
5713 enum { }; // ill-formed
5714 typedef class { }; // ill-formed
5715 --end example] */
5717 {
5721 }
5728 }
5730 else
5731 {
5739 && (!current_class_type
5748 "a storage class can only be specified for objects "
5752 "%<const%> can only be specified for objects and "
5756 "%<volatile%> can only be specified for objects and "
5760 "%<__restrict%> can only be specified for objects and "
5764 "%<__thread%> can only be specified for objects "
5778 }
5781 {
5782 location_t loc;
5785 /* For a non-template class, use the name location. */
5787 else
5788 /* For a template class (an explicit instantiation), use the
5789 current location. */
5793 /* [dcl.attr.grammar]/4:
5795 No attribute-specifier-seq shall appertain to an explicit
5796 instantiation. */
5797 {
5800 declared_type))
5802 "no attribute can be applied to "
5804 }
5805 else
5807 }
5809 /* Diagnose invalid application of contracts, if any. */
5812 else
5816 }
5818 /* Called when a declaration is seen that contains no names to declare.
5819 If its type is a reference to a structure, union or enum inherited
5820 from a containing scope, shadow that tag name for the current scope
5821 with a forward reference.
5822 If its type defines a new named structure or union
5823 or defines an enum, it is valid but we need not do anything here.
5824 Otherwise, it is an error.
5826 C++: may have to grok the declspecs to learn about static,
5827 complain for anonymous unions.
5829 Returns the TYPE declared -- or NULL_TREE if none. */
5831 tree
5833 {
5844 /* This is where the variables in an anonymous union are
5845 declared. An anonymous union declaration looks like:
5846 union { ... } ;
5847 because there is no declarator after the union, the parser
5848 sends that declaration here. */
5850 {
5854 {
5858 }
5859 }
5862 }
5863 \f
5864 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
5866 tree
5870 {
5871 tree attrs;
5872 tree type;
5873 enum decl_context context
5879 {
5884 /* A template type parameter or other dependent type. */
5887 else
5889 }
5891 }
5893 /* Process a DECLARATOR for a function-scope or namespace-scope
5894 variable or function declaration.
5895 (Function definitions go through start_function; class member
5896 declarations appearing in the body of the class go through
5897 grokfield.) The DECL corresponding to the DECLARATOR is returned.
5898 If an error occurs, the error_mark_node is returned instead.
5900 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED is
5901 SD_INITIALIZED if an explicit initializer is present, or SD_DEFAULTED
5902 for an explicitly defaulted function, or SD_DELETED for an explicitly
5903 deleted function, but 0 (SD_UNINITIALIZED) if this is a variable
5904 implicitly initialized via a default constructor. It can also be
5905 SD_DECOMPOSITION which behaves much like SD_INITIALIZED, but we also
5906 mark the new decl as DECL_DECOMPOSITION_P.
5908 ATTRIBUTES and PREFIX_ATTRIBUTES are GNU attributes associated with this
5909 declaration.
5911 The scope represented by the context of the returned DECL is pushed
5912 (if it is not the global namespace) and is assigned to
5913 *PUSHED_SCOPE_P. The caller is then responsible for calling
5914 pop_scope on *PUSHED_SCOPE_P if it is set. */
5916 tree
5920 tree attributes,
5921 tree prefix_attributes,
5923 {
5924 tree decl;
5925 tree context;
5929 tree initial;
5949 {
5954 }
5956 /* Save the DECL_INITIAL value in case it gets clobbered to assist
5957 with attribute validation. */
5961 {
5965 decl);
5969 /* Tell 'cplus_decl_attributes' this is an initialized decl,
5970 even though we might not yet have the initializer expression. */
5973 }
5979 /* If this is a typedef that names the class for linkage purposes
5980 (7.1.3p8), apply any attributes directly to the type. */
5985 else
5988 /* Set attributes here so if duplicate decl, will have proper attributes. */
5991 /* Restore the original DECL_INITIAL that we may have clobbered earlier to
5992 assist with attribute validation. */
5995 /* Dllimported symbols cannot be defined. Static data members (which
5996 can be initialized in-class and dllimported) go through grokfield,
5997 not here, so we don't need to exclude those decls when checking for
5998 a definition. */
6000 {
6004 }
6006 /* If #pragma weak was used, mark the decl weak now. */
6018 {
6022 {
6032 {
6038 }
6039 else
6040 {
6045 {
6052 }
6053 /* Static data member are tricky; an in-class initialization
6054 still doesn't provide a definition, so the in-class
6055 declaration will have DECL_EXTERNAL set, but will have an
6056 initialization. Thus, duplicate_decls won't warn
6057 about this situation, and so we check here. */
6065 }
6066 }
6067 else
6068 {
6070 this_tmpl
6071 ? current_template_parms
6076 }
6078 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
6080 /* Do not mark DECL as an explicit specialization if it was not
6081 already marked as an instantiation; a declaration should
6082 never be marked as a specialization unless we know what
6083 template is being specialized. */
6085 {
6090 else
6093 /* [temp.expl.spec] An explicit specialization of a static data
6094 member of a template is a definition if the declaration
6095 includes an initializer; otherwise, it is a declaration.
6097 We check for processing_specialization so this only applies
6098 to the new specialization syntax. */
6101 }
6104 /* Aliases are definitions. */
6106 {
6110 decl);
6114 decl);
6115 }
6116 }
6118 /* Create a DECL_LANG_SPECIFIC so that DECL_DECOMPOSITION_P works. */
6126 {
6127 /* A function-scope decl of some namespace-scope decl. */
6131 "block-scope extern declaration %q#D must not be"
6133 }
6135 /* Enter this declaration into the symbol table. Don't push the plain
6136 VAR_DECL for a variable template. */
6150 /* But not templated variables. */
6152 {
6153 /* This is a const variable with implicit 'static'. Set
6154 DECL_THIS_STATIC so we can tell it from variables that are
6155 !TREE_PUBLIC because of the anonymous namespace. */
6158 }
6163 {
6167 "%qD defined %<thread_local%> in %qs function only "
6173 "%qD defined %<static%> in %qs function only available "
6177 else
6181 }
6187 }
6189 /* Process the declaration of a variable DECL. INITIALIZED is true
6190 iff DECL is explicitly initialized. (INITIALIZED is false if the
6191 variable is initialized via an implicitly-called constructor.)
6192 This function must be called for ordinary variables (including, for
6193 example, implicit instantiations of templates), but must not be
6194 called for template declarations. */
6196 void
6198 {
6208 bool aggregate_definition_p
6211 /* If an explicit initializer is present, or if this is a definition
6212 of an aggregate, then we need a complete type at this point.
6213 (Scalars are always complete types, so there is nothing to
6214 check.) This code just sets COMPLETE_P; errors (if necessary)
6215 are issued below. */
6217 && !complete_p
6219 {
6221 /* We will not yet have set TREE_READONLY on DECL if the type
6222 was "const", but incomplete, before this point. But, now, we
6223 have a complete type, so we can try again. */
6225 }
6228 /* Is it valid for this decl to have an initializer at all? */
6229 {
6230 /* Don't allow initializations for incomplete types except for
6231 arrays which might be completed by the initialization. */
6237 {
6238 auto_diagnostic_group d;
6244 }
6246 {
6249 /* else we already gave an error in start_decl. */
6250 }
6251 }
6253 {
6256 else
6257 {
6258 auto_diagnostic_group d;
6260 decl);
6264 /* Change the type so that assemble_variable will give
6265 DECL an rtl we can live with: (mem (const_int 0)). */
6267 }
6268 }
6270 /* Create a new scope to hold this declaration if necessary.
6271 Whether or not a new scope is necessary cannot be determined
6272 until after the type has been completed; if the type is a
6273 specialization of a class template it is not until after
6274 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
6275 will be set correctly. */
6277 }
6279 /* Given a parenthesized list of values INIT, create a CONSTRUCTOR to handle
6280 C++20 P0960. TYPE is the type of the object we're initializing. */
6282 tree
6284 {
6288 {
6289 /* If the list has a single element and it's a string literal,
6290 then it's the initializer for the array as a whole. */
6296 /* Handle non-standard extensions like compound literals. This also
6297 prevents triggering aggregate parenthesized-initialization in
6298 compiler-generated code for =default. */
6302 }
6308 }
6310 /* Handle initialization of references. DECL, TYPE, and INIT have the
6311 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
6312 but will be set to a new CLEANUP_STMT if a temporary is created
6313 that must be destroyed subsequently.
6315 Returns an initializer expression to use to initialize DECL, or
6316 NULL if the initialization can be performed statically.
6318 Quotes on semantics can be found in ARM 8.4.3. */
6320 static tree
6322 {
6324 {
6331 }
6335 {
6336 /* This handles (C++20 only) code like
6338 const A& r(1, 2, 3);
6340 where we treat the parenthesized list as a CONSTRUCTOR. */
6345 {
6346 /* We don't know yet if we should treat const A& r(1) as
6347 const A& r{1}. */
6349 {
6352 tf_warning_or_error);
6353 }
6354 /* If the list had more than one element, the code is ill-formed
6355 pre-C++20, so we can build a constructor right away. */
6356 else
6358 }
6359 else
6361 tf_warning_or_error);
6362 }
6366 /* Note: default conversion is only called in very special cases. */
6369 /* check_initializer handles this for non-reference variables, but for
6370 references we need to do it here or the initializer will get the
6371 incomplete array type and confuse later calls to
6372 cp_complete_array_type. */
6377 {
6381 }
6383 /* Convert INIT to the reference type TYPE. This may involve the
6384 creation of a temporary, whose lifetime must be the same as that
6385 of the reference. If so, a DECL_EXPR for the temporary will be
6386 added just after the DECL_EXPR for DECL. That's why we don't set
6387 DECL_INITIAL for local references (instead assigning to them
6388 explicitly); we need to allow the temporary to be initialized
6389 first. */
6391 tf_warning_or_error);
6392 }
6394 /* Designated initializers in arrays are not supported in GNU C++.
6395 The parser cannot detect this error since it does not know whether
6396 a given brace-enclosed initializer is for a class type or for an
6397 array. This function checks that CE does not use a designated
6398 initializer. If it does, an error is issued. Returns true if CE
6399 is valid, i.e., does not have a designated initializer. */
6401 bool
6404 {
6405 /* Designated initializers for array elements are not supported. */
6407 {
6408 /* The parser only allows identifiers as designated
6409 initializers. */
6411 {
6415 }
6417 {
6421 }
6429 {
6430 /* A C99 designator is OK if it matches the current index. */
6432 {
6435 }
6436 else
6438 }
6439 else
6445 }
6448 }
6450 /* When parsing `int a[] = {1, 2};' we don't know the size of the
6451 array until we finish parsing the initializer. If that's the
6452 situation we're in, update DECL accordingly. */
6454 static void
6456 {
6462 {
6463 /* do_default is really a C-ism to deal with tentative definitions.
6464 But let's leave it here to ease the eventual merge. */
6469 /* Check that there are no designated initializers in INIT, as
6470 those are not supported in GNU C++, and as the middle-end
6471 will crash if presented with a non-numeric designated
6472 initializer. */
6474 {
6477 HOST_WIDE_INT i;
6479 {
6484 /* If an un-designated initializer is type-dependent, we can't
6485 check brace elision yet. */
6489 }
6490 }
6494 else
6495 {
6497 do_default);
6499 {
6503 }
6505 {
6507 {
6510 }
6511 /* If a `static' var's size isn't known, make it extern as
6512 well as static, so it does not get allocated. If it's not
6513 `static', then don't mark it extern; finish_incomplete_decl
6514 will give it a default size and it will get allocated. */
6517 }
6519 {
6522 }
6523 }
6528 }
6529 }
6531 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
6532 any appropriate error messages regarding the layout. */
6534 static void
6536 {
6537 tree type;
6543 /* If we haven't already laid out this declaration, do so now.
6544 Note that we must not call complete type for an external object
6545 because it's type might involve templates that we are not
6546 supposed to instantiate yet. (And it's perfectly valid to say
6547 `extern X x' for some incomplete type `X'.) */
6556 {
6557 /* An automatic variable with an incomplete type: that is an error.
6558 Don't talk about array types here, since we took care of that
6559 message in grokdeclarator. */
6563 }
6564 #if 0
6565 /* Keep this code around in case we later want to control debug info
6566 based on whether a type is "used". (jason 1999-11-11) */
6569 /* Let debugger know it should output info for this type. */
6574 #endif
6579 {
6583 else
6584 {
6589 }
6590 }
6592 /* If the final element initializes a flexible array field, adjust
6593 the size of the DECL with the initializer based on whether the
6594 DECL is a union or a structure. */
6604 {
6607 {
6614 {
6615 /* For a structure, add the size of the initializer to the DECL's
6616 size. */
6618 {
6625 }
6626 /* For a union, the DECL's size is the maximum of the current size
6627 and the size of the initializer. */
6628 else
6629 {
6636 }
6637 }
6638 }
6639 }
6640 }
6642 /* If a local static variable is declared in an inline function, or if
6643 we have a weak definition, we must endeavor to create only one
6644 instance of the variable at link-time. */
6646 void
6648 {
6649 /* Don't mess with __FUNCTION__ and similar. But do handle structured
6650 bindings. */
6654 /* Static data in a function with comdat linkage also has comdat
6655 linkage. */
6660 {
6662 {
6663 /* With weak symbols, we simply make the variable COMDAT;
6664 that will cause copies in multiple translations units to
6665 be merged. */
6667 }
6668 else
6669 {
6672 {
6673 /* Without weak symbols, we can use COMMON to merge
6674 uninitialized variables. */
6677 }
6678 else
6679 {
6680 /* While for initialized variables, we must use internal
6681 linkage -- which means that multiple copies will not
6682 be merged. */
6689 "%q#D are wrong (you%'ll wind up with "
6691 else
6693 "static data %q#D are wrong (you%'ll wind "
6699 }
6700 }
6701 }
6702 }
6704 /* Issue an error message if DECL is an uninitialized const variable.
6705 CONSTEXPR_CONTEXT_P is true when the function is called in a constexpr
6706 context from potential_constant_expression. Returns true if all is well,
6707 false otherwise. */
6709 bool
6711 tsubst_flags_t complain)
6712 {
6715 /* ``Unless explicitly declared extern, a const object does not have
6716 external linkage and must be initialized. ($8.4; $12.1)'' ARM
6717 7.1.6 */
6721 /* C++20 permits trivial default initialization in constexpr
6722 context (P1331R2). */
6724 && (constexpr_context_p
6727 {
6735 {
6737 {
6741 }
6742 else
6743 {
6747 "uninitialized variable %qD in %<constexpr%> "
6749 else
6752 }
6753 }
6757 decl);
6760 {
6761 tree defaulted_ctor;
6768 "constructor is not user-provided because it is "
6771 "and the implicitly-defined constructor does not "
6773 }
6776 }
6779 }
6780 \f
6781 /* Structure holding the current initializer being processed by reshape_init.
6782 CUR is a pointer to the current element being processed, END is a pointer
6783 after the last element present in the initializer. */
6784 struct reshape_iter
6785 {
6788 };
6792 /* FIELD is an element of TYPE_FIELDS or NULL. In the former case, the value
6793 returned is the next FIELD_DECL (possibly FIELD itself) that can be
6794 initialized as if for an aggregate class. If there are no more such fields,
6795 the return value will be NULL. */
6797 tree
6799 {
6804 /* In C++17, aggregates can have bases. */
6809 }
6811 /* FIELD is an element of TYPE_FIELDS or NULL. In the former case, the value
6812 returned is the next FIELD_DECL (possibly FIELD itself) that corresponds
6813 to a subobject. If there are no more such fields, the return value will be
6814 NULL. */
6816 tree
6818 {
6828 }
6830 /* Return true for [dcl.init.list] direct-list-initialization from
6831 single element of enumeration with a fixed underlying type. */
6833 bool
6835 {
6842 /* DR 2374: The single element needs to be implicitly
6843 convertible to the underlying type of the enum. */
6851 }
6853 /* Subroutine of reshape_init_array and reshape_init_vector, which does
6854 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
6855 INTEGER_CST representing the size of the array minus one (the maximum index),
6856 or NULL_TREE if the array was declared without specifying the size. D is
6857 the iterator within the constructor. */
6859 static tree
6862 {
6863 tree new_init;
6868 /* The initializer for an array is always a CONSTRUCTOR. If this is the
6869 outermost CONSTRUCTOR and the element type is non-aggregate, we don't need
6870 to build a new one. But don't reuse if not complaining; if this is
6871 tentative, we might also reshape to another type (95319). */
6878 else
6882 {
6883 /* Minus 1 is used for zero sized arrays. */
6889 /* sizetype is sign extended, not zero extended. */
6890 else
6892 }
6894 /* Loop until there are no more initializers. */
6898 {
6899 tree elt_init;
6907 complain);
6912 {
6915 }
6916 else
6922 /* This can happen with an invalid initializer (c++/54501). */
6925 }
6928 }
6930 /* Subroutine of reshape_init_r, processes the initializers for arrays.
6931 Parameters are the same of reshape_init_r. */
6933 static tree
6935 tsubst_flags_t complain)
6936 {
6946 }
6948 /* Subroutine of reshape_init_r, processes the initializers for vectors.
6949 Parameters are the same of reshape_init_r. */
6951 static tree
6953 {
6959 {
6962 {
6967 }
6970 }
6972 /* For a vector, we initialize it as an array of the appropriate size. */
6978 }
6980 /* Subroutine of reshape_init*: We're initializing an element with TYPE from
6981 INIT, in isolation from any designator or other initializers. */
6983 static tree
6985 {
6986 /* We could also implement this by wrapping init in a new CONSTRUCTOR and
6987 calling reshape_init, but this way can just live on the stack. */
6992 complain);
6993 }
6995 /* Subroutine of reshape_init_r, processes the initializers for classes
6996 or union. Parameters are the same of reshape_init_r. */
6998 static tree
7000 tsubst_flags_t complain)
7001 {
7002 tree field;
7003 tree new_init;
7007 /* The initializer for a class is always a CONSTRUCTOR. */
7014 {
7015 /* We get here from maybe_aggr_guide for C++20 class template argument
7016 deduction. In this case we need to look through the binfo because a
7017 template doesn't have base fields. */
7020 }
7023 else
7027 {
7028 /* [dcl.init.aggr]
7030 An initializer for an aggregate member that is an
7031 empty class shall have the form of an empty
7032 initializer-list {}. */
7034 {
7038 }
7040 }
7042 /* For C++20 CTAD, handle pack expansions in the base list. */
7045 /* Loop through the initializable fields, gathering initializers. */
7047 {
7048 tree field_init;
7052 /* Handle C++20 designated initializers. */
7054 {
7059 {
7060 /* We already reshaped this; we should have returned early from
7061 reshape_init. */
7064 {
7069 }
7070 }
7072 {
7076 }
7077 else
7078 {
7083 }
7086 /* Apparently the designator isn't for a member of this anonymous
7087 struct, so head back to the enclosing class. */
7091 {
7093 {
7095 {
7099 }
7100 else
7103 }
7105 }
7107 /* If the element is an anonymous union object and the initializer
7108 list is a designated-initializer-list, the anonymous union object
7109 is initialized by the designated-initializer-list { D }, where D
7110 is the designated-initializer-clause naming a member of the
7111 anonymous union object. */
7114 {
7115 /* Find the anon aggr that is a direct member of TYPE. */
7117 {
7122 }
7124 /* Not found, e.g. FIELD is a member of a base class. */
7129 found:
7130 /* Now find the TYPE member with that anon aggr type. */
7138 }
7139 }
7141 /* If we processed all the member of the class, we are done. */
7148 /* Each non-trailing aggregate element that is a pack expansion is
7149 assumed to correspond to no elements of the initializer list. */
7153 {
7154 /* The designated field F is initialized from this one element.
7156 Note that we don't want to do this if we found the designator
7157 inside an anon aggr above; we use the normal code to implement:
7159 "If the element is an anonymous union member and the initializer
7160 list is a brace-enclosed designated- initializer-list, the element
7161 is initialized by the designated-initializer-list { D }, where D
7162 is the designated- initializer-clause naming a member of the
7163 anonymous union member." */
7167 }
7168 else
7171 complain);
7177 {
7178 /* This can happen with an invalid initializer for a flexible
7179 array member (c++/54441). */
7183 }
7187 /* [dcl.init.aggr]
7189 When a union is initialized with a brace-enclosed
7190 initializer, the braces shall only contain an
7191 initializer for the first member of the union. */
7195 continue_:
7197 {
7200 else
7202 }
7203 else
7205 }
7207 /* A trailing aggregate element that is a pack expansion is assumed to
7208 correspond to all remaining elements of the initializer list (if any). */
7210 {
7215 }
7218 }
7220 /* Subroutine of reshape_init_r. We're in a context where C99 initializer
7221 designators are not valid; either complain or return true to indicate
7222 that reshape_init_r should return error_mark_node. */
7224 static bool
7226 {
7228 {
7233 else
7235 }
7237 }
7239 /* Subroutine of reshape_init, which processes a single initializer (part of
7240 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
7241 iterator within the CONSTRUCTOR which points to the initializer to process.
7242 If this is the first initializer of the outermost CONSTRUCTOR node,
7243 FIRST_INITIALIZER_P is that CONSTRUCTOR; otherwise, it is NULL_TREE. */
7245 static tree
7247 tsubst_flags_t complain)
7248 {
7261 {
7262 /* A complex type can be initialized from one or two initializers,
7263 but braces are not elided. */
7266 {
7268 {
7271 else
7273 }
7274 }
7276 {
7284 }
7286 }
7288 /* A non-aggregate type is always initialized with a single
7289 initializer. */
7291 /* As is an array with dependent bound, which we can see
7292 during C++20 aggregate CTAD. */
7296 {
7297 /* It is invalid to initialize a non-aggregate type with a
7298 brace-enclosed initializer before C++0x.
7299 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
7300 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
7301 a CONSTRUCTOR (with a record type). */
7303 /* Don't complain about a capture-init. */
7306 {
7308 {
7310 {
7313 type);
7315 }
7318 && (BRACE_ENCLOSED_INITIALIZER_P
7320 {
7325 }
7326 }
7327 else
7329 }
7333 }
7335 /* "If T is a class type and the initializer list has a single element of
7336 type cv U, where U is T or a class derived from T, the object is
7337 initialized from that element." Even if T is an aggregate. */
7339 && first_initializer_p
7340 /* But not if it's a designated init. */
7344 {
7347 }
7349 /* [dcl.init.aggr]
7351 All implicit type conversions (clause _conv_) are considered when
7352 initializing the aggregate member with an initializer from an
7353 initializer-list. If the initializer can initialize a member,
7354 the member is initialized. Otherwise, if the member is itself a
7355 non-empty subaggregate, brace elision is assumed and the
7356 initializer is considered for the initialization of the first
7357 member of the subaggregate. */
7359 /* But don't try this for the first initializer, since that would be
7360 looking through the outermost braces; A a2 = { a1 }; is not a
7361 valid aggregate initialization. */
7362 && !first_initializer_p
7365 complain)))
7366 {
7369 }
7371 /* [dcl.init.string]
7373 A char array (whether plain char, signed char, or unsigned char)
7374 can be initialized by a string-literal (optionally enclosed in
7375 braces); a wchar_t array can be initialized by a wide
7376 string-literal (optionally enclosed in braces). */
7379 {
7382 reshape_iter stripd = {};
7384 /* Strip one level of braces if and only if they enclose a single
7385 element (as allowed by [dcl.init.string]). */
7389 {
7393 }
7395 /* If it's a string literal, then it's the initializer for the array
7396 as a whole. Otherwise, continue with normal initialization for
7397 array types (one value per array element). */
7399 {
7405 }
7406 }
7408 /* The following cases are about aggregates. If we are not within a full
7409 initializer already, and there is not a CONSTRUCTOR, it means that there
7410 is a missing set of braces (that is, we are processing the case for
7411 which reshape_init exists). */
7414 {
7416 {
7419 /* There is no need to call reshape_init for pointer-to-member
7420 function initializers, as they are always constructed correctly
7421 by the front end. Here we have e.g. {.__pfn=0B, .__delta=0},
7422 which is missing outermost braces. We should warn below, and
7424 /* For a nested compound literal, proceed to specialized routines,
7425 to handle initialization of arrays and similar. */
7428 /* If we have an unresolved designator, we need to find the member it
7429 designates within TYPE, so proceed to the routines below. For
7430 FIELD_DECL or INTEGER_CST designators, we're already initializing
7431 the designated element. */
7434 /* Brace elision with designators is only permitted for anonymous
7435 aggregates. */
7437 /* A CONSTRUCTOR of the target's type is a previously
7438 digested initializer. */
7440 {
7443 }
7444 else
7445 {
7446 /* Something that hasn't been reshaped yet. */
7450 }
7451 }
7456 type);
7458 }
7460 /* Dispatch to specialized routines. */
7461 tree new_init;
7468 else
7476 }
7478 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
7479 brace-enclosed aggregate initializer.
7481 INIT is the CONSTRUCTOR containing the list of initializers describing
7482 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
7483 It may not presently match the shape of the TYPE; for example:
7485 struct S { int a; int b; };
7486 struct S a[] = { 1, 2, 3, 4 };
7488 Here INIT will hold a vector of four elements, rather than a
7489 vector of two elements, each itself a vector of two elements. This
7490 routine transforms INIT from the former form into the latter. The
7491 revised CONSTRUCTOR node is returned. */
7493 tree
7495 {
7497 reshape_iter d;
7498 tree new_init;
7504 /* An empty constructor does not need reshaping, and it is always a valid
7505 initializer. */
7510 /* Already reshaped. */
7513 /* Brace elision is not performed for a CONSTRUCTOR representing
7514 parenthesized aggregate initialization. */
7516 {
7518 /* If we're initializing a char array from a string-literal that is
7519 enclosed in braces, unwrap it here. */
7526 }
7528 /* Handle [dcl.init.list] direct-list-initialization from
7529 single element of enumeration with a fixed underlying type. */
7531 {
7535 {
7539 tf_warning_or_error);
7540 }
7541 else
7543 }
7545 /* Recurse on this CONSTRUCTOR. */
7553 /* Make sure all the element of the constructor were used. Otherwise,
7554 issue an error about exceeding initializers. */
7556 {
7560 }
7571 }
7573 /* Verify array initializer. Returns true if errors have been reported. */
7575 bool
7577 {
7580 /* Structured binding when initialized with an array type needs
7581 to have complete type. */
7586 {
7591 }
7593 /* The array type itself need not be complete, because the
7594 initializer may tell us how many elements are in the array.
7595 But, the elements of the array must be complete. */
7597 {
7601 else
7604 }
7610 /* A compound literal can't have variable size. */
7614 {
7617 }
7619 }
7621 /* Subroutine of check_initializer; args are passed down from that function.
7622 Set stmts_are_full_exprs_p to 1 across a call to build_aggr_init. */
7624 static tree
7626 {
7631 }
7633 /* Verify INIT (the initializer for DECL), and record the
7634 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
7635 grok_reference_init.
7637 If the return value is non-NULL, it is an expression that must be
7638 evaluated dynamically to initialize DECL. */
7640 static tree
7642 {
7643 tree type;
7645 tree core_type;
7647 /* Things that are going to be initialized need to have complete
7648 type. */
7652 {
7653 /* A variable with DECL_HAS_VALUE_EXPR_P set is just a placeholder,
7654 it doesn't have storage to be initialized. */
7657 }
7660 /* We will have already complained. */
7664 {
7667 }
7669 {
7674 }
7675 else
7676 /* There is no way to make a variable-sized class type in GNU C++. */
7680 {
7683 {
7685 {
7688 }
7690 {
7692 "scalar object %qD requires one element in "
7696 }
7697 }
7698 }
7701 {
7708 }
7710 ;
7713 {
7715 {
7718 }
7721 tf_warning_or_error);
7722 /* Do not reshape constructors of vectors (they don't need to be
7723 reshaped. */
7725 {
7727 {
7729 tf_warning_or_error);
7731 }
7733 {
7734 /* Don't reshape if the class has constructors. */
7737 "in C++98 %qD must be initialized by "
7739 decl);
7740 }
7742 {
7745 }
7746 else
7747 {
7750 }
7751 }
7752 /* [dcl.init] "Otherwise, if the destination type is an array, the object
7753 is initialized as follows..." So handle things like
7755 int a[](1, 2, 3);
7757 which is permitted in C++20 by P0960. */
7767 {
7770 /* We get here with code like `int a (2);' */
7772 tf_warning_or_error);
7773 }
7775 /* If DECL has an array type without a specific bound, deduce the
7776 array size from the initializer. */
7787 /* The call to build_aggr_init below could end up
7788 calling build_vec_init, which may break when we
7789 are processing a template. */
7790 || processing_template_decl
7794 {
7797 /* A constructor call is a non-trivial initializer even if
7798 it isn't explicitly written. */
7802 /* If this is a constexpr initializer, expand_default_init will
7803 have returned an INIT_EXPR rather than a CALL_EXPR. In that
7804 case, pull the initializer back out and pass it down into
7805 store_init_value. */
7807 {
7814 else
7816 }
7818 {
7819 /* In C++20, the call to build_aggr_init could have created
7820 an INIT_EXPR with a CONSTRUCTOR as the RHS to handle
7821 A(1, 2). */
7824 /* Avoid leaking TARGET_EXPR into template trees. */
7829 /* Don't call digest_init; it's unnecessary and will complain
7830 about aggregate initialization of non-aggregate classes. */
7832 }
7835 {
7836 /* Declared constexpr or constinit, but no suitable initializer;
7837 massage init appropriately so we can pass it into
7838 store_init_value for the error. */
7848 {
7853 }
7855 }
7856 else
7858 }
7861 {
7867 {
7872 }
7884 }
7885 }
7886 else
7887 {
7895 tf_warning_or_error);
7896 }
7906 {
7907 /* We might have set these in cp_finish_decl. */
7910 }
7915 {
7923 else
7927 {
7931 }
7933 }
7936 }
7938 /* If DECL is not a local variable, give it RTL. */
7940 static void
7942 {
7946 /* Set the DECL_ASSEMBLER_NAME for the object. */
7948 {
7949 /* The `register' keyword, when used together with an
7950 asm-specification, indicates that the variable should be
7951 placed in a particular register. */
7953 {
7956 }
7957 else
7958 {
7965 /* We have to propagate the name to the ns-alias.
7966 This is horrible, as we're affecting a
7967 possibly-shared decl. Again, a one-true-decl
7968 model breaks down. */
7971 }
7972 }
7974 /* Handle non-variables up front. */
7976 {
7979 }
7981 /* If we see a class member here, it should be a static data
7982 member. */
7984 {
7986 /* An in-class declaration of a static data member should be
7987 external; it is only a declaration, and not a definition. */
7991 }
7993 /* We don't create any RTL for local variables. */
7997 /* We defer emission of local statics until the corresponding
7998 DECL_EXPR is expanded. But with constexpr its function might never
7999 be expanded, so go ahead and tell cgraph about the variable now. */
8004 /* Defer template instantiations. */
8009 /* If we're not deferring, go ahead and assemble the variable. */
8012 }
8014 /* walk_tree helper for wrap_temporary_cleanups, below. */
8016 static tree
8018 {
8019 /* Stop at types or full-expression boundaries. */
8022 {
8025 }
8028 {
8034 {
8036 /* Tell honor_protect_cleanup_actions to handle this as a separate
8037 cleanup. */
8040 }
8041 }
8044 }
8046 /* We're initializing a local variable which has a cleanup GUARD. If there
8047 are any temporaries used in the initializer INIT of this variable, we
8048 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
8049 variable will be cleaned up properly if one of them throws.
8051 Unfortunately, there's no way to express this properly in terms of
8052 nesting, as the regions for the temporaries overlap the region for the
8053 variable itself; if there are two temporaries, the variable needs to be
8054 the first thing destroyed if either of the temporary destructors throws.
8055 However, we only want to run the variable's cleanup if it actually got
8056 constructed. So we need to guard the temporary cleanups with the
8057 variable's cleanup if they are run on the normal path, but not if they
8058 are run on the exceptional path. We implement this by telling
8059 honor_protect_cleanup_actions to strip the variable cleanup from the
8060 exceptional path.
8062 Another approach could be to make the variable cleanup region enclose
8063 initialization, but depend on a flag to indicate that the variable is
8064 initialized; that's effectively what we do for arrays. But the current
8065 approach works fine for non-arrays, and has no code overhead in the usual
8066 case where the temporary destructors are noexcept. */
8068 static void
8070 {
8072 {
8073 /* An array cleanup region already encloses any temporary cleanups,
8074 don't wrap it around them again. */
8077 }
8079 }
8081 /* Generate code to initialize DECL (a local variable). */
8083 static void
8085 {
8087 tree cleanup;
8095 {
8096 /* If we used it already as memory, it must stay in memory. */
8100 }
8105 /* Compute and store the initial value. */
8110 /* Generate a cleanup, if necessary. */
8113 /* Perform the initialization. */
8115 {
8120 {
8121 /* Stick simple initializers in DECL_INITIAL so that
8122 -Wno-init-self works (c++/34772). */
8126 {
8130 OPT_Winit_self,
8132 }
8133 }
8134 else
8135 {
8138 /* If we're only initializing a single object, guard the
8139 destructors of any temporaries used in its initializer with
8140 its destructor. */
8149 saved_stmts_are_full_exprs_p;
8150 }
8151 }
8153 /* Set this to 0 so we can tell whether an aggregate which was
8154 initialized was ever used. Don't do this if it has a
8155 destructor, so we don't complain about the 'resource
8156 allocation is initialization' idiom. Now set
8157 attribute((unused)) on types so decls of that type will be
8158 marked used. (see TREE_USED, above.) */
8160 && ! already_used
8169 }
8171 /* DECL is a VAR_DECL for a compiler-generated variable with static
8172 storage duration (like a virtual table) whose initializer is a
8173 compile-time constant. Initialize the variable and provide it to the
8174 back end. */
8176 void
8178 {
8179 tree init;
8185 /* Mark the decl as constexpr so that we can access its content
8186 at compile time. */
8193 }
8195 /* INIT is the initializer for a variable, as represented by the
8196 parser. Returns true iff INIT is value-dependent. */
8198 static bool
8200 {
8202 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
8205 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
8206 {
8219 }
8220 else
8221 /* It must be a simple expression, e.g., int i = 3; */
8225 }
8227 // Returns true if a DECL is VAR_DECL with the concept specifier.
8230 {
8232 // Not all variables have DECL_LANG_SPECIFIC.
8235 }
8237 /* A helper function to be called via walk_tree. If any label exists
8238 under *TP, it is (going to be) forced. Set has_forced_label_in_static. */
8240 static tree
8242 {
8248 }
8250 /* Return true if DECL has either a trivial destructor, or for C++20
8251 is constexpr and has a constexpr destructor. */
8253 static bool
8255 {
8261 }
8265 /* Helper function of omp_declare_variant_finalize. Finalize one
8266 "omp declare variant base" attribute. Return true if it should be
8267 removed. */
8269 static bool
8271 {
8273 {
8278 }
8282 OMP_TRAIT_CONSTRUCT_SIMD);
8284 {
8288 /* FIXME, adjusting simd args unimplemented. */
8290 }
8293 location_t varid_loc
8302 releasing_vec args;
8311 else
8316 {
8318 /* In C++20, we may need to perform ADL for a template
8319 name. */
8322 {
8324 {
8328 tf_warning_or_error);
8329 }
8330 else
8332 }
8334 {
8340 {
8344 tf_warning_or_error);
8345 }
8346 }
8347 }
8352 else
8362 {
8365 {
8369 }
8374 {
8377 }
8378 else
8379 {
8380 tree construct
8386 }
8387 }
8389 {
8392 }
8395 }
8397 /* Helper function, finish up "omp declare variant base" attribute
8398 now that there is a DECL. ATTR is the first "omp declare variant base"
8399 attribute. */
8401 void
8403 {
8413 {
8416 }
8418 {
8421 }
8423 {
8426 }
8428 {
8431 }
8433 {
8436 }
8437 /* This loop is like private_lookup_attribute, except that it works
8438 with tree * rather than tree, as we might want to remove the
8439 attributes that are diagnosed as errorneous. */
8441 {
8446 {
8448 {
8451 }
8452 }
8454 }
8455 }
8459 /* Finish processing of a declaration;
8460 install its line number and initial value.
8461 If the length of an array type is not known before,
8462 it must be determined now, from the initial value, or it is an error.
8464 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
8465 true, then INIT is an integral constant expression.
8467 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
8468 if the (init) syntax was used.
8470 DECOMP is first identifier's DECL and identifier count in a structured
8471 bindings, nullptr if not a structured binding. */
8473 void
8476 {
8481 tree auto_node;
8486 {
8490 }
8493 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
8503 /* Warn about register storage specifiers except when in GNU global
8504 or local register variable extension. */
8506 {
8509 "ISO C++17 does not allow %<register%> storage "
8511 else
8514 }
8516 /* If a name was specified, get the string. */
8522 bool in_class_decl
8523 = (current_class_type
8534 {
8535 tree d_init;
8537 {
8541 {
8542 /* init is null because we're deferring instantiating the
8543 initializer until we need it. Well, we need it now. */
8546 }
8550 else
8551 {
8552 /* Ordinary auto deduction without an initializer, a situation
8553 which grokdeclarator already detects and rejects for the most
8554 part. But we can still get here if we're instantiating a
8555 variable template before we've fully parsed (and attached) its
8556 initializer, e.g. template<class> auto x = x<int>; */
8561 }
8562 }
8565 {
8569 tf_warning_or_error);
8571 /* Force auto deduction now. Use tf_none to avoid redundant warnings
8572 on deprecated-14.C. */
8574 }
8583 /* The outer template arguments might be needed for satisfaction.
8584 (For function scope variables, do_auto_deduction will obtain the
8585 outer template arguments from current_function_decl.) */
8593 {
8598 }
8599 /* As in start_decl_1, complete so TREE_READONLY is set properly. */
8603 {
8609 }
8612 /* Update the type of the corresponding TEMPLATE_DECL to match. */
8617 }
8620 {
8623 {
8626 }
8627 }
8637 {
8639 ? TCTX_THREAD_STORAGE
8642 }
8645 {
8646 tree clone;
8650 {
8651 /* FIXME check this is 1st decl. */
8657 {
8661 }
8663 }
8665 {
8668 else
8670 }
8671 }
8674 {
8676 /* If DECL is a reference, then we want to know whether init is a
8677 reference constant; init_const_expr_p as passed tells us whether
8678 it's an rvalue constant. */
8682 {
8683 /* Set these flags now for templates. We'll update the flags in
8684 store_init_value for instantiations. */
8687 /* FIXME setting TREE_CONSTANT on refs breaks the back end. */
8690 }
8691 /* This is handled mostly by gimplify.cc, but we have to deal with
8692 not warning about int x = x; as it is a GCC extension to turn off
8693 this warning but only if warn_init_self is zero. */
8699 }
8705 /* We have no initializer but there's nothing to initialize anyway.
8706 Treat DECL as constant due to c++/109876. */
8711 /* #pragma omp declare variant on methods handled in finish_struct
8712 instead. */
8720 {
8723 /* Add this declaration to the statement-tree. */
8730 {
8733 }
8735 /* Generally, initializers in templates are expanded when the
8736 template is instantiated. But, if DECL is a variable constant
8737 then it can be used in future constant expressions, so its value
8738 must be available. */
8745 {
8748 }
8754 {
8755 /* This variable seems to be a non-dependent constant, so process
8756 its initializer. If check_initializer returns non-null the
8757 initialization wasn't constant after all. */
8758 tree init_code;
8764 }
8765 else
8766 {
8768 /* Try to deduce array size. */
8770 /* And complain about multiple initializers. */
8774 tf_warning_or_error);
8775 }
8781 {
8784 }
8787 {
8790 }
8792 }
8794 /* Just store non-static data member initializers for later. */
8798 /* Take care of TYPE_DECLs up front. */
8800 {
8803 {
8807 }
8809 /* If we have installed this as the canonical typedef for this
8810 type, and that type has not been defined yet, delay emitting
8811 the debug information for it, as we will emit it later. */
8817 at_eof);
8819 }
8821 /* A reference will be modified here, as it is initialized. */
8825 {
8828 }
8830 /* This needs to happen before extend_ref_init_temps. */
8832 {
8836 }
8839 {
8841 /* [dcl.constinit]/1 "The constinit specifier shall be applied
8842 only to a declaration of a variable with static or thread storage
8843 duration." */
8846 {
8848 "%<constinit%> can only be applied to a variable with "
8851 }
8856 /* If this is a local variable that will need a mangled name,
8857 register it now. We must do this before processing the
8858 initializer for the variable, since the initialization might
8859 require a guard variable, and since the mangled name of the
8860 guard variable will depend on the mangled name of this
8861 variable. */
8865 {
8866 /* The variable holding an anonymous union will have had its
8867 discriminator set in finish_anon_union, after which it's
8868 NAME will have been cleared. */
8871 /* Normally has_forced_label_in_static is set during GIMPLE
8872 lowering, but [cd]tors are never actually compiled directly.
8873 We need to set this early so we can deal with the label
8874 address extension. */
8878 {
8881 }
8882 /* And make sure it's in the symbol table for
8883 c_parse_final_cleanups to find. */
8885 }
8887 /* Convert the initializer to the type of DECL, if we have not
8888 already initialized DECL. */
8890 /* If !DECL_EXTERNAL then DECL is being defined. In the
8891 case of a static data member initialized inside the
8892 class-specifier, there can be an initializer even if DECL
8893 is *not* defined. */
8895 {
8899 /* Handle:
8901 [dcl.init]
8903 The memory occupied by any object of static storage
8904 duration is zero-initialized at program startup before
8905 any other initialization takes place.
8907 We cannot create an appropriate initializer until after
8908 the type of DECL is finalized. If DECL_INITIAL is set,
8909 then the DECL is statically initialized, and any
8910 necessary zero-initialization has already been performed. */
8915 /* Remember that the initialization for this variable has
8916 taken place. */
8918 /* This declaration is the definition of this variable,
8919 unless we are initializing a static data member within
8920 the class specifier. */
8923 }
8924 /* If the variable has an array type, lay out the type, even if
8925 there is no initializer. It is valid to index through the
8926 array, and we must get TYPE_ALIGN set correctly on the array
8927 type. */
8934 /* So decl is a global variable or a static member of a
8935 non local class. Record the types it uses
8936 so that we can decide later to emit debug info for them. */
8938 }
8940 /* Add this declaration to the statement-tree. This needs to happen
8941 after the call to check_initializer so that the DECL_EXPR for a
8942 reference temp is added before the DECL_EXPR for the reference itself. */
8944 {
8945 /* If we're building a variable sized type, and we might be
8946 reachable other than via the top of the current binding
8947 level, then create a new BIND_EXPR so that we deallocate
8948 the object at the right time. */
8953 {
8954 tree bind;
8959 }
8961 }
8963 /* Let the middle end know about variables and functions -- but not
8964 static data members in uninstantiated class templates. */
8966 {
8968 {
8971 /* Check again now that we have an initializer. */
8973 /* A class-scope constexpr variable with an out-of-class declaration.
8974 C++17 makes them implicitly inline, but still force it out. */
8980 }
8983 /* With -fmerge-all-constants, gimplify_init_constructor
8984 might add TREE_STATIC to aggregate variables. */
8988 {
8989 /* If a TREE_READONLY variable needs initialization
8990 at runtime, it is no longer readonly and we need to
8991 avoid MEM_READONLY_P being set on RTL created for it. */
8993 {
8997 }
9001 /* Likewise if it needs destruction. */
9004 }
9010 {
9011 /* TLS variables need dynamic initialization by the TLS wrapper
9012 function, we don't want to hoist accesses to it before the
9013 wrapper. */
9016 }
9020 /* Check for abstractness of the type. */
9025 /* No initialization required. */
9026 ;
9028 {
9030 {
9032 {
9033 /* An out-of-class default definition is defined at
9034 the point where it is explicitly defaulted. */
9039 }
9040 else
9044 decl);
9045 }
9046 /* else no initialization required. */
9047 }
9051 {
9052 /* check_initializer will have done any constant initialization. */
9053 }
9054 /* A variable definition. */
9056 /* Initialize the local variable. */
9059 /* If a variable is defined, and then a subsequent
9060 definition with external linkage is encountered, we will
9061 get here twice for the same variable. We want to avoid
9062 calling expand_static_init more than once. For variables
9063 that are not static data members, we can call
9064 expand_static_init only when we actually process the
9065 initializer. It is not legal to redeclare a static data
9066 member, so this issue does not arise in that case. */
9069 }
9071 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
9072 reference, insert it in the statement-tree now. */
9074 {
9076 {
9078 /* As in initialize_local_var. */
9080 }
9082 }
9091 {
9097 {
9103 }
9108 {
9114 {
9117 {
9121 }
9122 }
9123 }
9124 }
9126 /* This is the last point we can lower alignment so give the target the
9127 chance to do so. */
9134 }
9136 /* For class TYPE return itself or some its bases that contain
9137 any direct non-static data members. Return error_mark_node if an
9138 error has been diagnosed. */
9140 static tree
9142 {
9152 {
9156 else
9161 }
9163 {
9171 }
9172 else
9182 {
9187 {
9189 {
9194 }
9198 {
9200 "classes %qT and %qT have non-static data "
9203 }
9204 else
9206 }
9207 }
9209 }
9211 /* Return std::tuple_size<TYPE>::value. */
9213 static tree
9215 {
9221 tf_none);
9235 else
9237 }
9239 /* Return std::tuple_element<I,TYPE>::type. */
9241 static tree
9243 {
9250 tf_warning_or_error);
9253 }
9255 /* Return e.get<i>() or get<i>(e). */
9257 static tree
9259 {
9266 /* [The id-expression] e is an lvalue if the type of the entity e is an
9267 lvalue reference and an xvalue otherwise. */
9276 /* To use a member get, member lookup must find at least one
9277 declaration that is a function template
9278 whose first template parameter is a non-type parameter. */
9280 {
9283 {
9287 {
9290 }
9291 }
9292 }
9295 {
9300 }
9301 else
9302 {
9308 }
9309 }
9311 /* It's impossible to recover the decltype of a tuple decomposition variable
9312 based on the actual type of the variable, so store it in a hash table. */
9316 tree
9318 {
9322 }
9324 /* Mangle a decomposition declaration if needed. Arguments like
9325 in cp_finish_decomp. */
9327 static void
9329 {
9333 {
9340 {
9349 {
9354 }
9357 }
9360 }
9361 }
9363 /* Finish a decomposition declaration. DECL is the underlying declaration
9364 "e", FIRST is the head of a chain of decls for the individual identifiers
9365 chained through DECL_CHAIN in reverse order and COUNT is the number of
9366 those decls. */
9368 void
9370 {
9374 {
9375 error_out:
9377 {
9380 {
9383 }
9385 }
9389 }
9393 /* This happens for range for when not in templates.
9394 Still add the DECL_VALUE_EXPRs for later processing. */
9395 || (!processing_template_decl
9397 {
9399 {
9401 {
9407 }
9411 }
9413 }
9419 {
9422 }
9428 {
9434 {
9436 type);
9438 }
9439 }
9444 {
9445 tree nelts;
9450 {
9454 }
9456 {
9459 }
9462 {
9463 cnt_mismatch:
9468 else
9477 }
9480 {
9489 }
9490 }
9491 /* 2 GNU extensions. */
9493 {
9499 {
9508 }
9509 }
9511 {
9513 {
9516 }
9521 {
9532 }
9533 }
9535 {
9537 {
9541 }
9543 {
9550 }
9555 {
9556 /* For structured bindings used in conditions we need to evaluate
9557 the conversion of decl (aka e in the standard) to bool or
9558 integral/enumeral type (the latter for switch conditions)
9559 before the get methods. */
9562 /* switch condition. */
9565 else
9566 /* if/while/for condition. */
9569 {
9570 /* Wrap that value into a TARGET_EXPR, emit it right
9571 away and save for later uses in the cp_parse_condition
9572 or its instantiation. */
9576 }
9577 }
9580 {
9591 {
9595 }
9597 {
9601 }
9602 /* Save the decltype away before reference collapse. */
9608 {
9609 /* In this case the names are variables, not just proxies. */
9612 }
9614 {
9618 }
9619 }
9620 /* Ignore reads from the underlying decl performed during initialization
9621 of the individual variables. If those will be read, we'll mark
9622 the underlying decl as read at that point. */
9624 }
9626 {
9629 }
9631 {
9634 }
9636 {
9639 }
9644 type);
9645 else
9646 {
9651 {
9655 }
9661 else
9662 eltscnt++;
9667 {
9671 }
9678 else
9679 {
9681 NULL_TREE);
9687 {
9690 }
9691 i++;
9692 }
9693 }
9695 {
9698 {
9703 }
9704 }
9705 }
9707 /* Returns a declaration for a VAR_DECL as if:
9709 extern "C" TYPE NAME;
9711 had been seen. Used to create compiler-generated global
9712 variables. */
9714 static tree
9716 {
9723 /* If the user has explicitly declared this variable (perhaps
9724 because the code we are compiling is part of a low-level runtime
9725 library), then it is possible that our declaration will be merged
9726 with theirs by pushdecl. */
9732 }
9734 /* Returns the type for the argument to "atexit" corresponding to the function
9735 to be called when the program exits. */
9737 static tree
9739 {
9741 {
9744 }
9747 }
9749 /* Returns the type for the argument to "__cxa_atexit", "__cxa_thread_atexit"
9750 or "__cxa_throw" corresponding to the destructor to be called when the
9751 program exits. */
9753 tree
9755 {
9757 {
9762 }
9765 }
9767 /* Returns a pointer to the `atexit' function. Note that if
9768 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
9769 `__cxa_atexit' function specified in the IA64 C++ ABI. */
9771 static tree
9773 {
9774 tree atexit_fndecl;
9775 tree fn_type;
9776 tree fn_ptr_type;
9785 {
9786 /* The declaration for `__cxa_atexit' is:
9788 int __cxa_atexit (void (*)(void *), void *, void *)
9790 We build up the argument types and then the function type
9791 itself. */
9795 /* First, build the pointer-to-function type for the first
9796 argument. */
9798 /* Then, build the rest of the argument types. */
9801 {
9804 }
9805 else
9806 {
9809 }
9810 /* And the final __cxa_atexit type. */
9813 NULL_TREE);
9814 /* ... which needs noexcept. */
9817 {
9825 }
9826 else
9827 {
9830 }
9831 }
9832 else
9833 {
9834 /* The declaration for `atexit' is:
9836 int atexit (void (*)());
9838 We build up the argument types and then the function type
9839 itself. */
9841 /* Build the final atexit type. */
9844 /* ... which needs noexcept. */
9847 }
9849 /* Now, build the function declaration. */
9854 /* Install as hidden builtin so we're (a) more relaxed about
9855 exception spec matching and (b) will not give a confusing location
9856 in diagnostic and (c) won't magically appear in user-visible name
9857 lookups. */
9866 }
9868 /* Like get_atexit_node, but for thread-local cleanups. */
9870 static tree
9872 {
9876 /* The declaration for `__cxa_thread_atexit' is:
9878 int __cxa_thread_atexit (void (*)(void *), void *, void *) */
9882 NULL_TREE);
9884 /* Now, build the function declaration, as with __cxa_atexit. */
9896 }
9898 /* Returns the __dso_handle VAR_DECL. */
9900 static tree
9902 {
9906 /* Declare the variable. */
9908 ptr_type_node);
9910 #ifdef HAVE_GAS_HIDDEN
9912 {
9915 }
9916 #endif
9919 }
9921 /* Begin a new function with internal linkage whose job will be simply
9922 to destroy some particular variable. OB_PARM is true if object pointer
9923 is passed to the cleanup function, otherwise no argument is passed. */
9927 static tree
9929 {
9934 /* No need to mangle this. */
9937 /* Build the name of the function. */
9941 /* Build the function declaration. */
9944 /* It's a function with internal linkage, generated by the
9945 compiler. */
9948 /* Make the function `inline' so that it is only emitted if it is
9949 actually needed. It is unlikely that it will be inlined, since
9950 it is only called via a function pointer, but we avoid unnecessary
9951 emissions this way. */
9955 {
9956 /* Build the parameter. */
9961 }
9969 }
9971 /* Finish the cleanup function begun by start_cleanup_fn. */
9973 static void
9975 {
9979 }
9981 /* Generate code to handle the destruction of DECL, an object with
9982 static storage duration. */
9984 tree
9986 {
9987 tree cleanup;
9988 tree addr;
9989 tree compound_stmt;
9990 tree fcall;
9991 tree type;
9994 tree atex_node;
10002 {
10005 }
10007 /* If we're using "__cxa_atexit" (or "__cxa_thread_atexit" or
10008 "__aeabi_atexit"), and DECL is a class object, we can just pass the
10009 destructor to "__cxa_atexit"; we don't have to build a temporary
10010 function to do the cleanup. */
10011 dso_parm = (flag_use_cxa_atexit
10016 {
10019 /* Make sure it is accessible. */
10021 tf_warning_or_error);
10022 }
10023 else
10024 {
10025 /* Call build_cleanup before we enter the anonymous function so
10026 that any access checks will be done relative to the current
10027 scope, rather than the scope of the anonymous function. */
10030 /* Now start the function. */
10033 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
10034 to the original function, rather than the anonymous one. That
10035 will make the back end think that nested functions are in use,
10036 which causes confusion. */
10041 /* Create the body of the anonymous function. */
10046 }
10048 /* Call atexit with the cleanup function. */
10054 else
10058 {
10059 /* We must convert CLEANUP to the type that "__cxa_atexit"
10060 expects. */
10062 /* "__cxa_atexit" will pass the address of DECL to the
10063 cleanup function. */
10066 /* The declared type of the parameter to "__cxa_atexit" is
10067 "void *". For plain "T*", we could just let the
10068 machinery in cp_build_function_call convert it -- but if the
10069 type is "cv-qualified T *", then we need to convert it
10070 before passing it in, to avoid spurious errors. */
10072 }
10073 else
10074 /* Since the cleanup functions we build ignore the address
10075 they're given, there's no reason to pass the actual address
10076 in, and, in general, it's cheaper to pass NULL than any
10077 other value. */
10082 tf_warning_or_error);
10084 /* Just pass NULL to the dso handle parm if we don't actually
10085 have a DSO handle on this target. */
10087 else
10091 {
10094 {
10097 }
10098 else
10099 {
10102 }
10103 }
10104 else
10105 {
10108 }
10111 }
10113 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
10114 is its initializer. Generate code to handle the construction
10115 and destruction of DECL. */
10117 static void
10119 {
10123 /* Some variables require no dynamic initialization. */
10125 {
10126 /* Make sure the destructor is callable. */
10130 }
10134 {
10139 else
10144 {
10148 }
10150 }
10153 {
10154 /* Emit code to perform this initialization but once. */
10159 /* We don't need thread-safety code for thread-local vars. */
10163 /* Emit code to perform this initialization but once. This code
10164 looks like:
10166 static <type> guard;
10167 if (!__atomic_load (guard.first_byte)) {
10168 if (__cxa_guard_acquire (&guard)) {
10169 bool flag = false;
10170 try {
10171 // Do initialization.
10172 flag = true; __cxa_guard_release (&guard);
10173 // Register variable for destruction at end of program.
10174 } catch {
10175 if (!flag) __cxa_guard_abort (&guard);
10176 }
10177 }
10178 }
10180 Note that the `flag' variable is only set to 1 *after* the
10181 initialization is complete. This ensures that an exception,
10182 thrown during the construction, will cause the variable to
10183 reinitialized when we pass through this code again, as per:
10185 [stmt.dcl]
10187 If the initialization exits by throwing an exception, the
10188 initialization is not complete, so it will be tried again
10189 the next time control enters the declaration.
10191 This process should be thread-safe, too; multiple threads
10192 should not be able to initialize the variable more than
10193 once. */
10195 /* Create the guard variable. */
10198 /* Begin the conditional initialization. */
10205 {
10218 acquire_fn = push_library_fn
10221 NULL_TREE),
10226 NULL_TREE);
10229 ECF_NOTHROW);
10236 inner_if_stmt);
10244 void_node,
10248 /* Do the initialization itself. */
10254 /* Use atexit to register a function for destroying this static
10255 variable. Do this before calling __cxa_guard_release. */
10259 guard_addr));
10260 }
10261 else
10262 {
10265 /* Use atexit to register a function for destroying this static
10266 variable. */
10268 }
10273 {
10277 }
10282 }
10285 else
10287 }
10289 \f
10290 /* Make TYPE a complete type based on INITIAL_VALUE.
10291 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
10292 2 if there was no information (in which case assume 0 if DO_DEFAULT),
10293 3 if the initializer list is empty (in pedantic mode). */
10295 int
10297 {
10301 /* Don't get confused by a CONSTRUCTOR for some other type. */
10308 {
10309 /* An array of character type can be initialized from a
10310 brace-enclosed string constant so call reshape_init to
10311 remove the optional braces from a braced string literal. */
10315 tf_warning_or_error);
10317 /* If any of the elements are parameter packs, we can't actually
10318 complete this type now because the array size is dependent. */
10323 }
10327 /* We can create the array before the element type is complete, which
10328 means that we didn't have these two bits set in the original type
10329 either. In completing the type, we are expected to propagate these
10330 bits. See also complete_type which does the same thing for arrays
10331 of fixed size. */
10334 {
10339 }
10342 }
10344 /* As above, but either give an error or reject zero-size arrays, depending
10345 on COMPLAIN. */
10347 int
10350 {
10353 /* In SFINAE context we can't be lenient about zero-size arrays. */
10360 {
10366 {
10369 }
10373 }
10375 }
10376 \f
10377 /* Return zero if something is declared to be a member of type
10378 CTYPE when in the context of CUR_TYPE. STRING is the error
10379 message to print in that case. Otherwise, quietly return 1. */
10381 static int
10383 {
10385 {
10388 else
10391 }
10393 }
10394 \f
10395 /* Subroutine of `grokdeclarator'. */
10397 /* Generate errors possibly applicable for a given set of specifiers.
10398 This is for ARM $7.1.2. */
10400 static void
10409 {
10411 {
10455 }
10459 && !flag_noexcept_type
10465 }
10467 /* DECL is a member function or static data member and is presently
10468 being defined. Check that the definition is taking place in a
10469 valid namespace. */
10471 static void
10473 {
10474 /* These checks only apply to member functions and static data
10475 members. */
10477 /* We check for problems with specializations in pt.cc in
10478 check_specialization_namespace, where we can issue better
10479 diagnostics. */
10482 /* We check this in check_explicit_instantiation_namespace. */
10485 /* [class.mfct]
10487 A member function definition that appears outside of the
10488 class definition shall appear in a namespace scope enclosing
10489 the class definition.
10491 [class.static.data]
10493 The definition for a static data member shall appear in a
10494 namespace scope enclosing the member's class definition. */
10498 }
10500 /* Build a PARM_DECL for the "this" parameter of FN. TYPE is the
10501 METHOD_TYPE for a non-static member function; QUALS are the
10502 cv-qualifiers that apply to the function. */
10504 tree
10506 {
10507 tree this_type;
10508 tree qual_type;
10509 tree parm;
10510 cp_cv_quals this_quals;
10513 {
10514 this_type
10517 }
10518 else
10520 /* The `this' parameter is implicitly `const'; it cannot be
10521 assigned to. */
10527 }
10529 /* DECL is a static member function. Complain if it was declared
10530 with function-cv-quals. */
10532 static void
10534 {
10537 decl);
10538 }
10540 // Check that FN takes no arguments and returns bool.
10541 static void
10543 {
10544 // A constraint is nullary.
10549 // The declared return type of the concept shall be bool, and
10550 // it shall not be deduced from it definition.
10558 }
10560 /* Helper function. Replace the temporary this parameter injected
10561 during cp_finish_omp_declare_simd with the real this parameter. */
10563 static tree
10565 {
10574 }
10576 /* CTYPE is class type, or null if non-class.
10577 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
10578 or METHOD_TYPE.
10579 DECLARATOR is the function's name.
10580 PARMS is a chain of PARM_DECLs for the function.
10581 VIRTUALP is truthvalue of whether the function is virtual or not.
10582 FLAGS are to be passed through to `grokclassfn'.
10583 QUALS are qualifiers indicating whether the function is `const'
10584 or `volatile'.
10585 RAISES is a list of exceptions that this function can raise.
10586 CHECK is 1 if we must find this method in CTYPE, 0 if we should
10587 not look, and -1 if we should not call `grokclassfn' at all.
10589 SFK is the kind of special function (if any) for the new function.
10591 Returns `NULL_TREE' if something goes wrong, after issuing
10592 applicable error messages. */
10594 static tree
10596 tree type,
10597 tree declarator,
10598 tree parms,
10599 tree orig_declarator,
10601 tree decl_reqs,
10604 cp_cv_quals quals,
10605 cp_ref_qualifier rqual,
10606 tree raises,
10613 special_function_kind sfk,
10617 tree in_namespace,
10619 location_t location)
10620 {
10621 tree decl;
10622 tree t;
10627 /* Was the concept specifier present? */
10630 /* Concept declarations must have a corresponding definition. */
10632 {
10635 }
10641 /* Set the constraints on the declaration. */
10643 {
10648 && (current_template_depth
10651 {
10653 /* If there are no template parameters, something must have
10654 gone wrong. */
10656 else
10658 }
10661 {
10664 }
10665 /* C++20 CA378: Remove non-templated constrained functions. */
10666 /* [temp.friend]/9 A non-template friend declaration with a
10667 requires-clause shall be a definition. A friend function template with
10668 a constraint that depends on a template parameter from an enclosing
10669 template shall be a definition. */
10671 && (block_local
10672 || !processing_template_decl
10674 {
10677 else
10681 }
10687 }
10690 {
10695 /* Allocate space to hold the vptr bit if needed. */
10697 }
10703 /* Propagate volatile out from type to decl. */
10707 /* Setup decl according to sfk. */
10709 {
10721 /* Give deduction guides a definition even though they don't really
10722 have one: the restriction that you can't repeat a deduction guide
10723 makes them more like a definition anyway. */
10728 }
10731 {
10735 orig_declarator);
10736 else
10737 {
10742 {
10743 /* Something like `template <class T> friend void f<T>()'. */
10745 "invalid use of template-id %qD in declaration "
10747 orig_declarator);
10749 }
10751 /* A friend declaration of the form friend void f<>(). Record
10752 the information in the TEMPLATE_ID_EXPR. */
10761 {
10763 "default arguments are not allowed in declaration "
10765 decl);
10767 }
10770 {
10772 "%<inline%> is not allowed in declaration of friend "
10774 decl);
10776 }
10777 }
10778 }
10780 /* C++17 11.3.6/4: "If a friend declaration specifies a default argument
10781 expression, that declaration shall be a definition..." */
10783 {
10787 {
10789 "friend declaration of %qD specifies default "
10792 }
10793 }
10795 /* If this decl has namespace scope, set that up. */
10800 else
10803 /* `main' and builtins have implicit 'C' linkage. */
10829 {
10850 }
10852 /* Members of anonymous types and local classes have no linkage; make
10853 them internal. If a typedef is made later, this will be changed. */
10857 /* But members of local classes in a module CMI should have their
10858 definitions exported, in case they are (directly or indirectly)
10859 used by an importer. We don't just use module_has_cmi_p here
10860 because for entities in the GMF we don't yet know whether this
10861 module will have a CMI, so we'll conservatively assume it might. */
10865 {
10866 /* [basic.link]: A name with no linkage (notably, the name of a class
10867 or enumeration declared in a local scope) shall not be used to
10868 declare an entity with linkage.
10870 DR 757 relaxes this restriction for C++0x. */
10872 }
10876 {
10879 }
10881 /* If the declaration was declared inline, mark it as such. */
10883 {
10887 }
10891 {
10894 }
10896 // If the concept declaration specifier was found, check
10897 // that the declaration satisfies the necessary requirements.
10899 {
10902 }
10906 {
10909 TYPE_UNQUALIFIED,
10910 REF_QUAL_NONE);
10911 auto_diagnostic_group d;
10915 : !xobj_func_p
10919 decl);
10923 : !xobj_func_p
10927 decl);
10935 }
10938 {
10942 {
10947 }
10950 {
10954 }
10958 }
10963 {
10967 /* [over.literal]/6: Literal operators shall not have C linkage. */
10969 {
10973 }
10976 {
10979 {
10982 }
10986 {
10990 }
10992 {
10996 }
10997 /* 17.6.3.3.5 */
11001 "literal operator suffixes not preceded by %<_%>"
11003 }
11004 else
11005 {
11008 }
11009 }
11012 /* Make the init_value nonzero so pushdecl knows this is not
11013 tentative. error_mark_node is replaced later with the BLOCK. */
11020 {
11021 /* Adjust "omp declare simd" attributes. */
11024 {
11025 tree attr;
11028 {
11033 {
11035 cl = c_omp_declare_simd_clauses_to_numbers
11039 else
11041 }
11042 }
11043 }
11044 }
11046 /* Caller will do the rest of this. */
11053 /* 12.4/3 */
11063 template_count,
11075 {
11078 }
11083 /* Check main's type after attributes have been applied. */
11085 {
11087 integer_type_node))
11088 {
11090 tree newtype;
11095 }
11098 }
11101 {
11103 (current_template_depth
11105 ? current_template_parms
11112 {
11113 tree ok;
11114 tree pushed_scope;
11117 /* Because grokfndecl is always supposed to return a
11118 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
11119 here. We depend on our callers to figure out that its
11120 really a template that's being returned. */
11125 {
11126 /* Remove the `this' parm added by grokclassfn. */
11129 }
11131 {
11134 }
11136 {
11141 }
11143 /* Since we've smashed OLD_DECL to its
11144 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
11148 /* Attempt to merge the declarations. This can fail, in
11149 the case of some invalid specialization declarations. */
11155 {
11159 }
11163 }
11164 }
11176 }
11178 /* decl is a FUNCTION_DECL.
11179 specifiers are the parsed virt-specifiers.
11181 Set flags to reflect the virt-specifiers.
11183 Returns decl. */
11185 static tree
11187 {
11195 }
11197 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
11198 the linkage that DECL will receive in the object file. */
11200 static void
11202 {
11203 /* A static data member always has static storage duration and
11204 external linkage. Note that static data members are forbidden in
11205 local classes -- the only situation in which a class has
11206 non-external linkage. */
11209 /* For non-template classes, static data members are always put
11210 out in exactly those files where they are defined, just as
11211 with ordinary namespace-scope variables. */
11214 }
11216 /* Create a VAR_DECL named NAME with the indicated TYPE.
11218 If SCOPE is non-NULL, it is the class type or namespace containing
11219 the variable. If SCOPE is NULL, the variable should is created in
11220 the innermost enclosing scope. */
11222 static tree
11224 tree name,
11225 tree orig_declarator,
11232 tree scope,
11233 location_t location)
11234 {
11235 tree decl;
11236 tree explicit_scope;
11243 /* Compute the scope in which to place the variable, but remember
11244 whether or not that scope was explicitly specified by the user. */
11247 {
11248 /* An explicit "extern" specifier indicates a namespace-scope
11249 variable. */
11254 }
11258 template, we need DECL_LANG_SPECIFIC. */
11260 /* Similarly for namespace-scope variables with language linkage
11261 other than C++. */
11264 /* Similarly for static data members. */
11266 /* Similarly for explicit specializations. */
11267 || (orig_declarator
11270 else
11275 else
11279 {
11282 }
11285 {
11287 /* This function is only called with out-of-class definitions. */
11290 }
11291 /* At top level, either `static' or no s.c. makes a definition
11292 (perhaps tentative), and absence of `static' makes it public. */
11294 {
11297 || ! constp
11298 || volatilep
11299 || inlinep
11302 }
11303 /* Not at top level, only `static' makes a static definition. */
11304 else
11305 {
11308 }
11313 {
11315 {
11319 }
11322 }
11324 /* If the type of the decl has no linkage, make sure that we'll
11325 notice that in mark_used. */
11334 {
11335 /* [basic.link]: A name with no linkage (notably, the name of a class
11336 or enumeration declared in a local scope) shall not be used to
11337 declare an entity with linkage.
11339 DR 757 relaxes this restriction for C++0x. */
11342 }
11343 else
11348 {
11354 "an entity named %<main%> cannot be declared with "
11356 }
11358 /* Check that the variable can be safely declared as a concept.
11359 Note that this also forbids explicit specializations. */
11361 {
11363 {
11367 }
11369 {
11373 }
11374 else
11377 {
11380 }
11381 }
11384 {
11387 }
11389 // Handle explicit specializations and instantiations of variable templates.
11395 }
11397 /* Create and return a canonical pointer to member function type, for
11398 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
11400 tree
11402 {
11404 tree t;
11409 /* Make sure that we always have the unqualified pointer-to-member
11410 type first. */
11412 {
11415 }
11417 /* If a canonical type already exists for this type, use it. We use
11418 this method instead of type_hash_canon, because it only does a
11419 simple equality check on the list of field members. */
11427 /* Let the front end know this is a pointer to member function. */
11435 delta_type_node);
11442 /* Zap out the name so that the back end will give us the debugging
11443 information for this anonymous RECORD_TYPE. */
11446 /* Cache this pointer-to-member type so that we can find it again
11447 later. */
11456 }
11458 /* Create and return a pointer to data member type. */
11460 tree
11462 {
11464 {
11469 }
11470 else
11471 {
11474 }
11475 }
11477 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
11478 Check to see that the definition is valid. Issue appropriate error
11479 messages. */
11481 static void
11483 {
11484 /* Avoid redundant diagnostics on out-of-class definitions. */
11486 ;
11487 /* Can't check yet if we don't know the type. */
11489 ;
11490 /* If DECL is declared constexpr, we'll do the appropriate checks
11491 in check_initializer. Similarly for inline static data members. */
11495 ;
11497 {
11500 "in-class initialization of static data member %q#D of "
11504 "%<constexpr%> needed for in-class initialization of "
11506 else
11508 "in-class initialization of static data member %q#D of "
11510 }
11511 /* Motion 10 at San Diego: If a static const integral data member is
11512 initialized with an integral constant expression, the initializer
11513 may appear either in the declaration (within the class), or in
11514 the definition, but not both. If it appears in the class, the
11515 member is a member constant. The file-scope definition is always
11516 required. */
11519 "invalid in-class initialization of static data member "
11521 type);
11524 "ISO C++ forbids in-class initialization of non-const "
11526 decl);
11529 "ISO C++ forbids initialization of member constant "
11531 }
11533 /* *expr_p is part of the TYPE_SIZE of a variably-sized array. If any
11534 SAVE_EXPRs in *expr_p wrap expressions with side-effects, break those
11535 expressions out into temporary variables so that walk_tree doesn't
11536 step into them (c++/15764). */
11538 static tree
11540 {
11544 {
11550 }
11554 }
11556 /* Entry point for the above. */
11558 static void
11560 {
11562 /* Break out any function calls into temporary variables. */
11564 }
11566 /* Reduce a SIZEOF_EXPR to its value. */
11568 tree
11570 {
11571 tree r;
11580 else
11587 }
11589 /* Given the SIZE (i.e., number of elements) in an array, compute
11590 an appropriate index type for the array. If non-NULL, NAME is
11591 the name of the entity being declared. */
11593 static tree
11595 tsubst_flags_t complain)
11596 {
11600 /* The type of the index being computed. */
11601 tree itype;
11603 /* The original numeric size as seen in the source code before
11604 conversion to size_t. */
11610 {
11615 /* In C++98, we mark a non-constant array bound with a magic
11617 else
11618 {
11620 /* Pedantically a constant expression is required here and so
11621 __builtin_is_constant_evaluated () should fold to true if it
11622 is successfully folded into a constant. */
11628 }
11633 /* The array bound must be an integer type. */
11636 {
11642 else
11645 }
11646 }
11648 /* A type is dependent if it is...an array type constructed from any
11649 dependent type or whose size is specified by a constant expression
11650 that is value-dependent. */
11651 /* We can only call value_dependent_expression_p on integral constant
11652 expressions. */
11656 {
11657 /* Just build the index type and mark that it requires
11658 structural equality checks. */
11659 in_template:
11666 }
11669 {
11672 {
11676 else
11679 }
11681 /* We might have lost the TREE_CONSTANT flag e.g. when we are
11682 folding a conversion from a pointer to integral type. In that
11684 else
11685 /* Use the folded result for VLAs, too; it will have resolved
11686 SIZEOF_EXPR. */
11688 }
11690 /* Normally, the array-bound will be a constant. */
11692 {
11693 /* The size to use in diagnostics that reflects the constant
11694 size used in the source, rather than SIZE massaged above. */
11697 /* If the original size before conversion to size_t was signed
11698 and negative, convert it to ssizetype to restore the sign. */
11702 {
11705 /* Clear the overflow bit that may have been set as a result
11706 of the conversion from the sizetype of the new size to
11707 ssizetype. */
11709 }
11711 /* Verify that the array has a positive number of elements
11712 and issue the appropriate diagnostic if it doesn't. */
11714 {
11718 }
11719 /* As an extension we allow zero-sized arrays. */
11721 {
11723 /* We must fail if performing argument deduction (as
11724 indicated by the state of complain), so that
11725 another substitution can be found. */
11730 else
11733 }
11734 }
11736 /* We don't allow VLAs at non-function scopes, or during
11737 tentative template substitution. */
11740 {
11743 /* `(int) &fn' is not a valid array bound. */
11747 name);
11748 else
11751 }
11753 {
11757 else
11760 }
11762 {
11766 else
11769 }
11773 else
11774 {
11776 {
11777 /* A variable sized array. Arrange for the SAVE_EXPR on the inside
11778 of the MINUS_EXPR, which allows the -1 to get folded with the +1
11779 that happens when building TYPE_SIZE. */
11782 }
11784 /* Compute the index of the largest element in the array. It is
11785 one less than the number of elements in the array. We save
11786 and restore PROCESSING_TEMPLATE_DECL so that computations in
11787 cp_build_binary_op will be appropriately folded. */
11788 {
11789 processing_template_decl_sentinel s;
11791 MINUS_EXPR,
11794 complain),
11795 complain);
11797 }
11800 {
11803 {
11804 /* We have to add 1 -- in the ubsan routine we generate
11805 LE_EXPR rather than LT_EXPR. */
11810 }
11811 }
11812 /* Make sure that there was no overflow when creating to a signed
11813 index type. (For example, on a 32-bit machine, an array with
11814 size 2^32 - 1 is too big.) */
11817 {
11822 }
11823 }
11825 /* Create and return the appropriate index type. */
11828 /* If the index type were dependent, we would have returned early, so
11829 remember that it isn't. */
11833 }
11835 tree
11837 {
11839 }
11841 /* Returns the scope (if any) in which the entity declared by
11842 DECLARATOR will be located. If the entity was declared with an
11843 unqualified name, NULL_TREE is returned. */
11845 tree
11847 {
11851 /* If the declarator-id is a SCOPE_REF, the scope in which the
11852 declaration occurs is the first operand. */
11857 /* Otherwise, the declarator is not a qualified name; the entity will
11858 be declared in the current scope. */
11860 }
11862 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
11863 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
11864 with this type. */
11866 static tree
11868 {
11871 /* If things have already gone awry, bail now. */
11875 /* [dcl.type.class.deduct] prohibits forming an array of placeholder
11876 for a deduced class type. */
11878 {
11882 else
11885 }
11887 /* If there are some types which cannot be array elements,
11888 issue an error-message and return. */
11890 {
11894 else
11901 else
11908 else
11915 name);
11916 else
11922 }
11928 /* [dcl.array]
11930 The constant expressions that specify the bounds of the arrays
11931 can be omitted only for the first member of the sequence. */
11933 {
11937 name);
11938 else
11943 }
11945 /* Figure out the index type for the array. */
11947 {
11949 tf_warning_or_error);
11952 {
11955 }
11956 }
11959 }
11961 /* Returns the smallest location that is not UNKNOWN_LOCATION. */
11963 static location_t
11965 {
11971 }
11973 /* Returns the smallest location != UNKNOWN_LOCATION among the
11974 three stored in LOCATIONS[ds_const], LOCATIONS[ds_volatile],
11975 and LOCATIONS[ds_restrict]. */
11977 static location_t
11979 {
11992 }
11994 /* Returns the smallest among the latter and locations[ds_type_spec]. */
11996 static location_t
11998 {
12001 }
12003 static location_t
12005 {
12008 }
12010 /* Check that it's OK to declare a function with the indicated TYPE
12011 and TYPE_QUALS. SFK indicates the kind of special function (if any)
12012 that this function is. OPTYPE is the type given in a conversion
12013 operator declaration, or the class type for a constructor/destructor.
12014 Returns the actual return type of the function; that may be different
12015 than TYPE if an error occurs, or for certain special functions. */
12017 static tree
12019 tree type,
12020 tree optype,
12023 {
12025 {
12036 else
12048 /* We can't use the proper return type here because we run into
12049 problems with ambiguous bases and covariant returns. */
12052 else
12062 "qualifiers are not allowed on declaration of "
12074 "qualifiers are not allowed on declaration of "
12077 {
12081 }
12082 else
12092 }
12095 }
12097 /* A variable or data member (whose unqualified name is IDENTIFIER)
12098 has been declared with the indicated TYPE. If the TYPE is not
12099 acceptable, issue an error message and return a type to use for
12100 error-recovery purposes. */
12102 tree
12104 {
12106 {
12110 {
12113 identifier);
12114 }
12115 else
12118 }
12121 }
12123 /* Handle declaring DECL as an inline variable. */
12125 static void
12127 {
12130 {
12134 }
12139 {
12142 }
12143 }
12146 /* Assign a typedef-given name to a class or enumeration type declared
12147 as anonymous at first. This was split out of grokdeclarator
12148 because it is also used in libcc1. */
12150 void
12152 {
12155 /* Replace the anonymous decl with the real decl. Be careful not to
12156 rename other typedefs (such as the self-reference) of type. */
12162 /* If this is a typedef within a template class, the nested
12163 type is a (non-primary) template. The name for the
12164 template needs updating as well. */
12168 /* Adjust linkage now that we aren't unnamed anymore. */
12171 /* FIXME remangle member functions; member functions of a
12172 type with external linkage have external linkage. */
12174 /* Check that our job is done, and that it would fail if we
12175 attempted to do it again. */
12177 }
12179 /* Check that decltype(auto) was well-formed: only plain decltype(auto)
12180 is allowed. TYPE might contain a decltype(auto). Returns true if
12181 there was a problem, false otherwise. */
12183 static bool
12185 {
12187 {
12189 {
12191 {
12195 }
12197 {
12200 }
12201 }
12202 }
12204 }
12206 /* Given declspecs and a declarator (abstract or otherwise), determine
12207 the name and type of the object declared and construct a DECL node
12208 for it.
12210 DECLSPECS points to the representation of declaration-specifier
12211 sequence that precedes declarator.
12213 DECL_CONTEXT says which syntactic context this declaration is in:
12214 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
12215 FUNCDEF for a function definition. Like NORMAL but a few different
12216 error messages in each case. Return value may be zero meaning
12217 this definition is too screwy to try to parse.
12218 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
12219 handle member functions (which have FIELD context).
12220 Return value may be zero meaning this definition is too screwy to
12221 try to parse.
12222 PARM for a parameter declaration (either within a function prototype
12223 or before a function body). Make a PARM_DECL, or return void_type_node.
12224 TPARM for a template parameter declaration.
12225 CATCHPARM for a parameter declaration before a catch clause.
12226 TYPENAME if for a typename (in a cast or sizeof).
12227 Don't make a DECL node; just return the ..._TYPE node.
12228 FIELD for a struct or union field; make a FIELD_DECL.
12229 BITFIELD for a field with specified width.
12231 INITIALIZED is as for start_decl.
12233 ATTRLIST is a pointer to the list of attributes, which may be NULL
12234 if there are none; *ATTRLIST may be modified if attributes from inside
12235 the declarator should be applied to the declaration.
12237 When this function is called, scoping variables (such as
12238 CURRENT_CLASS_TYPE) should reflect the scope in which the
12239 declaration occurs, not the scope in which the new declaration will
12240 be placed. For example, on:
12242 void S::f() { ... }
12244 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
12245 should not be `S'.
12247 Returns a DECL (if a declarator is present), a TYPE (if there is no
12248 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
12249 error occurs. */
12251 tree
12257 {
12270 /* True if this declarator is a function definition. */
12274 #if 0
12275 /* See the code below that used this. */
12277 #endif
12279 /* Keep track of what sort of function is being processed
12280 so that we can warn about default return values, or explicit
12281 return values which do not match prescribed defaults. */
12287 /* cv-qualifiers that apply to the declarator, for a declaration of
12288 a member function. */
12290 /* virt-specifiers that apply to the declarator, for a declaration of
12291 a member function. */
12293 /* ref-qualifier that applies to the declarator, for a declaration of
12294 a member function. */
12296 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
12303 /* The unqualified name of the declarator; either an
12304 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
12305 tree unqualified_id;
12306 /* The class type, if any, in which this entity is located,
12307 or NULL_TREE if none. Note that this value may be different from
12308 the current class type; for example if an attempt is made to declare
12309 "A::f" inside "B", this value will be "A". */
12311 /* The NAMESPACE_DECL for the namespace in which this entity is
12312 located. If an unqualified name is used to declare the entity,
12313 this value will be NULL_TREE, even if the entity is located at
12314 namespace scope. */
12316 cp_storage_class storage_class;
12339 // Was concept_p specified? Note that ds_concept
12340 // implies ds_constexpr!
12362 location_t id_loc;
12363 location_t init_loc;
12365 {
12368 }
12369 else
12372 /* Look inside a declarator for the name being declared
12373 and get it as a string, for an error message. */
12375 id_declarator;
12377 {
12382 {
12386 {
12390 }
12394 {
12400 {
12405 {
12406 /* [dcl.meaning]
12408 A declarator-id shall not be qualified except
12409 for ...
12411 None of the cases are permitted in block
12412 scope. */
12415 decl);
12419 else
12423 }
12425 {
12428 {
12432 }
12434 && current_class_type
12436 current_class_type))
12437 {
12442 }
12443 }
12446 }
12448 {
12450 {
12452 {
12456 }
12459 {
12463 }
12470 }
12474 {
12480 }
12481 /* Fall through. */
12488 {
12490 dname);
12492 }
12495 else
12496 {
12503 else
12505 }
12510 }
12512 }
12529 }
12532 }
12534 /* [dcl.fct.edf]
12536 The declarator in a function-definition shall have the form
12537 D1 ( parameter-declaration-clause) ... */
12539 {
12542 }
12547 {
12550 }
12553 {
12556 {
12559 }
12562 {
12564 {
12567 }
12569 {
12572 }
12573 }
12574 }
12576 /* Anything declared one level down from the top level
12577 must be one of the parameters of a function
12578 (because the body is at least two levels down). */
12580 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
12581 by not allowing C++ class definitions to specify their parameters
12582 with xdecls (must be spec.d in the parmlist).
12584 Since we now wait to push a class scope until we are sure that
12585 we are in a legitimate method context, we must set oldcname
12586 explicitly (since current_class_name is not yet alive).
12588 We also want to avoid calling this a PARM if it is in a namespace. */
12591 {
12597 }
12603 {
12607 }
12610 {
12614 }
12617 {
12621 }
12624 {
12628 }
12631 {
12635 }
12637 /* [dcl.spec]/2 "At most one of the constexpr, consteval, and constinit
12638 keywords shall appear in a decl-specifier-seq." */
12640 {
12644 "can use at most one of the %<constinit%> and %<constexpr%> "
12647 }
12649 /* If there were multiple types specified in the decl-specifier-seq,
12650 issue an error message. */
12652 {
12656 }
12661 /* Extract the basic type from the decl-specifier-seq. */
12664 {
12667 }
12669 /* Ignore erroneous attributes. */
12673 /* An object declared as __attribute__((unavailable)) suppresses
12674 any reports of being declared with unavailable or deprecated
12675 items. An object declared as __attribute__((deprecated))
12676 suppresses warnings of uses of other deprecated items. */
12685 {
12691 }
12692 /* No type at all: default to `int', and set DEFAULTED_INT
12693 because it was not a user-defined typedef. */
12695 {
12697 {
12698 /* These imply 'int'. */
12701 }
12702 /* If we just have "complex", it is equivalent to "complex double". */
12705 {
12708 "ISO C++ does not support plain %<complex%> meaning "
12710 }
12711 }
12712 /* Gather flags. */
12716 #if 0
12717 /* See the code below that used this. */
12720 #endif
12725 else
12729 {
12731 ctor_return_type,
12732 type_quals,
12735 }
12737 {
12742 /* We handle `main' specially here, because 'main () { }' is so
12743 common. With no options, it is allowed. With -Wreturn-type,
12744 it is a warning. It is only an error with -pedantic-errors. */
12745 is_main = (funcdef_flag
12758 name);
12762 else
12767 /* FIXME we should be able to propagate the error_mark_node as is
12768 for other contexts too. */
12770 else
12772 }
12777 {
12779 {
12784 }
12785 /* Don't pedwarn if the alternate "__intN__" form has been used instead
12786 of "__intN". */
12791 }
12793 /* Now process the modifiers that were specified
12794 and check for invalid combinations. */
12796 /* Long double is a special combination. */
12798 {
12802 }
12804 /* Check all other uses of type modifiers. */
12807 {
12808 location_t loc;
12811 {
12814 }
12816 {
12819 }
12821 {
12824 }
12826 {
12829 }
12831 {
12834 }
12839 {
12844 }
12846 {
12850 }
12860 {
12862 {
12867 /* PR108099: __int128_t comes from c_common_nodes_and_builtins,
12868 and is not built as a typedef. */
12871 }
12874 else
12876 }
12877 else
12880 /* Discard the type modifiers if they are invalid. */
12882 {
12888 }
12889 }
12891 /* Decide whether an integer type is signed or not.
12892 Optionally treat bitfields as signed by default. */
12894 /* [class.bit]
12896 It is implementation-defined whether a plain (neither
12897 explicitly signed or unsigned) char, short, int, or long
12898 bit-field is signed or unsigned.
12900 Naturally, we extend this to long long as well. Note that
12901 this does not include wchar_t. */
12903 && !signed_p
12904 /* A typedef for plain `int' without `signed' can be
12905 controlled just like plain `int', but a typedef for
12906 `signed int' cannot be so controlled. */
12907 && !(typedef_decl
12911 {
12924 else
12926 }
12941 {
12945 /* If a modifier is specified, the resulting complex is the complex
12946 form of TYPE. E.g, "complex short" is "complex short int". */
12955 else
12957 }
12959 /* If we're using the injected-class-name to form a compound type or a
12960 declaration, replace it with the underlying class so we don't get
12961 redundant typedefs in the debug output. But if we are returning the
12962 type unchanged, leave it alone so that it's available to
12963 maybe_get_template_decl_from_type_decl. */
12971 type = cp_build_qualified_type
12975 /* We might have ignored or rejected some of the qualifiers. */
12980 /* Placeholder in parm gets a better error below. */
12984 {
12985 auto_diagnostic_group g;
12989 "for deduction, template placeholder must be followed "
12993 }
13004 /* Treat class-scope deduction guides as static member functions
13005 so that they get a FUNCTION_TYPE instead of a METHOD_TYPE. */
13009 {
13011 {
13018 }
13020 {
13024 "declared both %<virtual%> and %<constexpr%> only in "
13026 }
13027 }
13030 /* Issue errors about use of storage classes for parameters. */
13032 {
13034 {
13038 }
13040 {
13044 name);
13046 }
13050 {
13055 }
13057 /* Function parameters cannot be concept. */
13059 {
13064 }
13065 /* Function parameters cannot be constexpr. If we saw one, moan
13066 and pretend it wasn't there. */
13068 {
13072 }
13074 {
13078 }
13080 {
13084 }
13085 }
13087 /* Give error if `virtual' is used outside of class declaration. */
13090 {
13094 }
13097 {
13114 "structured binding declaration can be %qs only in "
13116 declspecs->gnu_thread_keyword_p
13121 /* [dcl.struct.bind] "A cv that includes volatile is deprecated." */
13126 {
13136 "structured binding declaration can be %qs only in "
13153 }
13156 {
13158 {
13159 auto_diagnostic_group d;
13163 "type must be cv-qualified %<auto%> or reference to "
13165 }
13168 }
13171 "structured binding declaration cannot have constrained "
13179 {
13182 }
13183 }
13185 /* Static anonymous unions are dealt with here. */
13191 /* Warn about storage classes that are invalid for certain
13192 kinds of declarations (parameters, typenames, etc.). */
13194 && ((storage_class
13198 {
13199 location_t loc
13204 }
13209 {
13213 ;
13215 ;
13217 /* C++ allows static class elements. */
13219 /* C++ also allows inlines and signed and unsigned elements,
13220 but in those cases we don't come in here. */
13221 ;
13222 else
13223 {
13224 location_t loc
13231 else
13238 }
13239 }
13244 {
13248 }
13252 {
13258 /* When thread_local is applied to a variable of block scope the
13259 storage-class-specifier static is implied if it does not appear
13260 explicitly. */
13263 }
13266 {
13269 "storage class specifiers invalid in friend function "
13273 }
13277 else
13278 {
13281 {
13294 }
13295 }
13299 {
13305 }
13310 /* Skip over build_memfn_type when a FUNCTION_DECL is an xobj memfn. */
13312 /* Determine the type of the entity declared by recurring on the
13313 declarator. */
13315 {
13317 tree attrs;
13324 {
13336 /* Assume that any attributes that get applied late to
13337 templates will DTRT when applied to the declaration
13338 as a whole. */
13342 attrs),
13343 attr_flags);
13345 }
13349 /* Check that contracts aren't misapplied. */
13355 /* We don't want to warn in parameter context because we don't
13356 yet know if the parse will succeed, and this might turn out
13357 to be a constructor call. */
13360 && !typedef_p
13362 /* If the type is class-like and the inner name used a
13363 global namespace qualifier, we need the parens.
13364 Unfortunately all we can tell is whether a qualified name
13365 was used or not. */
13366 && !(inner_declarator
13371 {
13374 name))
13375 {
13380 }
13381 }
13386 {
13397 /* [dcl.array]/1:
13399 The optional attribute-specifier-seq appertains to the
13400 array. */
13406 {
13407 tree arg_types;
13410 /* Declaring a function type. */
13412 /* Pick up type qualifiers which should be applied to `this'. */
13414 /* Pick up virt-specifiers. */
13416 /* And ref-qualifier, too */
13418 /* And tx-qualifier. */
13420 /* Pick up the exception specifications. */
13422 /* If the exception-specification is ill-formed, let's pretend
13423 there wasn't one. */
13428 {
13429 /* There is no need to iterate over the list,
13430 only the first parm can be a valid xobj parm. */
13433 /* If we make it here, we are looking at an xobj parm.
13435 Non-null 'purpose' usually means the parm has a default
13436 argument, we don't want to violate this assumption. */
13439 };
13441 tree xobj_parm
13447 "explicit object member function only available "
13451 {
13452 /* We inform in every case, just differently depending on what
13453 case it is. */
13454 auto_diagnostic_group d;
13456 /* If declarator->kind is cdk_function and we are at the end of
13457 the declarator chain, we are looking at a function type. */
13459 {
13461 "a function type cannot "
13464 }
13467 "a pointer to function type cannot "
13471 "a pointer to member function type "
13473 else
13476 /* The locations being used here are probably not correct. */
13479 "the type of a pointer to explicit object member "
13481 else
13483 "the type of an explicit object "
13485 /* Ideally we should synthesize the correct syntax
13486 for the user, perhaps this could be added later. */
13487 }
13488 /* Since a valid xobj parm has its purpose cleared in find_xobj_parm
13489 the first parm node will never erroneously be detected here. */
13490 {
13491 auto_diagnostic_group d;
13496 {
13501 gcc_rich_location bad_xobj_parm
13504 "only the first parameter of a member function "
13506 }
13510 }
13516 /* Say it's a definition only for the CALL_EXPR
13517 closest to the identifier. */
13520 /* Handle a late-specified return type. */
13523 {
13525 {
13532 {
13534 "%<auto%> type specifier without "
13537 "deduced return type only available "
13539 }
13541 {
13545 }
13546 }
13548 {
13550 "return type has %qT as its type rather "
13553 }
13555 {
13558 "%qs function with trailing return type "
13559 "has %<decltype(auto)%> as its type "
13561 else
13565 }
13571 {
13573 {
13574 auto_diagnostic_group g;
13581 }
13583 {
13585 "for %qT must have trailing return "
13590 }
13596 else
13600 }
13601 }
13604 {
13608 /* Not using maybe_warn_cpp0x because this should
13609 always be an error. */
13611 "trailing return type only available "
13613 else
13615 "return type not declared with %<auto%> "
13618 }
13620 {
13623 }
13629 {
13632 }
13635 {
13636 /* It's wrong, for instance, to issue a -Wignored-qualifiers
13637 warning for
13638 static_assert(!is_same_v<void(*)(), const void(*)()>);
13639 because there the qualifier matters. */
13643 /* [dcl.fct] "A volatile-qualified return type is
13644 deprecated." */
13647 "%<volatile%>-qualified return type is "
13650 /* We now know that the TYPE_QUALS don't apply to the
13651 decl, but to its return type. */
13653 }
13655 /* Error about some types functions can't return. */
13658 {
13662 }
13664 {
13668 }
13670 {
13672 "%<constinit%> on function return type is not "
13675 }
13682 && funcdecl_p
13688 {
13689 /* We are within a class's scope. If our declarator name
13690 is the same as the class name, and we are defining
13691 a function, then it is a constructor/destructor, and
13692 therefore returns a void type. */
13694 /* ISO C++ 12.4/2. A destructor may not be declared
13695 const or volatile. A destructor may not be static.
13696 A destructor may not be declared with ref-qualifier.
13698 ISO C++ 12.1. A constructor may not be declared
13699 const or volatile. A constructor may not be
13700 virtual. A constructor may not be static.
13701 A constructor may not be declared with ref-qualifier. */
13710 {
13715 }
13718 {
13724 }
13728 current_class_type,
13729 flags))
13733 {
13734 /* It's a constructor. */
13738 {
13742 }
13746 }
13749 }
13751 {
13753 {
13754 /* Cannot be both friend and virtual. */
13759 }
13764 {
13766 "cannot define friend function %qs in a local "
13769 }
13770 /* [class.friend]/6: A function can be defined in a friend
13771 declaration if the function name is unqualified. */
13773 {
13776 "friend function definition %qs cannot have "
13778 else
13780 "friend function definition %qs cannot have "
13782 in_namespace);
13783 }
13784 }
13786 {
13788 {
13791 }
13792 }
13794 {
13797 }
13800 {
13803 && (in_namespace
13806 "a non-member function cannot have "
13808 else
13809 {
13811 {
13812 auto_diagnostic_group d;
13814 "an explicit object member function cannot "
13819 }
13821 {
13822 auto_diagnostic_group d;
13824 "an explicit object member function cannot "
13828 }
13833 "%qD cannot be an explicit object member "
13835 }
13836 }
13842 pushed_scope
13854 {
13860 }
13866 {
13868 /* transaction_safe applies to the type, but
13869 transaction_safe_dynamic applies to the function. */
13872 else
13874 }
13876 /* Actually apply the contract attributes to the declaration. */
13878 {
13881 {
13883 /* Intentionally reverse order of contracts so they're
13884 reversed back into their lexical order. */
13887 }
13888 else
13890 }
13893 /* [dcl.fct]/2:
13895 The optional attribute-specifier-seq appertains to
13896 the function type. */
13901 }
13907 /* Filter out pointers-to-references and references-to-references.
13908 We can get these if a TYPE_DECL is used. */
13911 {
13913 {
13916 }
13918 /* In C++0x, we allow reference to reference declarations
13919 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
13920 and template type arguments [14.3.1/4 temp.arg.type]. The
13921 check for direct reference to reference declarations, which
13922 are still forbidden, occurs below. Reasoning behind the change
13923 can be found in DR106, DR540, and the rvalue reference
13924 proposals. */
13926 {
13929 }
13930 }
13932 {
13937 }
13939 /* We now know that the TYPE_QUALS don't apply to the decl,
13940 but to the target of the pointer. */
13943 /* This code used to handle METHOD_TYPE, but I don't think it's
13944 possible to get it here anymore. */
13948 {
13952 memfn_quals,
13953 rqual);
13959 }
13967 type);
13969 /* When the pointed-to type involves components of variable size,
13970 care must be taken to ensure that the size evaluation code is
13971 emitted early enough to dominate all the possible later uses
13972 and late enough for the variables on which it depends to have
13973 been assigned.
13975 This is expected to happen automatically when the pointed-to
13976 type has a name/declaration of it's own, but special attention
13977 is required if the type is anonymous.
13979 We handle the NORMAL and FIELD contexts here by inserting a
13980 dummy statement that just evaluates the size at a safe point
13981 and ensures it is not deferred until e.g. within a deeper
13982 conditional context (c++/43555).
13984 We expect nothing to be needed here for PARM or TYPENAME.
13985 Evaluating the size at this point for TYPENAME would
13986 actually be incorrect, as we might be in the middle of an
13987 expression with side effects on the pointed-to type size
13988 "arguments" prior to the pointer declaration point and the
13989 size evaluation could end up prior to the side effects. */
13995 {
13999 }
14002 {
14003 /* In C++0x, the type we are creating a reference to might be
14004 a typedef which is itself a reference type. In that case,
14005 we follow the reference collapsing rules in
14006 [7.1.3/8 dcl.typedef] to create the final reference type:
14008 "If a typedef TD names a type that is a reference to a type
14009 T, an attempt to create the type 'lvalue reference to cv TD'
14010 creates the type 'lvalue reference to T,' while an attempt
14011 to create the type "rvalue reference to cv TD' creates the
14012 type TD."
14013 */
14017 {
14020 else
14022 }
14023 else
14024 type = cp_build_reference_type
14027 /* In C++0x, we need this check for direct reference to
14028 reference declarations, which are forbidden by
14029 [8.3.2/5 dcl.ref]. Reference to reference declarations
14030 are only allowed indirectly through typedefs and template
14031 type arguments. Example:
14033 void foo(int & &); // invalid ref-to-ref decl
14035 typedef int & int_ref;
14036 void foo(int_ref &); // valid ref-to-ref decl
14037 */
14041 }
14045 {
14049 /* We will already have complained. */
14051 else
14053 type);
14054 }
14055 else
14058 /* Process a list of type modifier keywords (such as
14059 const or volatile) that were given inside the `*' or `&'. */
14062 {
14063 type
14067 }
14069 /* Apply C++11 attributes to the pointer, and not to the
14070 type pointed to. This is unlike what is done for GNU
14071 attributes above. It is to comply with [dcl.ptr]/1:
14073 [the optional attribute-specifier-seq (7.6.1) appertains
14074 to the pointer and not to the object pointed to]. */
14087 }
14088 }
14093 /* Don't check this if it can be the artifical decltype(auto)
14094 we created when building a constraint in a compound-requirement:
14095 that the type-constraint is plain is going to be checked in
14096 cp_parser_compound_requirement. */
14101 /* A `constexpr' specifier used in an object declaration declares
14102 the object as `const'. */
14104 {
14105 /* DR1688 says that a `constexpr' specifier in combination with
14106 `volatile' is valid. */
14109 {
14112 }
14113 }
14118 {
14120 unqualified_id);
14122 }
14124 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
14125 qualified with a class-name, turn it into a METHOD_TYPE, unless
14126 we know that the function is static. We take advantage of this
14127 opportunity to do other processing that pertains to entities
14128 explicitly declared to be class members. Note that if DECLARATOR
14129 is non-NULL, we know it is a cdk_id declarator; otherwise, we
14130 would not have exited the loop above. */
14135 {
14141 {
14143 {
14145 "member functions are implicitly "
14148 }
14149 else
14152 }
14154 can skip the following checks. */
14157 qualifying type must certainly be complete. */
14158 funcdef_flag
14159 /* A friend declaration of "T::f" is OK, even if
14160 "T" is a template parameter. But, if this
14161 function is not a friend, the qualifying type
14162 must be a class. */
14164 /* For a declaration, the type need not be
14165 complete, if either it is dependent (since there
14166 is no meaningful definition of complete in that
14167 case) or the qualifying class is currently being
14168 defined. */
14171 /* Check that the qualifying type is complete. */
14175 {
14178 {
14186 }
14187 }
14189 {
14193 }
14194 }
14199 /* Now TYPE has the actual type. */
14202 {
14205 else
14207 }
14213 {
14214 /* [dcl.meaning]/1: The optional attribute-specifier-seq following
14215 a declarator-id appertains to the entity that is declared. */
14218 else
14219 /* We should have already diagnosed the issue (c++/78344). */
14221 }
14223 /* Handle parameter packs. */
14225 {
14227 /* Turn the type into a pack expansion.*/
14229 else
14231 }
14234 && !processing_template_decl
14236 {
14240 else
14244 }
14247 {
14248 /* [dcl.fct.spec] (C++11) The explicit specifier shall be used only
14249 in the declaration of a constructor or conversion function within
14250 a class definition. */
14257 else
14259 "only declarations of constructors and conversion operators "
14262 }
14265 {
14268 {
14270 name);
14272 }
14274 {
14277 name);
14279 }
14281 {
14283 name);
14285 }
14287 {
14289 name);
14291 }
14293 {
14295 name);
14297 }
14299 {
14301 name);
14303 }
14304 }
14306 /* If this is declaring a typedef name, return a TYPE_DECL. */
14308 {
14310 tree decl;
14313 {
14317 else
14321 }
14323 /* This declaration:
14325 typedef void f(int) const;
14327 declares a function type which is not a member of any
14328 particular class, but which is cv-qualified; for
14329 example "f S::*" declares a pointer to a const-qualified
14330 member function of S. We record the cv-qualification in the
14331 function type. */
14333 {
14336 /* We have now dealt with these qualifiers. */
14339 }
14342 {
14346 else
14350 }
14356 {
14359 }
14363 else
14367 {
14371 /* The TYPE_DECL is "abstract" because there will be
14372 clones of this constructor/destructor, and there will
14373 be copies of this TYPE_DECL generated in those
14374 clones. The decloning optimization (for space) may
14375 revert this subsequently if it determines that
14376 the clones should share a common implementation. */
14380 }
14385 unqualified_id);
14387 /* If the user declares "typedef struct {...} foo" then the
14388 struct will have an anonymous name. Fill that name in now.
14389 Nothing can refer to it, so nothing needs know about the name
14390 change. */
14392 && unqualified_id
14411 /* Acknowledge that this was written:
14412 `using analias = atype;'. */
14416 }
14418 /* Detect the case of an array type of unspecified size
14419 which came, as such, direct from a typedef name.
14420 We must copy the type, so that the array's domain can be
14421 individually set by the object's initializer. */
14428 /* Detect where we're using a typedef of function type to declare a
14429 function. PARMS will not be set, so we must create it now. */
14432 {
14434 tree args;
14439 {
14445 }
14450 {
14451 /* The qualifiers on the function type become the qualifiers on
14452 the non-static member function. */
14457 }
14458 }
14460 /* If this is a type name (such as, in a cast or sizeof),
14461 compute the type and return it now. */
14464 {
14465 /* Note that here we don't care about type_quals. */
14467 /* Special case: "friend class foo" looks like a TYPENAME context. */
14469 {
14471 {
14474 }
14477 {
14478 /* Don't allow friend declaration without a class-key. */
14485 else
14488 type);
14489 }
14491 /* Only try to do this stuff if we didn't already give up. */
14493 {
14494 /* A friendly class? */
14498 else
14500 type);
14503 }
14504 }
14506 {
14513 /* Core issue #547: need to allow this in template type args.
14514 Allow it in general in C++11 for alias-declarations. */
14518 else
14520 }
14526 }
14530 && ! bitfield
14532 {
14535 }
14538 {
14539 /* Only functions may be declared using an operator-function-id. */
14541 {
14544 }
14549 type);
14550 }
14552 /* We don't check parameter types here because we can emit a better
14553 error message later. */
14555 {
14559 }
14561 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
14562 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
14565 {
14571 {
14574 {
14579 {
14580 auto_diagnostic_group g;
14584 "missing template argument list after %qE; template "
14590 }
14594 else
14595 /* Do not issue an error while tentatively parsing a function
14596 parameter: for T t(auto(a), 42);, when we just saw the 1st
14597 parameter, we don't know yet that this construct won't be
14598 a function declaration. Defer the checking to
14599 cp_parser_parameter_declaration_clause. */
14601 }
14602 else
14606 }
14608 /* A parameter declared as an array of T is really a pointer to T.
14609 One declared as a function is really a pointer to a function.
14610 One declared as a member is really a pointer to member. */
14613 {
14614 /* Transfer const-ness of array into that of type pointed to. */
14618 }
14621 }
14624 /* Don't convert xobj member functions to METHOD_TYPE. */
14625 && !is_xobj_member_function
14626 && !(unqualified_id
14629 {
14635 }
14637 {
14641 {
14649 }
14651 {
14654 {
14660 else
14664 }
14666 /* The C99 flexible array extension. */
14669 {
14676 else
14677 {
14678 /* Array is a flexible member. */
14682 else
14686 /* Flexible array member has a null domain. */
14688 }
14689 }
14692 {
14693 /* Happens when declaring arrays of sizes which
14694 are error_mark_node, for example. */
14696 }
14698 {
14699 /* Something like struct S { int N::j; }; */
14702 }
14704 {
14706 tree function_context;
14709 {
14710 /* This should never happen in pure C++ (the check
14711 could be an assert). It could happen in
14712 Objective-C++ if someone writes invalid code that
14713 uses a function declaration for an instance
14714 variable or property (instance variables and
14715 properties are parsed as FIELD_DECLs, but they are
14716 part of an Objective-C class, not a C++ class).
14717 That code is invalid and is caught by this
14718 check. */
14720 {
14722 unqualified_id);
14724 }
14726 /* ``A union may [ ... ] not [ have ] virtual functions.''
14727 ARM 9.5 */
14729 {
14732 unqualified_id);
14734 }
14739 {
14741 "%qD cannot be declared %<virtual%>, since it "
14744 }
14745 }
14747 /* Check that the name used for a destructor makes sense. */
14749 {
14753 {
14758 }
14761 {
14765 }
14767 {
14771 }
14773 {
14775 "%<constexpr%> destructors only available"
14778 }
14780 {
14784 }
14785 }
14787 {
14792 }
14795 {
14799 }
14801 {
14805 }
14809 {
14813 }
14816 {
14819 {
14825 }
14826 }
14828 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
14829 function_context
14838 parms,
14839 unqualified_id,
14840 declspecs,
14841 reqs,
14854 #if 0
14855 /* This clobbers the attrs stored in `decl' from `attrlist'. */
14856 /* The decl and setting of decl_attr is also turned off. */
14858 #endif
14860 /* [class.conv.ctor]
14862 A constructor declared without the function-specifier
14863 explicit that can be called with a single parameter
14864 specifies a conversion from the type of its first
14865 parameter to the type of its class. Such a constructor
14866 is called a converting constructor. */
14872 }
14874 && ((current_class_type
14880 {
14883 {
14885 {
14889 }
14890 else
14895 }
14896 }
14898 staticp
14899 ? TCTX_STATIC_STORAGE
14901 {
14904 }
14905 else
14906 {
14908 {
14911 "%qE is neither function nor member function; "
14913 else
14917 }
14919 }
14922 {
14923 /* Packages tend to use GNU attributes on friends, so we only
14924 warn for standard attributes. */
14926 && !funcdef_flag
14929 {
14934 }
14935 /* Friends are treated specially. */
14939 {
14943 /* Kludge: We need funcdef_flag to be true in do_friend for
14944 in-class defaulted functions, but that breaks grokfndecl.
14945 So set it here. */
14955 }
14956 else
14958 }
14960 /* Structure field. It may not be a function, except for C++. */
14963 {
14965 {
14966 /* C++ allows static class members. All other work
14967 for this is done by grokfield. */
14972 {
14974 template_count,
14978 }
14985 {
14987 "%<constexpr%> static data member %qD must "
14990 }
15001 /* Even if there is an in-class initialization, DECL
15002 is considered undefined until an out-of-class
15003 definition is provided, unless this is an inline
15004 variable. */
15008 {
15014 }
15016 /* Set the constraints on the declaration. */
15020 {
15023 }
15024 }
15025 else
15026 {
15028 {
15034 }
15036 {
15041 }
15043 {
15048 }
15050 {
15055 }
15062 {
15065 }
15068 {
15069 /* An attempt is being made to initialize a non-static
15070 member. This is new in C++11. */
15073 /* If this has been parsed with static storage class, but
15074 errors forced staticp to be cleared, ensure NSDMI is
15075 not present. */
15078 }
15079 }
15086 }
15087 }
15089 {
15090 tree original_name;
15098 else
15100 // FIXME:gcc_assert (original_name == dname);
15108 name);
15110 {
15114 name);
15115 else
15117 "storage class %<thread_local%> invalid for "
15119 }
15127 /* Function declaration not at top level.
15128 Storage classes other than `extern' are not allowed
15129 and `extern' makes no difference. */
15134 {
15137 "%<static%> specifier invalid for function %qs "
15139 else
15141 "%<inline%> specifier invalid for function %qs "
15143 }
15146 {
15148 {
15151 }
15154 {
15159 }
15160 }
15164 {
15168 }
15170 /* Record whether the function is public. */
15175 declspecs,
15178 publicp,
15183 funcdef_flag,
15184 late_return_type_p,
15186 id_loc);
15193 {
15196 /* Don't allow a static member function in a class, and forbid
15197 declaring main to be static. */
15199 {
15203 }
15205 {
15206 /* 7.1.1: There can be no static function declarations within a
15207 block. */
15211 }
15214 {
15217 }
15218 }
15221 }
15222 else
15223 {
15224 /* It's a variable. */
15226 /* An uninitialized decl with `extern' is a reference. */
15228 declspecs,
15229 initialized,
15230 type_quals,
15231 inlinep,
15232 concept_p,
15233 template_count,
15235 id_loc);
15245 {
15248 {
15250 "%<static%> may not be used when defining "
15254 }
15256 {
15259 }
15261 {
15263 "cannot explicitly declare member %q#D to have "
15266 }
15267 }
15269 {
15271 "declaration of %<constexpr%> variable %qD "
15274 }
15276 {
15280 }
15285 {
15290 }
15291 }
15296 {
15300 }
15303 {
15305 {
15306 /* It's common practice (and completely valid) to have a const
15307 be initialized and declared extern. */
15311 }
15312 else
15313 {
15317 }
15318 }
15320 /* Record `register' declaration for warnings on &
15321 and in case doing stupid register allocation. */
15324 {
15326 /* Warn about register storage specifiers on PARM_DECLs. */
15328 {
15331 "ISO C++17 does not allow %<register%> storage "
15333 else
15336 }
15337 }
15344 {
15345 /* Set constexpr flag on vars (functions got it in grokfndecl). */
15348 /* And the constinit flag (which only applies to variables). */
15351 }
15353 {
15354 /* If we saw a return type, record its location. */
15359 {
15365 }
15368 }
15370 /* Record constancy and volatility on the DECL itself . There's
15371 no need to do this when processing a template; we'll do this
15372 for the instantiated declaration based on the type of DECL. */
15374 /* Don't do it for instantiated variable templates either,
15375 cp_apply_type_quals_to_decl should have been called on it
15376 already and might have been overridden in cp_finish_decl
15377 if initializer needs runtime initialization. */
15382 }
15383 }
15384 \f
15385 /* Subroutine of start_function. Ensure that each of the parameter
15386 types (as listed in PARMS) is complete, as is required for a
15387 function definition. */
15389 static void
15391 {
15393 {
15398 {
15405 }
15406 else
15407 /* grokparms or complete_type_or_else will have already issued
15408 an error. */
15410 }
15411 }
15413 /* Returns nonzero if T is a local variable. */
15415 int
15417 {
15426 }
15428 /* Like local_variable_p, but suitable for use as a tree-walking
15429 function. */
15431 static tree
15434 {
15436 {
15437 /* DR 2082 permits local variables in unevaluated contexts
15438 within a default argument. */
15441 }
15450 }
15452 /* Check that ARG, which is a default-argument expression for a
15453 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
15454 something goes wrong. DECL may also be a _TYPE node, rather than a
15455 DECL, if there is no DECL available. */
15457 tree
15459 {
15460 tree var;
15461 tree decl_type;
15464 /* We get a DEFERRED_PARSE when looking at an in-class declaration
15465 with a default argument. Ignore the argument for now; we'll
15466 deal with it after the class is complete. */
15470 {
15473 }
15474 else
15481 /* Something already went wrong. There's no need to check
15482 further. */
15485 /* [dcl.fct.default]
15487 A default argument expression is implicitly converted to the
15488 parameter type. */
15490 /* Avoid digest_init clobbering the initializer. */
15493 LOOKUP_IMPLICIT);
15496 /* Avoid redundant -Wzero-as-null-pointer-constant warnings at
15497 the call sites. */
15500 /* Don't lose side-effects as in PR90473. */
15504 /* [dcl.fct.default]
15506 Local variables shall not be used in default argument
15507 expressions.
15509 The keyword `this' shall not be used in a default argument of a
15510 member function. */
15513 {
15515 {
15519 else
15521 }
15523 }
15525 /* All is well. */
15527 }
15529 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
15531 static tree
15533 {
15538 {
15541 else
15542 {
15545 }
15546 }
15548 /* Do warn about using typedefs to a deprecated class. */
15560 return type_is_deprecated
15564 }
15566 /* Returns an unavailable type used within TYPE, or NULL_TREE if none. */
15568 static tree
15570 {
15575 {
15578 else
15579 {
15582 }
15583 }
15585 /* Do warn about using typedefs to a deprecated class. */
15597 return type_is_unavailable
15601 }
15603 /* Decode the list of parameter types for a function type.
15604 Given the list of things declared inside the parens,
15605 return a list of types.
15607 If this parameter does not end with an ellipsis, we append
15608 void_list_node.
15610 *PARMS is set to the chain of PARM_DECLs created. */
15612 tree
15614 {
15617 tree parm;
15621 {
15630 {
15633 }
15637 {
15639 && !init
15642 /* DR 577: A parameter list consisting of a single
15643 unnamed parameter of non-dependent type 'void'. */
15647 "invalid use of cv-qualified type %qT in "
15649 else
15651 "invalid use of type %<void%> in parameter "
15653 /* It's not a good idea to actually create parameters of
15654 type `void'; other parts of the compiler assume that a
15655 void type terminates the parameter list. */
15658 }
15661 {
15663 {
15667 }
15670 {
15674 }
15676 /* [dcl.fct] "A parameter with volatile-qualified type is
15677 deprecated." */
15680 "%<volatile%>-qualified parameter is "
15683 /* Top-level qualifiers on the parameters are
15684 ignored for function types. */
15687 {
15691 }
15693 {
15694 /* Before C++17 DR 393:
15695 [dcl.fct]/6, parameter types cannot contain pointers
15696 (references) to arrays of unknown bound. */
15701 {
15709 }
15712 ptr
15718 }
15722 }
15727 }
15737 /* We had parm errors, recover by giving the function (...) type. */
15741 }
15743 \f
15744 /* D is a constructor or overloaded `operator='.
15746 Let T be the class in which D is declared. Then, this function
15747 returns:
15749 -1 if D's is an ill-formed constructor or copy assignment operator
15750 whose first parameter is of type `T'.
15751 0 if D is not a copy constructor or copy assignment
15752 operator.
15753 1 if D is a copy constructor or copy assignment operator whose
15754 first parameter is a reference to non-const qualified T.
15755 2 if D is a copy constructor or copy assignment operator whose
15756 first parameter is a reference to const qualified T.
15758 This function can be used as a predicate. Positive values indicate
15759 a copy constructor and nonzero values indicate a copy assignment
15760 operator. */
15762 int
15764 {
15765 tree args;
15766 tree arg_type;
15774 /* Instantiations of template member functions are never copy
15775 functions. Note that member functions of templated classes are
15776 represented as template functions internally, and we must
15777 accept those as copy functions. */
15785 {
15789 /* Reject unrelated object parameters. */
15794 }
15795 else
15805 {
15806 /* Pass by value copy assignment operator. */
15808 }
15812 {
15815 }
15816 else
15822 /* There are more non-optional args. */
15826 }
15828 /* D is a constructor or overloaded `operator='.
15830 Let T be the class in which D is declared. Then, this function
15831 returns true when D is a move constructor or move assignment
15832 operator, false otherwise. */
15834 bool
15836 {
15838 /* There are no move constructors if we are in C++98 mode. */
15844 /* Instantiations of template member functions are never move
15845 functions. Note that member functions of templated classes are
15846 represented as template functions internally, and we must
15847 accept those as move functions. */
15851 }
15853 /* D is a constructor or overloaded `operator='.
15855 Then, this function returns true when D has the same signature as a move
15856 constructor or move assignment operator (because either it is such a
15857 ctor/op= or it is a template specialization with the same signature),
15858 false otherwise. */
15860 bool
15862 {
15863 tree args;
15864 tree arg_type;
15872 {
15876 /* Reject unrelated object parameters. */
15881 }
15882 else
15900 /* There are more non-optional args. */
15904 }
15906 /* Remember any special properties of member function DECL. */
15908 void
15910 {
15911 tree class_type;
15919 {
15926 {
15927 /* [class.copy]
15929 A non-template constructor for class X is a copy
15930 constructor if its first parameter is of type X&, const
15931 X&, volatile X& or const volatile X&, and either there
15932 are no other parameters or else all other parameters have
15933 default arguments. */
15937 }
15948 }
15950 {
15951 /* [class.copy]
15953 A non-template assignment operator for class X is a copy
15954 assignment operator if its parameter is of type X, X&, const
15955 X&, volatile X& or const volatile X&. */
15960 {
15964 }
15965 }
15969 /* Destructors are handled in check_methods. */
15970 }
15972 /* Check a constructor DECL has the correct form. Complains
15973 if the class has a constructor of the form X(X). */
15975 bool
15977 {
15981 {
15982 /* [class.copy]
15984 A declaration of a constructor for a class X is ill-formed if
15985 its first parameter is of type (optionally cv-qualified) X
15986 and either there are no other parameters or else all other
15987 parameters have default arguments.
15989 We *don't* complain about member template instantiations that
15990 have this form, though; they can occur as we try to decide
15991 what constructor to use during overload resolution. Since
15992 overload resolution will never prefer such a constructor to
15993 the non-template copy constructor (which is either explicitly
15994 or implicitly defined), there's no need to worry about their
15995 existence. Theoretically, they should never even be
15996 instantiated, but that's hard to forestall. */
16001 }
16004 }
16006 /* DECL is a declaration for an overloaded or conversion operator. If
16007 COMPLAIN is true, errors are issued for invalid declarations. */
16009 bool
16011 {
16021 tree_code operator_code;
16024 {
16025 /* Conversion operators are TYPE_EXPR for the purposes of this
16026 function. */
16029 }
16030 else
16031 {
16038 }
16041 {
16042 /* operator new and operator delete are quite special. */
16045 {
16064 }
16066 /* [basic.std.dynamic.allocation]/1:
16068 A program is ill-formed if an allocation function is declared
16069 in a namespace scope other than global scope or declared
16070 static in global scope.
16072 The same also holds true for deallocation functions. */
16074 {
16076 {
16078 decl);
16080 }
16083 {
16086 }
16087 }
16090 {
16093 }
16094 else
16095 {
16098 }
16101 }
16103 /* An operator function must either be a non-static member function
16104 or have at least one parameter of a class, a reference to a class,
16105 an enumeration, or a reference to an enumeration. 13.4.0.6 */
16107 {
16111 {
16114 }
16117 {
16119 {
16122 }
16124 /* For lambdas we diagnose static lambda specifier elsewhere. */
16126 /* For instantiations, we have diagnosed this already. */
16130 decl);
16132 /* static operator[] should have exactly one argument
16133 for C++20 and earlier, so that it isn't multidimensional. */
16135 }
16137 {
16141 }
16142 else
16144 {
16146 {
16151 }
16157 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
16158 because these checks are performed even on template
16159 functions. */
16163 }
16164 }
16167 /* There are no further restrictions on the arguments to an overloaded
16168 "operator ()". */
16171 /* C++23 allows an arbitrary number of parameters and default arguments for
16172 operator[], and none of the other checks below apply. */
16177 {
16178 /* 13.4.0.3 */
16181 }
16183 /* Count the number of arguments and check for ellipsis. */
16186 {
16188 {
16190 decl);
16192 }
16194 }
16195 /* FIXME: We need tests for these errors with xobj member functions. */
16196 /* Verify correct number of arguments. */
16198 {
16201 {
16202 /* We have a unary instance of an ambi-ary op. Remap to the
16203 unary one. */
16209 }
16211 {
16212 /* This was an ambiguous operator but is invalid. */
16214 methodp
16218 }
16221 && ! processing_template_decl
16222 /* x++ and x--'s second argument must be an int. */
16224 integer_type_node))
16225 {
16227 methodp
16230 decl);
16232 }
16237 {
16239 methodp
16243 }
16248 {
16250 methodp
16254 }
16259 }
16261 /* There can be no default arguments. */
16265 {
16269 }
16271 /* At this point the declaration is well-formed. It may not be
16272 sensible though. */
16274 /* Check member function warnings only on the in-class declaration.
16275 There's no point warning on an out-of-class definition. */
16279 /* Warn about conversion operators that will never be used. */
16283 {
16294 {
16297 ref
16302 class_type);
16303 /* Don't force t to be complete here. */
16308 ref
16314 }
16315 }
16320 /* Effective C++ rules below. */
16322 /* More Effective C++ rule 7. */
16329 /* More Effective C++ rule 6. */
16334 {
16343 {
16348 }
16349 else
16350 {
16354 }
16355 }
16357 /* Effective C++ rule 23. */
16368 }
16369 \f
16370 /* Return a string giving the keyword associate with CODE. */
16374 {
16376 {
16389 }
16390 }
16392 /* Name lookup in an elaborated-type-specifier (after the keyword
16393 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
16394 elaborated-type-specifier is invalid, issue a diagnostic and return
16395 error_mark_node; otherwise, return the *_TYPE to which it referred.
16396 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
16398 tree
16400 tree decl,
16402 {
16403 tree type;
16405 /* In the case of:
16407 struct S { struct S *p; };
16409 name lookup will find the TYPE_DECL for the implicit "S::S"
16410 typedef. Adjust for that here. */
16416 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
16417 is false for this case as well. */
16419 {
16423 }
16424 /* Accept template template parameters. */
16428 ;
16429 /* [dcl.type.elab]
16431 If the identifier resolves to a typedef-name or the
16432 simple-template-id resolves to an alias template
16433 specialization, the elaborated-type-specifier is ill-formed.
16435 In other words, the only legitimate declaration to use in the
16436 elaborated type specifier is the implicit typedef created when
16437 the type is declared. */
16441 {
16445 else
16450 }
16455 {
16459 }
16462 {
16466 }
16470 {
16471 /* If a class template appears as elaborated type specifier
16472 without a template header such as:
16474 template <class T> class C {};
16475 void f(class C); // No template header here
16477 then the required template argument is missing. */
16482 }
16485 }
16487 /* Lookup NAME of an elaborated type specifier according to SCOPE and
16488 issue diagnostics if necessary. Return *_TYPE node upon success,
16489 NULL_TREE when the NAME is not found, and ERROR_MARK_NODE for type
16490 error. */
16492 static tree
16495 {
16496 tree decl;
16498 {
16499 /* First try ordinary name lookup, ignoring hidden class name
16500 injected via friend declaration. */
16502 /* If that fails, the name will be placed in the smallest
16503 non-class, non-function-prototype scope according to 3.3.1/5.
16504 We may already have a hidden name declared as friend in this
16505 scope. So lookup again but not ignoring hidden names.
16506 If we find one, that name will be made visible rather than
16507 creating a new tag. */
16510 }
16511 else
16515 /* We found nothing. */
16519 {
16523 }
16526 && !template_header_p
16528 {
16533 }
16536 /* If scope is TAG_how::CURRENT_ONLY we're defining a class,
16537 so ignore a template template parameter. */
16542 /* Found not-a-type. */
16545 /* Look for invalid nested type:
16546 class C {
16547 class C {};
16548 }; */
16550 {
16554 }
16556 /* Two cases we need to consider when deciding if a class
16557 template is allowed as an elaborated type specifier:
16558 1. It is a self reference to its own class.
16559 2. It comes with a template header.
16561 For example:
16563 template <class T> class C {
16564 class C *c1; // DECL_SELF_REFERENCE_P is true
16565 class D;
16566 };
16567 template <class U> class C; // template_header_p is true
16568 template <class T> class C<T>::D {
16569 class C *c2; // DECL_SELF_REFERENCE_P is true
16570 }; */
16573 template_header_p
16578 {
16587 }
16590 }
16592 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
16593 Define the tag as a forward-reference if it is not defined.
16595 If a declaration is given, process it here, and report an error if
16596 multiple declarations are not identical.
16598 SCOPE is TS_CURRENT when this is also a definition. Only look in
16599 the current frame for the name (since C++ allows new names in any
16600 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
16601 declaration. Only look beginning from the current scope outward up
16602 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
16604 TEMPLATE_HEADER_P is true when this declaration is preceded by
16605 a set of template parameters. */
16607 tree
16610 {
16619 {
16632 }
16634 /* In case of anonymous name, xref_tag is only called to
16635 make type node and push name. Name lookup is not required. */
16646 {
16650 /* Since HOW is not TAG_how::CURRENT_ONLY, we are not looking at
16651 a definition of this tag. Since, in addition, we are
16652 currently processing a (member) template declaration of a
16653 template class, we must be very careful; consider:
16655 template <class X> struct S1
16657 template <class U> struct S2
16658 {
16659 template <class V> friend struct S1;
16660 };
16662 Here, the S2::S1 declaration should not be confused with the
16663 outer declaration. In particular, the inner version should
16664 have a template parameter of level 2, not level 1.
16666 On the other hand, when presented with:
16668 template <class T> struct S1
16669 {
16670 template <class U> struct S2 {};
16671 template <class U> friend struct S2;
16672 };
16674 the friend must find S1::S2 eventually. We accomplish this
16675 by making sure that the new type we create to represent this
16676 declaration has the right TYPE_CONTEXT. */
16679 }
16682 {
16683 /* If no such tag is yet defined, create a forward-reference node
16684 and record it as the "definition".
16685 When a real declaration of this type is found,
16686 the forward-reference will be altered into a real type. */
16688 {
16691 }
16696 /* Mark it as a lambda type right now. Our caller will
16697 correct the value. */
16700 }
16701 else
16702 {
16704 {
16705 /* Check that we aren't trying to overload a class with different
16706 constraints. */
16710 }
16714 {
16718 }
16722 {
16732 {
16733 auto_diagnostic_group d;
16737 }
16743 /* FIXME: we should do a more precise check for redefinitions
16744 of a conflicting using-declaration here, as these diagnostics
16745 are not ideal. */
16749 {
16750 /* Push it into this TU's symbol slot. */
16752 /* We're in the template parm binding level.
16753 Pushtag has logic to slide under that, but we're
16754 not pushing a *new* type. */
16760 }
16763 }
16764 }
16767 }
16769 /* Create the binfo hierarchy for REF with (possibly NULL) base list
16770 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
16771 access_* node, and the TREE_VALUE is the type of the base-class.
16772 Non-NULL TREE_TYPE indicates virtual inheritance. */
16774 void
16776 {
16783 tree default_access;
16789 /* The base of a derived class is private by default, all others are
16790 public. */
16795 /* First, make sure that any templates in base-classes are
16796 instantiated. This ensures that if we call ourselves recursively
16797 we do not get confused about which classes are marked and which
16798 are not. */
16801 {
16804 /* The dependent_type_p call below should really be dependent_scope_p
16805 so that we give a hard error about using an incomplete type as a
16806 base, but we allow it with a pedwarn for backward
16807 compatibility. */
16813 /* An incomplete type. Remove it from the list. */
16815 else
16816 {
16817 max_bases++;
16819 max_dvbases++;
16823 }
16824 }
16829 /* The binfo slot should be empty, unless this is an (ill-formed)
16830 redefinition. */
16841 /* Apply base-class info set up to the variants of this type. */
16845 {
16847 /* A C++98 POD cannot have base classes. */
16851 {
16854 }
16855 }
16862 {
16863 /* An aggregate can't have virtual base classes. */
16871 }
16874 {
16882 /* Before C++17, an aggregate cannot have base classes. In C++17, an
16883 aggregate can't have virtual, private, or protected base classes. */
16894 {
16896 basetype);
16898 }
16902 {
16904 /* The original basetype could have been a typedef'd type. */
16907 /* Inherit flags from the base. */
16918 }
16920 /* We must do this test after we've seen through a typedef
16921 type. */
16923 {
16926 else
16929 }
16932 /* Regenerate the pack expansion for the bases. */
16946 dropped_base:
16947 /* Update max_vbases to reflect the reality that we are dropping
16948 this base: if it reaches zero we want to undo the vec_alloc
16949 above to avoid inconsistencies during error-recovery: eg, in
16950 build_special_member_call, CLASSTYPE_VBASECLASSES non null
16951 and vtt null (c++/27952). */
16953 max_vbases--;
16955 max_vbases
16957 }
16964 /* If we didn't get max_vbases vbases, we must have shared at
16965 least one of them, and are therefore diamond shaped. */
16968 /* Unmark all the types. */
16973 /* Now see if we have a repeated base type. */
16975 {
16978 {
16980 {
16983 }
16985 }
16990 else
16992 }
16993 }
16995 \f
16996 /* Copies the enum-related properties from type SRC to type DST.
16997 Used with the underlying type of an enum and the enum itself. */
16998 static void
17000 {
17001 tree t;
17003 {
17013 else
17017 }
17018 }
17020 /* Begin compiling the definition of an enumeration type.
17021 NAME is its name,
17023 if ENUMTYPE is not NULL_TREE then the type has alredy been found.
17025 UNDERLYING_TYPE is the type that will be used as the storage for
17026 the enumeration type. This should be NULL_TREE if no storage type
17027 was specified.
17029 ATTRIBUTES are any attributes specified after the enum-key.
17031 SCOPED_ENUM_P is true if this is a scoped enumeration type.
17033 if IS_NEW is not NULL, gets TRUE iff a new type is created.
17035 Returns the type object, as yet incomplete.
17036 Also records info about it so that build_enumerator
17037 may be used to declare the individual values as they are read. */
17039 tree
17042 {
17048 /* [C++0x dcl.enum]p5:
17050 If not explicitly specified, the underlying type of a scoped
17051 enumeration type is int. */
17058 /* If this is the real definition for a previous forward reference,
17059 fill in the contents in the same object that used to be the
17060 forward reference. */
17066 /* In case of a template_decl, the only check that should be deferred
17067 to instantiation time is the comparison of underlying types. */
17069 {
17070 /* Attempt to set the declaring module. */
17072 {
17076 else
17078 }
17081 ;
17083 {
17084 auto_diagnostic_group d;
17090 }
17092 {
17093 auto_diagnostic_group d;
17099 }
17103 {
17104 auto_diagnostic_group d;
17110 }
17111 }
17115 {
17116 /* In case of error, make a dummy enum to allow parsing to
17117 continue. */
17119 {
17122 }
17124 /* enumtype may be an ENUMERAL_TYPE if this is a redefinition
17125 of an opaque enum, or an opaque enum of an already defined
17126 enumeration (C++11).
17127 In any other case, it'll be NULL_TREE. */
17129 {
17132 }
17135 /* Do not push the decl more than once. */
17138 {
17142 /* std::byte aliases anything. */
17147 }
17148 else
17154 /* The enum is considered opaque until the opening '{' of the
17155 enumerator list. */
17158 }
17165 {
17167 /* We already checked that it matches, don't change it to a different
17170 {
17173 }
17176 else
17177 {
17181 }
17182 }
17184 /* If into a template class, the returned enum is always the first
17185 declaration (opaque or not) seen. This way all the references to
17186 this type will be to the same declaration. The following ones are used
17187 only to check for definition errors. */
17190 else
17192 }
17194 /* After processing and defining all the values of an enumeration type,
17195 install their decls in the enumeration type.
17196 ENUMTYPE is the type object. */
17198 void
17200 {
17201 tree values;
17202 tree underlying_type;
17203 tree decl;
17204 tree value;
17206 tree t;
17208 bool fixed_underlying_type_p
17211 /* We built up the VALUES in reverse order. */
17214 /* For an enum defined in a template, just set the type of the values;
17215 all further processing is postponed until the template is
17216 instantiated. We need to set the type so that tsubst of a CONST_DECL
17217 works. */
17219 {
17221 values;
17225 }
17227 /* Determine the minimum and maximum values of the enumerators. */
17229 {
17233 values;
17235 {
17238 /* [dcl.enum]: Following the closing brace of an enum-specifier,
17239 each enumerator has the type of its enumeration. Prior to the
17240 closing brace, the type of each enumerator is the type of its
17241 initializing value. */
17244 /* Update the minimum and maximum values, if appropriate. */
17248 /* Figure out what the minimum and maximum values of the
17249 enumerators are. */
17256 }
17257 }
17258 else
17259 /* [dcl.enum]
17261 If the enumerator-list is empty, the underlying type is as if
17262 the enumeration had a single enumerator with value 0. */
17266 {
17267 /* Compute the number of bits require to represent all values of the
17268 enumeration. We must do this before the type of MINNODE and
17269 MAXNODE are transformed, since tree_int_cst_min_precision relies
17270 on the TREE_TYPE of the value it is passed. */
17278 /* Determine the underlying type of the enumeration.
17280 [dcl.enum]
17282 The underlying type of an enumeration is an integral type that
17283 can represent all the enumerator values defined in the
17284 enumeration. It is implementation-defined which integral type is
17285 used as the underlying type for an enumeration except that the
17286 underlying type shall not be larger than int unless the value of
17287 an enumerator cannot fit in an int or unsigned int.
17289 We use "int" or an "unsigned int" as the underlying type, even if
17290 a smaller integral type would work, unless the user has
17291 explicitly requested that we use the smallest possible type. The
17292 user can request that for all enumerations with a command line
17293 flag, or for just one enumeration with an attribute. */
17295 use_short_enum = flag_short_enums
17298 /* If the precision of the type was specified with an attribute and it
17299 was too small, give an error. Otherwise, use it. */
17301 {
17304 else
17305 {
17308 }
17309 }
17313 itk++)
17314 {
17320 }
17322 {
17323 /* DR 377
17325 IF no integral type can represent all the enumerator values, the
17326 enumeration is ill-formed. */
17331 }
17333 /* [dcl.enum]
17335 The value of sizeof() applied to an enumeration type, an object
17336 of an enumeration type, or an enumerator, is the value of sizeof()
17337 applied to the underlying type. */
17340 /* Compute the minimum and maximum values for the type.
17342 [dcl.enum]
17344 For an enumeration where emin is the smallest enumerator and emax
17345 is the largest, the values of the enumeration are the values of the
17346 underlying type in the range bmin to bmax, where bmin and bmax are,
17347 respectively, the smallest and largest values of the smallest bit-
17348 field that can store emin and emax. */
17350 /* The middle-end currently assumes that types with TYPE_PRECISION
17351 narrower than their underlying type are suitably zero or sign
17352 extended to fill their mode. Similarly, it assumes that the front
17353 end assures that a value of a particular type must be within
17354 TYPE_MIN_VALUE and TYPE_MAX_VALUE.
17356 We used to set these fields based on bmin and bmax, but that led
17357 to invalid assumptions like optimizing away bounds checking. So
17358 now we just set the TYPE_PRECISION, TYPE_MIN_VALUE, and
17359 TYPE_MAX_VALUE to the values for the mode above and only restrict
17360 the ENUM_UNDERLYING_TYPE for the benefit of diagnostics. */
17364 set_min_and_max_values_for_integral_type
17367 /* If -fstrict-enums, still constrain TYPE_MIN/MAX_VALUE. */
17372 {
17375 }
17376 }
17377 else
17380 /* If the enum is exported, mark the consts too. */
17385 /* Convert each of the enumerators to the type of the underlying
17386 type of the enumeration. */
17388 {
17392 /* If the enumeration type has a fixed underlying type, we
17393 already checked all of the enumerator values. */
17395 else
17398 tf_warning_or_error);
17399 /* Do not clobber shared ints. */
17401 {
17405 }
17409 }
17411 /* Fix up all variant types of this enum type. */
17418 {
17420 /* TYPE_FIELDS needs fixup. */
17422 }
17424 /* Finish debugging output for this type. */
17427 /* Each enumerator now has the type of its enumeration. Clear the cache
17428 so that this change in types doesn't confuse us later on. */
17430 }
17432 /* Finishes the enum type. This is called only the first time an
17433 enumeration is seen, be it opaque or odinary.
17434 ENUMTYPE is the type object. */
17436 void
17438 {
17440 {
17444 }
17446 /* If this is a forward declaration, there should not be any variants,
17447 though we can get a variant in the middle of an enum-specifier with
17448 wacky code like 'enum E { e = sizeof(const E*) };' */
17452 }
17454 /* Build and install a CONST_DECL for an enumeration constant of the
17455 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
17456 Apply ATTRIBUTES if available. LOC is the location of NAME.
17457 Assignment of sequential values by default is handled here. */
17459 tree
17461 location_t loc)
17462 {
17463 tree decl;
17464 tree context;
17465 tree type;
17467 /* scalar_constant_value will pull out this expression, so make sure
17468 it's folded as appropriate. */
17472 /* If the VALUE was erroneous, pretend it wasn't there; that will
17473 result in the enum being assigned the next value in sequence. */
17477 /* Remove no-op casts from the value. */
17482 {
17483 /* Validate and default VALUE. */
17485 {
17487 {
17492 }
17495 value = perform_implicit_conversion_flags
17503 {
17506 {
17508 "enumerator value for %qD must have integral or "
17511 }
17512 else
17513 {
17517 {
17521 }
17522 }
17523 }
17524 }
17526 /* Default based on previous value. */
17528 {
17530 {
17531 tree prev_value;
17533 /* C++03 7.2/4: If no initializer is specified for the first
17534 enumerator, the type is an unspecified integral
17535 type. Otherwise the type is the same as the type of the
17536 initializing value of the preceding enumerator unless the
17537 incremented value is not representable in that type, in
17538 which case the type is an unspecified integral type
17539 sufficient to contain the incremented value. */
17543 else
17544 {
17551 {
17554 {
17557 {
17563 }
17570 }
17573 else
17575 }
17578 {
17581 }
17582 }
17583 }
17584 else
17586 }
17588 /* Remove no-op casts from the value. */
17591 /* If the underlying type of the enum is fixed, check whether
17592 the enumerator values fits in the underlying type. If it
17593 does not fit, the program is ill-formed [C++0x dcl.enum]. */
17595 && value
17597 {
17602 /* Convert the value to the appropriate type. */
17604 }
17605 }
17607 /* C++ associates enums with global, function, or class declarations. */
17610 /* Build the actual enumeration constant. Note that the enumeration
17611 constants have the underlying type of the enum (if it is fixed)
17612 or the type of their initializer (if the underlying type of the
17613 enum is not fixed):
17615 [ C++0x dcl.enum ]
17617 If the underlying type is fixed, the type of each enumerator
17618 prior to the closing brace is the underlying type; if the
17619 initializing value of an enumerator cannot be represented by
17620 the underlying type, the program is ill-formed. If the
17621 underlying type is not fixed, the type of each enumerator is
17622 the type of its initializing value.
17624 If the underlying type is not fixed, it will be computed by
17625 finish_enum and we will reset the type of this enumerator. Of
17626 course, if we're processing a template, there may be no value. */
17640 {
17641 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
17642 on the TYPE_FIELDS list for `S'. (That's so that you can say
17643 things like `S::i' later.) */
17645 /* The enumerator may be getting declared outside of its enclosing
17646 class, like so:
17648 class S { public: enum E : int; }; enum S::E : int { i = 7; };
17650 For which case we need to make sure that the access of `S::i'
17651 matches the access of `S::E'. */
17655 }
17656 else
17659 /* Add this enumeration constant to the list for this type. */
17663 }
17665 /* Look for an enumerator with the given NAME within the enumeration
17666 type ENUMTYPE. This routine is used primarily for qualified name
17667 lookup into an enumerator in C++0x, e.g.,
17669 enum class Color { Red, Green, Blue };
17671 Color color = Color::Red;
17673 Returns the value corresponding to the enumerator, or
17674 NULL_TREE if no such enumerator was found. */
17675 tree
17677 {
17678 tree e;
17683 }
17685 /* Implement LANG_HOOKS_SIMULATE_ENUM_DECL. */
17687 tree
17690 {
17697 {
17702 }
17716 }
17718 /* Implement LANG_HOOKS_SIMULATE_RECORD_DECL. */
17720 tree
17723 {
17730 {
17733 }
17752 }
17753 \f
17754 /* We're defining DECL. Make sure that its type is OK. */
17756 static void
17758 {
17762 /* In a function definition, arg types must be complete. */
17769 {
17774 /* Make it return void instead. */
17777 void_type_node,
17779 else
17781 fntype = (cp_build_type_attribute_variant
17785 }
17786 else
17787 {
17791 }
17792 }
17794 /* True iff FN is an implicitly-defined default constructor. */
17796 static bool
17798 {
17802 }
17804 /* Clobber the contents of *this to let the back end know that the object
17805 storage is dead when we enter the constructor or leave the destructor. */
17807 static tree
17809 {
17810 /* Clobbering an empty base is pointless, and harmful if its one byte
17811 TYPE_SIZE overlays real data. */
17815 /* If we have virtual bases, clobber the whole object, but only if we're in
17816 charge. If we don't have virtual bases, clobber the as-base type so we
17817 don't mess with tail padding. */
17828 {
17831 }
17838 }
17840 /* Create the FUNCTION_DECL for a function definition.
17841 DECLSPECS and DECLARATOR are the parts of the declaration;
17842 they describe the function's name and the type it returns,
17843 but twisted together in a fashion that parallels the syntax of C.
17845 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
17846 DECLARATOR is really the DECL for the function we are about to
17847 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
17848 indicating that the function is an inline defined in-class.
17850 This function creates a binding context for the function body
17851 as well as setting up the FUNCTION_DECL in current_function_decl.
17853 For C++, we must first check whether that datum makes any sense.
17854 For example, "class A local_a(1,2);" means that variable local_a
17855 is an aggregate of type A, which should have a constructor
17856 applied to it with the argument list [1, 2].
17858 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
17859 or may be a BLOCK if the function has been defined previously
17860 in this translation unit. On exit, DECL_INITIAL (decl1) will be
17861 error_mark_node if the function has never been defined, or
17862 a BLOCK if the function has been defined somewhere. */
17864 bool
17866 {
17870 /* Sanity check. */
17877 else
17878 {
17883 }
17885 /* Adjust for #pragma target/optimize. */
17893 /* Handle gnu_inline attribute. */
17895 {
17900 }
17903 /* This is a constructor, we must ensure that any default args
17904 introduced by this definition are propagated to the clones
17905 now. The clones are used directly in overload resolution. */
17908 /* Sometimes we don't notice that a function is a static member, and
17909 build a METHOD_TYPE for it. Fix that up now. */
17913 /* Set up current_class_type, and enter the scope of the class, if
17914 appropriate. */
17918 /* Now that we have entered the scope of the class, we must restore
17919 the bindings for any template parameters surrounding DECL1, if it
17920 is an inline member template. (Order is important; consider the
17921 case where a template parameter has the same name as a field of
17922 the class.) It is not until after this point that
17923 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
17927 /* Effective C++ rule 15. */
17935 /* Make the init_value nonzero so pushdecl knows this is not tentative.
17936 error_mark_node is replaced below (in poplevel) with the BLOCK. */
17940 /* This function exists in static storage.
17941 (This does not mean `static' in the C sense!) */
17944 /* We must call push_template_decl after current_class_type is set
17945 up. (If we are processing inline definitions after exiting a
17946 class scope, current_class_type will be NULL_TREE until set above
17947 by push_nested_class.) */
17949 {
17952 {
17956 }
17958 }
17960 /* Make sure the parameter and return types are reasonable. When
17961 you declare a function, these types can be incomplete, but they
17962 must be complete when you define the function. */
17965 /* Build the return declaration for the function. */
17969 {
17970 /* In a template instantiation, copy the return type location. When
17971 parsing, the location will be set in grokdeclarator. */
17974 {
17978 }
17986 }
17988 /* Record the decl so that the function name is defined.
17989 If we already have a decl for this name, and it is a FUNCTION_DECL,
17990 use the old decl. */
17992 {
17993 /* A specialization is not used to guide overload resolution. */
17997 {
18001 /* If something went wrong when registering the declaration,
18002 use DECL1; we have to have a FUNCTION_DECL to use when
18003 parsing the body of the function. */
18004 ;
18005 else
18006 {
18007 /* Otherwise, OLDDECL is either a previous declaration
18008 of the same function or DECL1 itself. */
18015 {
18016 tree context;
18018 /* Check whether DECL1 is in an anonymous
18019 namespace. */
18021 context;
18023 {
18027 }
18031 OPT_Wmissing_declarations,
18033 }
18036 }
18037 }
18038 else
18039 {
18040 /* We need to set the DECL_CONTEXT. */
18043 }
18047 /* If #pragma weak applies, mark the decl appropriately now.
18048 The pragma only applies to global functions. Because
18049 determining whether or not the #pragma applies involves
18050 computing the mangled name for the declaration, we cannot
18051 apply the pragma until after we have merged this declaration
18052 with any previous declarations; if the original declaration
18053 has a linkage specification, that specification applies to
18054 the definition as well, and may affect the mangled name. */
18057 }
18059 /* We are now in the scope of the function being defined. */
18062 /* Save the parm names or decls from this function's declarator
18063 where store_parm_decls will find them. */
18066 /* Let the user know we're compiling this function. */
18071 /* This function may already have been parsed, in which case just
18072 return; our caller will skip over the body without parsing. */
18076 /* Initialize RTL machinery. We cannot do this until
18077 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
18078 even when processing a template; this is how we get
18079 CFUN set up, and our per-function variables initialized.
18080 FIXME factor out the non-RTL stuff. */
18084 /* Initialize the language data structures. Whenever we start
18085 a new function, we destroy temporaries in the usual way. */
18090 /* If we are (erroneously) defining a function that we have already
18091 defined before, wipe out what we knew before. */
18097 {
18100 }
18102 /* Start the statement-tree, start the tree now. */
18106 {
18107 /* We know that this was set up by `grokclassfn'. We do not
18108 wait until `store_parm_decls', since evil parse errors may
18109 never get us to that point. Here we keep the consistency
18110 between `current_class_type' and `current_class_ptr'. */
18116 cp_function_chain->x_current_class_ref
18118 /* Set this second to avoid shortcut in cp_build_indirect_ref. */
18121 /* Constructors and destructors need to know whether they're "in
18122 charge" of initializing virtual base classes. */
18125 {
18128 }
18130 {
18133 }
18134 }
18137 /* Implicitly-defined methods (like the
18138 destructor for a class in which no destructor
18139 is explicitly declared) must not be defined
18140 until their definition is needed. So, we
18141 ignore interface specifications for
18142 compiler-generated functions. */
18150 {
18157 /* This is a function in a local class in an extern inline
18158 or template function. */
18160 }
18161 /* If this function belongs to an interface, it is public.
18162 If it belongs to someone else's interface, it is also external.
18163 This only affects inlines and template instantiations. */
18165 {
18168 {
18172 && ! flag_implement_inlines
18175 /* For WIN32 we also want to put these in linkonce sections. */
18177 }
18178 else
18181 /* If this function is in an interface implemented in this file,
18182 make sure that the back end knows to emit this function
18183 here. */
18186 }
18189 {
18190 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
18191 interface, we will have both finfo->interface_unknown and
18192 finfo->interface_only set. In that case, we don't want to
18193 use the normal heuristics because someone will supply a
18194 #pragma implementation elsewhere, and deducing it here would
18195 produce a conflict. */
18200 }
18201 else
18202 {
18203 /* This is a definition, not a reference.
18204 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
18212 else
18214 }
18216 /* Determine the ELF visibility attribute for the function. We must not
18217 do this before calling "pushdecl", as we must allow "duplicate_decls"
18218 to merge any attributes appropriately. We also need to wait until
18219 linkage is set. */
18240 /* Clobbering an empty base is harmful if it overlays real data. */
18242 /* We can't clobber safely for an implicitly-defined default constructor
18243 because part of the initialization might happen before we enter the
18244 constructor, via AGGR_INIT_ZERO_FIRST (c++/68006). */
18259 }
18262 /* Like start_preparsed_function, except that instead of a
18263 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
18265 Returns true on success. If the DECLARATOR is not suitable
18266 for a function, we return false, which tells the parser to
18267 skip the entire function. */
18269 bool
18272 tree attrs)
18273 {
18274 tree decl1;
18282 /* main must return int. grokfndecl should have corrected it
18283 (and issued a diagnostic) if the user got it wrong. */
18285 integer_type_node));
18288 }
18289 \f
18290 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
18291 FN. */
18293 static bool
18295 {
18297 && !processing_template_decl
18298 /* We insert the EH_SPEC_BLOCK only in the original
18299 function; then, it is copied automatically to the
18300 clones. */
18302 /* Implicitly-generated constructors and destructors have
18303 exception specifications. However, those specifications
18304 are the union of the possible exceptions specified by the
18305 constructors/destructors for bases and members, so no
18306 unallowed exception will ever reach this function. By
18307 not creating the EH_SPEC_BLOCK we save a little memory,
18308 and we avoid spurious warnings about unreachable
18309 code. */
18312 }
18314 /* Helper function to push ARGS into the current lexical scope. DECL
18315 is the function declaration. NONPARMS is used to handle enum
18316 constants. */
18318 void
18320 {
18321 /* If we're doing semantic analysis, then we'll call pushdecl
18322 for each of these. We must do them in reverse order so that
18323 they end in the correct forward order. */
18326 tree next;
18328 {
18333 {
18334 /* If we find an enum constant or a type tag, put it aside for
18335 the moment. */
18338 }
18339 }
18341 /* Get the decls in their original chain order and record in the
18342 function. This is all and only the PARM_DECLs that were
18343 pushed into scope by the loop above. */
18345 }
18347 /* Store the parameter declarations into the current function declaration.
18348 This is called after parsing the parameter declarations, before
18349 digesting the body of the function.
18351 Also install to binding contour return value identifier, if any. */
18353 static void
18355 {
18358 /* This is a chain of any other decls that came in among the parm
18359 declarations. If a parm is declared with enum {foo, bar} x;
18360 then CONST_DECLs for foo and bar are put here. */
18364 {
18365 /* This case is when the function was defined with an ANSI prototype.
18366 The parms already have decls, so we need not do anything here
18367 except record them as in effect
18368 and complain if any redundant old-style parm decls were written. */
18372 /* Must clear this because it might contain TYPE_DECLs declared
18373 at class level. */
18377 }
18378 else
18381 /* Now store the final chain of decls for the arguments
18382 as the decl-chain of the current lexical scope.
18383 Put the enumerators in as well, at the front so that
18384 DECL_ARGUMENTS is not modified. */
18389 }
18391 \f
18392 /* Mark CDTOR's implicit THIS argument for returning, if required by
18393 the ABI.. Return the decl for THIS, if it is to be returned, and
18394 NULL otherwise. */
18396 tree
18398 {
18401 {
18404 }
18407 }
18409 /* Set the return value of the [cd]tor if the ABI wants that. */
18411 void
18413 {
18415 {
18416 /* Return the address of the object. */
18422 }
18423 }
18425 /* Do all the processing for the beginning of a destructor; set up the
18426 vtable pointers and cleanups for bases and members. */
18428 static void
18430 {
18431 tree compound_stmt;
18433 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
18434 issued an error message. We still want to try to process the
18435 body of the function, but initialize_vtbl_ptrs will crash if
18436 TYPE_BINFO is NULL. */
18438 {
18440 /* Make all virtual function table pointers in non-virtual base
18441 classes point to CURRENT_CLASS_TYPE's virtual function
18442 tables. */
18447 /* Clobbering an empty base is harmful if it overlays real data. */
18449 {
18453 {
18455 tree ref
18462 tf_warning_or_error);
18463 /* If the vptr is shared with some virtual nearly empty base,
18464 don't clear it if not in charge, the dtor of the virtual
18465 nearly empty base will do that later. */
18467 {
18470 {
18472 {
18474 tf_warning_or_error);
18477 }
18479 }
18480 }
18482 }
18483 else
18486 }
18488 /* And insert cleanups for our bases and members so that they
18489 will be properly destroyed if we throw. */
18491 }
18492 }
18494 /* Do the necessary processing for the beginning of a function body, which
18495 in this case includes member-initializers, but not the catch clauses of
18496 a function-try-block. Currently, this means opening a binding level
18497 for the member-initializers (in a ctor), member cleanups (in a dtor),
18498 and capture proxies (in a lambda operator()). */
18500 tree
18502 {
18508 else
18509 /* Always keep the BLOCK node associated with the outermost pair of
18510 curly braces of a function. These are needed for correct
18511 operation of dwarfout.c. */
18523 }
18525 /* Do the processing for the end of a function body. Currently, this means
18526 closing out the cleanups for fully-constructed bases and members, and in
18527 the case of the destructor, deleting the object if desired. Again, this
18528 is only meaningful for [cd]tors, since they are the only functions where
18529 there is a significant distinction between the main body and any
18530 function catch clauses. Handling, say, main() return semantics here
18531 would be wrong, as flowing off the end of a function catch clause for
18532 main() would also need to return 0. */
18534 void
18536 {
18540 /* Close the block. */
18548 }
18550 /* Given a function, returns the BLOCK corresponding to the outermost level
18551 of curly braces, skipping the artificial block created for constructor
18552 initializers. */
18554 tree
18556 {
18566 }
18568 /* If FNDECL is a class's key method, add the class to the list of
18569 keyed classes that should be emitted. */
18571 static void
18573 {
18577 {
18580 {
18582 /* Classes attached to a named module are already handled. */
18586 }
18587 }
18588 }
18590 /* Attempt to add a fix-it hint to RICHLOC suggesting the insertion
18591 of "return *this;" immediately before its location, using FNDECL's
18592 first statement (if any) to give the indentation, if appropriate. */
18594 static void
18596 {
18603 indent);
18604 }
18606 /* This function carries out the subset of finish_function operations needed
18607 to emit the compiler-generated outlined helper functions used by the
18608 coroutines implementation. */
18610 static void
18612 {
18613 /* This is a partial set of the operations done by finish_function()
18614 plus emitting the result. */
18624 /* We must start each function with a clear fold cache. */
18629 /* This function has coroutine IFNs that we should handle in middle
18630 end lowering. */
18634 }
18636 /* Finish up a function declaration and compile that function
18637 all the way to assembler language output. The free the storage
18638 for the function definition. INLINE_P is TRUE if we just
18639 finished processing the body of an in-class inline function
18640 definition. (This processing will have taken place after the
18641 class definition is complete.) */
18643 tree
18645 {
18650 /* When we get some parse errors, we can end up without a
18651 current_function_decl, so cope. */
18656 && !processing_template_decl
18672 /* TREE_READONLY (fndecl) = 1;
18673 This caused &foo to be of type ptr-to-const-function
18674 which then got a warning when stored in a ptr-to-function variable. */
18677 /* The current function is being defined, so its DECL_INITIAL should
18678 be set, and unless there's a multiple definition, it should be
18679 error_mark_node. */
18683 {
18684 /* Only try to emit the coroutine outlined helper functions if the
18685 transforms succeeded. Otherwise, treat errors in the same way as
18686 a regular function. */
18689 /* We should handle coroutine IFNs in middle end lowering. */
18692 /* Do not try to process the ramp's EH unless outlining succeeded. */
18696 current_eh_spec_block);
18698 /* If outlining succeeded, then add contracts handling if needed. */
18701 }
18702 else
18703 /* For a cloned function, we've already got all the code we need;
18704 there's no need to add any extra bits. */
18706 {
18707 /* Make it so that `main' always returns 0 by default. */
18715 current_eh_spec_block);
18720 }
18722 /* If we're saving up tree structure, tie off the function now. */
18727 /* This must come after expand_function_end because cleanups might
18728 have declarations (from inline functions) that need to go into
18729 this function's blocks. */
18731 /* If the current binding level isn't the outermost binding level
18732 for this function, either there is a bug, or we have experienced
18733 syntax errors and the statement tree is malformed. */
18735 {
18736 /* Make sure we have already experienced errors. */
18739 /* Throw away the broken statement tree and extra binding
18740 levels. */
18744 {
18747 else
18749 }
18750 }
18753 /* Statements should always be full-expressions at the outermost set
18754 of curly braces for a function. */
18757 /* If there are no return statements in a function with auto return type,
18758 the return type is void. But if the declared type is something like
18759 auto*, this is an error. */
18762 {
18764 && !current_function_returns_value
18766 {
18767 /* We haven't applied return type deduction because we haven't
18768 seen any return statements. Do that now. */
18772 adc_return_type);
18776 }
18779 {
18784 }
18785 }
18787 /* Remember that we were in class scope. */
18792 {
18796 }
18798 // If this is a concept, check that the definition is reasonable.
18807 /* Complain if there's just no return statement. */
18814 /* Don't complain if we abort or throw. */
18815 && !current_function_returns_abnormally
18816 /* Don't complain if there's an infinite loop. */
18817 && !current_function_infinite_loop
18818 /* Don't complain if we are declared noreturn. */
18822 /* Structor return values (if any) are set by the compiler. */
18826 {
18828 /* Potentially add a "return *this;" fix-it hint for
18829 assignment operators. */
18831 {
18834 && current_class_ref
18835 && same_type_ignoring_top_level_qualifiers_p
18839 }
18845 "no return statement in function returning "
18848 }
18850 /* Lambda closure members are implicitly constexpr if possible. */
18854 = ((processing_template_decl
18858 /* Save constexpr function body before it gets munged by
18859 the NRV transformation. */
18862 /* Invoke the pre-genericize plugin before we start munging things. */
18866 /* Perform delayed folding before NRV transformation. */
18872 /* Set up the named return value optimization, if we can. Candidate
18873 variables are selected in check_return_expr. */
18875 {
18879 }
18881 /* Must mark the RESULT_DECL as being in this function. */
18884 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
18885 to the FUNCTION_DECL node itself. */
18888 /* Store the end of the function, so that we get good line number
18889 info for the epilogue. */
18892 /* Complain about parameters that are only set, but never otherwise used. */
18894 && !processing_template_decl
18897 {
18898 tree decl;
18901 decl;
18915 OPT_Wunused_but_set_parameter,
18918 }
18920 /* Complain about locally defined typedefs that are not used in this
18921 function. */
18924 /* Possibly warn about unused parameters. */
18926 && !processing_template_decl
18930 /* Genericize before inlining. */
18936 /* If this function can't throw any exceptions, remember that. */
18939 && !flag_non_call_exceptions
18944 /* Emit the resumer and destroyer functions now, providing that we have
18945 not encountered some fatal error. */
18947 {
18950 }
18952 cleanup:
18953 /* We're leaving the context of this function, so zap cfun. It's still in
18954 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
18958 /* If this is an in-class inline definition, we may have to pop the
18959 bindings for the template parameters that we added in
18960 maybe_begin_member_template_processing when start_function was
18961 called. */
18965 /* Leave the scope of the class. */
18971 /* Clean up. */
18974 /* If we have used outlined contracts checking functions, build and emit
18975 them here. */
18979 }
18980 \f
18981 /* Create the FUNCTION_DECL for a function definition.
18982 DECLSPECS and DECLARATOR are the parts of the declaration;
18983 they describe the return type and the name of the function,
18984 but twisted together in a fashion that parallels the syntax of C.
18986 This function creates a binding context for the function body
18987 as well as setting up the FUNCTION_DECL in current_function_decl.
18989 Returns a FUNCTION_DECL on success.
18991 If the DECLARATOR is not suitable for a function (it defines a datum
18992 instead), we return 0, which tells yyparse to report a parse error.
18994 May return void_type_node indicating that this method is actually
18995 a friend. See grokfield for more details.
18997 Came here with a `.pushlevel' .
18999 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
19000 CHANGES TO CODE IN `grokfield'. */
19002 tree
19005 {
19015 /* Pass friends other than inline friend functions back. */
19020 {
19025 }
19029 /* p1779 ABI-Isolation makes inline not a default for in-class
19030 definitions attached to a named module. If the user explicitly
19031 made it inline, grokdeclarator will already have done the right
19032 things. */
19034 || flag_module_implicit_inline
19035 /* Lambda's operator function remains inline. */
19037 /* If the user explicitly asked for this to be inline, we don't
19038 need to do more, but more importantly we want to warn if we
19039 can't inline it. */
19041 {
19045 /* It's ok if we can't inline this. */
19047 }
19049 /* We process method specializations in finish_struct_1. */
19051 {
19052 /* Avoid calling decl_spec_seq... until we have to. */
19057 }
19060 {
19063 }
19069 }
19070 \f
19072 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
19073 we can lay it out later, when and if its type becomes complete.
19075 Also handle constexpr variables where the initializer involves
19076 an unlowered PTRMEM_CST because the class isn't complete yet. */
19078 void
19080 {
19083 /* Keep track of variables with incomplete types. */
19086 {
19094 /* RTTI TD entries are created while defining the type_info. */
19097 {
19100 }
19106 {
19107 /* When the outermost open class is complete we can resolve any
19108 pointers-to-members. */
19112 }
19113 }
19114 }
19116 /* Called when a class type (given by TYPE) is defined. If there are
19117 any existing VAR_DECLs whose type has been completed by this
19118 declaration, update them now. */
19120 void
19122 {
19127 {
19129 {
19136 {
19137 /* Complete the type of the variable. */
19142 }
19144 /* Remove this entry from the list. */
19146 }
19147 else
19148 ix++;
19149 }
19150 }
19152 /* If DECL is of a type which needs a cleanup, build and return an
19153 expression to perform that cleanup here. Return NULL_TREE if no
19154 cleanup need be done. DECL can also be a _REF when called from
19155 split_nonconstant_init_1. */
19157 tree
19159 {
19160 tree type;
19161 tree attr;
19162 tree cleanup;
19164 /* Assume no cleanup is required. */
19170 /* Handle "__attribute__((cleanup))". We run the cleanup function
19171 before the destructor since the destructor is what actually
19172 terminates the lifetime of the object. */
19175 else
19178 {
19179 tree id;
19180 tree fn;
19181 tree arg;
19183 /* Get the name specified by the user for the cleanup function. */
19185 /* Look up the name to find the cleanup function to call. It is
19186 important to use lookup_name here because that is what is
19187 used in c-common.cc:handle_cleanup_attribute when performing
19188 initial checks on the attribute. Note that those checks
19189 include ensuring that the function found is not an overloaded
19190 function, or an object with an overloaded call operator,
19191 etc.; we can rely on the fact that the function found is an
19192 ordinary FUNCTION_DECL. */
19200 }
19201 /* Handle ordinary C++ destructors. */
19204 {
19206 tree addr;
19207 tree call;
19211 else
19225 else
19227 }
19229 /* build_delete sets the location of the destructor call to the
19230 current location, even though the destructor is going to be
19231 called later, at the end of the current scope. This can lead to
19232 a "jumpy" behavior for users of debuggers when they step around
19233 the end of the block. So let's unset the location of the
19234 destructor call instead. */
19242 /* Treat objects with destructors as used; the destructor may do
19243 something substantive. */
19252 }
19254 \f
19255 /* Return the FUNCTION_TYPE that corresponds to MEMFNTYPE, which can be a
19256 FUNCTION_DECL, METHOD_TYPE, FUNCTION_TYPE, pointer or reference to
19257 METHOD_TYPE or FUNCTION_TYPE, or pointer to member function. */
19259 tree
19261 {
19262 tree fntype;
19263 tree args;
19276 fntype = (cp_build_type_attribute_variant
19280 }
19282 /* DECL was originally constructed as a non-static member function,
19283 but turned out to be static. Update it accordingly. */
19285 void
19287 {
19300 }
19302 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
19303 one of the language-independent trees. */
19305 enum cp_tree_node_structure_enum
19307 {
19309 {
19327 }
19328 }
19330 bool
19332 {
19333 /* A missing noreturn is ok for the `main' function. */
19335 }
19337 /* Return the decl used to identify the COMDAT group into which DECL should
19338 be placed. */
19340 tree
19342 {
19343 /* Virtual tables, construction virtual tables, and virtual table
19344 tables all go in a single COMDAT group, named after the primary
19345 virtual table. */
19348 /* For all other DECLs, the COMDAT group is the mangled name of the
19349 declaration itself. */
19350 else
19351 {
19353 {
19354 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
19355 into the same section as the target function. In that case
19356 we must return target's name. */
19362 else
19364 }
19365 /* If a ctor/dtor has already set the comdat group by
19366 maybe_clone_body, don't override it. */
19372 }
19375 }
19377 /* Returns the return type for FN as written by the user, which may include
19378 a placeholder for a deduced return type. */
19380 tree
19382 {
19388 }
19390 /* Returns true iff DECL is a variable or function declared with an auto type
19391 that has not yet been deduced to a real type. */
19393 bool
19395 {
19402 }
19404 /* Complain if DECL has an undeduced return type. */
19406 bool
19408 {
19410 {
19414 {
19415 /* Set the return type of __builtin_source_location. */
19418 {
19421 }
19426 }
19434 }
19436 }
19438 /* Create a representation of the explicit-specifier with
19439 constant-expression of EXPR. COMPLAIN is as for tsubst. */
19441 tree
19443 {
19448 /* Wait for instantiation, tsubst_function_decl will handle it. */
19455 }