| blob | d606b31d7a7afeee1d5bbaf31aa074eb7dea3528 |
1 /* Process declarations and variables for -*- C++ -*- compiler.
2 Copyright (C) 1988-2023 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
10 any later version.
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
22 /* Process declarations and symbol lookup for C++ front end.
23 Also constructs types; the standard scalar types at initialization,
24 and structure, union, array and enum types when they are declared. */
26 /* ??? not all decl nodes are given the most useful possible
27 line numbers. For example, the CONST_DECLs for enum values. */
62 /* Possible cases of bad specifiers type used by bad_specifiers. */
67 BSP_FIELD /* field */
68 };
98 static tree check_special_function_return_type
107 /* The following symbols are subsumed in the cp_global_trees array, and
108 listed here individually for documentation purposes.
110 C++ extensions
111 tree wchar_decl_node;
113 tree vtable_entry_type;
114 tree delta_type_node;
115 tree __t_desc_type_node;
117 tree class_type_node;
118 tree unknown_type_node;
120 Array type `vtable_entry_type[]'
122 tree vtbl_type_node;
123 tree vtbl_ptr_type_node;
125 Namespaces,
127 tree std_node;
128 tree abi_node;
130 A FUNCTION_DECL which can call `abort'. Not necessarily the
131 one that the user will declare, but sufficient to be called
132 by routines that want to abort the program.
134 tree abort_fndecl;
136 Used by RTTI
137 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
138 tree tinfo_var_id; */
142 /* A list of objects which have constructors or destructors
143 which reside in namespace scope. The decl is stored in
144 the TREE_VALUE slot and the initializer is stored
145 in the TREE_PURPOSE slot. */
146 tree static_aggregates;
148 /* Like static_aggregates, but for thread_local variables. */
149 tree tls_aggregates;
151 /* A hash-map mapping from variable decls to the dynamic initializer for
152 the decl. This is currently only used by OpenMP. */
155 /* -- end of C++ */
157 /* A node for the integer constant 2. */
159 tree integer_two_node;
161 /* vector of static decls. */
164 /* vector of keyed classes. */
167 /* Used only for jumps to as-yet undefined labels, since jumps to
168 defined labels can have their validity checked immediately. */
172 /* The binding level to which this entry is *currently* attached.
173 This is initially the binding level in which the goto appeared,
174 but is modified as scopes are closed. */
176 /* The head of the names list that was current when the goto appeared,
177 or the inner scope popped. These are the decls that will *not* be
178 skipped when jumping to the label. */
179 tree names_in_scope;
180 /* The location of the goto, for error reporting. */
181 location_t o_goto_locus;
182 /* True if an OpenMP structured block scope has been closed since
183 the goto appeared. This means that the branch from the label will
184 illegally exit an OpenMP scope. */
186 };
188 /* A list of all LABEL_DECLs in the function that have names. Here so
189 we can clear out their names' definitions at the end of the
190 function, and so we can check the validity of jumps to these labels. */
200 /* The binding level to which the label is *currently* attached.
201 This is initially set to the binding level in which the label
202 is defined, but is modified as scopes are closed. */
205 /* The head of the names list that was current when the label was
206 defined, or the inner scope popped. These are the decls that will
207 be skipped when jumping to the label. */
208 tree names_in_scope;
210 /* A vector of all decls from all binding levels that would be
211 crossed by a backward branch to the label. */
214 /* A list of uses of the label, before the label is defined. */
217 /* The following bits are set after the label is defined, and are
218 updated as scopes are popped. They indicate that a jump to the
219 label will illegally enter a scope of the given flavor. */
227 };
229 #define named_labels cp_function_chain->x_named_labels
230 \f
231 /* The number of function bodies which we are currently processing.
232 (Zero if we are at namespace scope, one inside the body of a
233 function, two inside the body of a function in a local class, etc.) */
236 /* Whether the exception-specifier is part of a function type (i.e. C++17). */
239 /* States indicating how grokdeclarator() should handle declspecs marked
240 with __attribute__((deprecated)). An object declared as
241 __attribute__((deprecated)) suppresses warnings of uses of other
242 deprecated items. */
245 \f
246 /* A list of VAR_DECLs whose type was incomplete at the time the
247 variable was declared. */
250 tree decl;
251 tree incomplete_type;
252 };
256 \f
257 /* Returns the kind of template specialization we are currently
258 processing, given that it's declaration contained N_CLASS_SCOPES
259 explicit scope qualifications. */
261 tmpl_spec_kind
263 {
269 /* Scan through the template parameter scopes. */
273 {
274 /* If we see a specialization scope inside a parameter scope,
275 then something is wrong. That corresponds to a declaration
276 like:
278 template <class T> template <> ...
280 which is always invalid since [temp.expl.spec] forbids the
281 specialization of a class member template if the enclosing
282 class templates are not explicitly specialized as well. */
284 {
287 else
289 }
294 }
296 /* Handle explicit instantiations. */
298 {
300 /* We've seen a template parameter list during an explicit
301 instantiation. For example:
303 template <class T> template void f(int);
305 This is erroneous. */
307 else
309 }
312 /* We've not seen enough template headers to match all the
313 specialized classes present. For example:
315 template <class T> void R<T>::S<T>::f(int);
317 This is invalid; there needs to be one set of template
318 parameters for each class. */
321 /* We're processing a non-template declaration (even though it may
322 be a member of a template class.) For example:
324 template <class T> void S<T>::f(int);
326 The `class T' matches the `S<T>', leaving no template headers
327 corresponding to the `f'. */
330 /* We've got too many template headers. For example:
332 template <> template <class T> void f (T);
334 There need to be more enclosing classes. */
336 else
337 /* This must be a template. It's of the form:
339 template <class T> template <class U> void S<T>::f(U);
341 This is a specialization if the innermost level was a
342 specialization; otherwise it's just a definition of the
343 template. */
345 }
347 /* Exit the current scope. */
349 void
351 {
353 }
355 /* When a label goes out of scope, check to see if that label was used
356 in a valid manner, and issue any appropriate warnings or errors. */
358 static void
360 {
362 {
364 {
365 location_t location;
369 /* FIXME want (LOCATION_FILE (input_location), (line)0) */
370 /* Avoid crashing later. */
372 }
373 else
375 }
376 }
378 /* Helper function to sort named label entries in a vector by DECL_UID. */
380 static int
382 {
386 /* DECL_UIDs can never be equal. */
388 }
390 /* At the end of a function, all labels declared within the function
391 go out of scope. BLOCK is the top-level block for the
392 function. */
394 static void
396 {
400 /* We need to add the labels to the block chain, so debug
401 information is emitted. But, we want the order to be stable so
402 need to sort them first. Otherwise the debug output could be
403 randomly ordered. I guess it's mostly stable, unless the hash
404 table implementation changes. */
409 {
416 }
421 {
428 }
429 }
431 /* At the end of a block with local labels, restore the outer definition. */
433 static void
435 {
443 else
444 {
447 }
449 }
451 /* The following two routines are used to interface to Objective-C++.
452 The binding level is purposely treated as an opaque type. */
456 {
458 }
460 /* The following routine is used by the NeXT-style SJLJ exceptions;
461 variables get marked 'volatile' so as to not be clobbered by
462 _setjmp()/_longjmp() calls. All variables in the current scope,
463 as well as parent scopes up to (but not including) ENCLOSING_BLK
464 shall be thusly marked. */
466 void
468 {
474 {
475 tree decl;
480 /* Do not climb up past the current function. */
483 }
484 }
486 /* True if B is the level for the condition of a constexpr if. */
488 static bool
490 {
494 }
496 /* True if B is the level for the condition of a consteval if. */
498 static bool
500 {
504 }
506 /* Update data for defined and undefined labels when leaving a scope. */
508 int
510 {
515 {
516 tree decl;
518 /* ENT->NAMES_IN_SCOPE may contain a mixture of DECLs and
519 TREE_LISTs representing OVERLOADs, so be careful. */
529 {
553 }
554 }
556 {
561 {
566 }
567 }
570 }
572 /* Saved errorcount to avoid -Wunused-but-set-{parameter,variable} warnings
573 when errors were reported, except for -Werror-unused-but-set-*. */
576 /* Exit a binding level.
577 Pop the level off, and restore the state of the identifier-decl mappings
578 that were in effect when this level was entered.
580 If KEEP == 1, this level had explicit declarations, so
581 and create a "block" (a BLOCK node) for the level
582 to record its declarations and subblocks for symbol table output.
584 If FUNCTIONBODY is nonzero, this level is the body of a function,
585 so create a block as if KEEP were set and also clear out all
586 label names.
588 If REVERSE is nonzero, reverse the order of decls before putting
589 them into the BLOCK. */
591 tree
593 {
594 tree link;
595 /* The chain of decls was accumulated in reverse order.
596 Put it into forward order, just for cleanliness. */
597 tree decls;
598 tree subblocks;
599 tree block;
600 tree decl;
601 scope_kind kind;
604 restart:
617 /* We used to use KEEP == 2 to indicate that the new block should go
618 at the beginning of the list of blocks at this binding level,
619 rather than the end. This hack is no longer used. */
625 /* Any uses of undefined labels, and any defined labels, now operate
626 under constraints of next binding contour. */
631 /* Get the decls in the order they were written.
632 Usually current_binding_level->names is in reverse order.
633 But parameter decls were previously put in forward order. */
637 {
640 }
642 /* If there were any declarations or structure tags in that level,
643 or if this level is a function body,
644 create a BLOCK to record them for the life of this function. */
646 /* Avoid function body block if possible. */
652 {
655 }
657 /* In each subblock, record that this is its superior. */
662 /* Before we remove the declarations first check for unused variables. */
667 {
668 /* There are cases where D itself is a TREE_LIST. See in
669 push_local_binding where the list of decls returned by
670 getdecls is built. */
677 /* For structured bindings, consider only real variables, not
678 subobjects. */
686 {
688 {
691 OPT_Wunused_variable,
693 else
696 }
698 // For -Wunused-but-set-variable leave references alone.
701 {
706 else
708 OPT_Wunused_but_set_variable,
711 }
712 }
713 }
715 /* Remove declarations for all the DECLs in this level. */
717 {
718 tree name;
720 {
724 }
725 else
726 {
729 }
731 /* Remove the binding. */
734 else
736 }
738 /* Restore the IDENTIFIER_TYPE_VALUEs. */
743 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
744 list if a `using' declaration put them there. The debugging
745 back ends won't understand OVERLOAD, so we remove them here.
746 Because the BLOCK_VARS are (temporarily) shared with
747 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
748 popped all the bindings. Also remove undeduced 'auto' decls,
749 which LTO doesn't understand, and can't have been used by anything. */
751 {
755 {
757 || (!processing_template_decl
760 else
762 }
763 }
765 /* If the level being exited is the top level of a function,
766 check over all the labels. */
768 {
770 {
771 /* Since this is the top level block of a function, the vars are
772 the function's parameters. Don't leave them in the BLOCK
773 because they are found in the FUNCTION_DECL instead. */
776 }
777 else
779 }
783 {
784 tree stmt;
786 /* If this is a temporary binding created for a cleanup, then we'll
787 have pushed a statement list level. Pop that, create a new
788 BIND_EXPR for the block, and insert it into the stream. */
792 }
796 {
797 /* The current function is being defined, so its DECL_INITIAL
798 should be error_mark_node. */
802 {
804 {
807 }
808 else
810 }
811 }
813 current_binding_level->blocks
816 /* If we did not make a block for the level just exited,
817 any blocks made for inner levels
818 (since they cannot be recorded as subblocks in that level)
819 must be carried forward so they will later become subblocks
820 of something else. */
822 current_binding_level->blocks
825 /* Each and every BLOCK node created here in `poplevel' is important
826 (e.g. for proper debugging information) so if we created one
827 earlier, mark it as "used". */
831 /* All temporary bindings created for cleanups are popped silently. */
836 }
838 /* Call wrapup_globals_declarations for the globals in NAMESPACE. */
839 /* Diagnose odr-used extern inline variables without definitions
840 in the current TU. */
842 int
844 {
846 {
848 {
858 OPT_Wunused_function,
867 }
869 /* Clear out the list, so we don't rescan next time. */
872 /* Write out any globals that need to be output. */
875 }
877 }
878 \f
879 /* In C++, you don't have to write `struct S' to refer to `S'; you
880 can just use `S'. We accomplish this by creating a TYPE_DECL as
881 if the user had written `typedef struct S S'. Create and return
882 the TYPE_DECL for TYPE. */
884 tree
886 {
887 tree decl;
891 /* There are other implicit type declarations, like the one *within*
892 a class that allows you to write `S::S'. We must distinguish
893 amongst these. */
899 }
901 /* Function-scope local entities that need discriminators. Each entry
902 is a {decl,name} pair. VAR_DECLs for anon unions get their name
903 smashed, so we cannot rely on DECL_NAME. */
907 /* Determine the mangling discriminator of local DECL. There are
908 generally very few of these in any particular function. */
910 void
912 {
921 {
929 {
935 /* Replace the saved decl. */
939 }
940 }
943 {
947 }
948 }
950 \f
952 /* Returns true if functions FN1 and FN2 have equivalent trailing
953 requires clauses. */
955 static bool
957 {
958 /* In the concepts TS, the combined constraints are compared. */
960 {
966 }
968 /* Compare only trailing requirements. */
974 /* Substitution is needed when friends are involved. */
979 }
981 /* Two functions of the same name correspond [basic.scope.scope] if
983 + both declare functions with the same non-object-parameter-type-list,
984 equivalent ([temp.over.link]) trailing requires-clauses (if any, except as
985 specified in [temp.friend]), and, if both are non-static members, they have
986 corresponding object parameters, or
988 + both declare function templates with equivalent
989 non-object-parameter-type-lists, return types (if any), template-heads, and
990 trailing requires-clauses (if any), and, if both are non-static members,
991 they have corresponding object parameters.
993 This is a subset of decls_match: it identifies declarations that cannot be
994 overloaded with one another. This function does not consider DECL_NAME. */
996 bool
998 {
1003 {
1008 }
1016 /* If only one is a non-static member function, ignore ref-quals. */
1019 /* Two non-static member functions have corresponding object parameters if:
1020 + exactly one is an implicit object member function with no ref-qualifier
1021 and the types of their object parameters ([dcl.fct]), after removing
1022 top-level references, are the same, or
1023 + their object parameters have the same type. */
1024 /* ??? We treat member functions of different classes as corresponding even
1025 though that means the object parameters have different types. */
1032 {
1036 }
1038 /* Two function declarations match if either has a requires-clause
1039 then both have a requires-clause and their constraints-expressions
1040 are equivalent. */
1045 }
1047 /* Subroutine of duplicate_decls: return truthvalue of whether
1048 or not types of these decls match.
1050 For C++, we must compare the parameter list so that `int' can match
1051 `int&' in a parameter position, but `int&' is not confused with
1052 `const int&'. */
1054 int
1056 {
1063 /* If the two DECLs are not even the same kind of thing, we're not
1064 interested in their types. */
1070 {
1071 /* Specializations of different templates are different functions
1072 even if they have the same type. */
1087 /* A new declaration doesn't match a built-in one unless it
1088 is also extern "C". */
1098 /* A declaration with deduced return type should use its pre-deduction
1099 type for declaration matching. */
1107 {
1110 {
1114 }
1115 else
1116 types_match =
1122 }
1123 else
1126 /* Two function declarations match if either has a requires-clause
1127 then both have a requires-clause and their constraints-expressions
1128 are equivalent. */
1132 /* The decls dont match if they correspond to two different versions
1133 of the same function. Disallow extern "C" functions to be
1134 versions for now. */
1139 {
1145 }
1146 }
1148 {
1158 /* Two template types match if they are the same. Otherwise, compare
1159 the underlying declarations. */
1162 else
1164 }
1165 else
1166 {
1167 /* Need to check scope for variable declaration (VAR_DECL).
1168 For typedef (TYPE_DECL), scope is ignored. */
1171 /* [dcl.link]
1172 Two declarations for an object with C language linkage
1173 with the same name (ignoring the namespace that qualify
1174 it) that appear in different namespace scopes refer to
1175 the same object. */
1185 else
1188 COMPARE_REDECLARATION);
1189 }
1192 }
1194 /* Mark DECL as versioned if it isn't already. */
1196 static void
1198 {
1200 {
1202 /* If DECL_ASSEMBLER_NAME has already been set, re-mangle
1203 to include the version marker. */
1206 }
1207 }
1209 /* NEWDECL and OLDDECL have identical signatures. If they are
1210 different versions adjust them and return true.
1211 If RECORD is set to true, record function versions. */
1213 bool
1215 {
1221 {
1224 }
1228 {
1229 /* Unfortunately, we can get here before pushdecl naturally calls
1230 push_local_extern_decl_alias, so we need to call it directly. */
1235 }
1241 }
1243 /* If NEWDECL is `static' and an `extern' was seen previously,
1244 warn about it. OLDDECL is the previous declaration.
1246 Note that this does not apply to the C++ case of declaring
1247 a variable `extern const' and then later `const'.
1249 Don't complain about built-in functions, since they are beyond
1250 the user's control. */
1252 void
1254 {
1261 /* Don't get confused by static member functions; that's a different
1262 use of `static'. */
1267 /* If the old declaration was `static', or the new one isn't, then
1268 everything is OK. */
1272 /* It's OK to declare a builtin function as `static'. */
1277 auto_diagnostic_group d;
1282 }
1284 /* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1285 function templates. If their exception specifications do not
1286 match, issue a diagnostic. */
1288 static void
1290 tree old_decl)
1291 {
1295 /* Two default specs are equivalent, don't force evaluation. */
1301 {
1304 }
1308 /* [except.spec]
1310 If any declaration of a function has an exception-specification,
1311 all declarations, including the definition and an explicit
1312 specialization, of that function shall have an
1313 exception-specification with the same set of type-ids. */
1317 {
1322 auto_diagnostic_group d;
1326 /* We used to silently permit mismatched eh specs with
1327 -fno-exceptions, so make them a pedwarn now. */
1329 else
1334 }
1335 }
1337 /* Return true if OLD_DECL and NEW_DECL agree on constexprness.
1338 Otherwise issue diagnostics. */
1340 static bool
1342 {
1350 {
1356 }
1358 {
1359 /* With -fimplicit-constexpr, ignore changes in the constexpr
1360 keyword. */
1366 {
1367 /* Hide a built-in declaration. */
1373 }
1374 /* 7.1.5 [dcl.constexpr]
1375 Note: An explicit specialization can differ from the template
1376 declaration with respect to the constexpr specifier. */
1386 "redeclaration %qD differs in %qs "
1388 kind);
1392 }
1394 }
1396 // If OLDDECL and NEWDECL are concept declarations with the same type
1397 // (i.e., and template parameters), but different requirements,
1398 // emit diagnostics and return true. Otherwise, return false.
1401 {
1413 {
1418 {
1421 }
1422 }
1424 }
1426 /* DECL is a redeclaration of a function or function template. If
1427 it does have default arguments issue a diagnostic. Note: this
1428 function is used to enforce the requirements in C++11 8.3.6 about
1429 no default arguments in redeclarations. */
1431 static void
1433 {
1439 {
1441 "redeclaration of %q#D may not have default "
1444 }
1445 }
1447 /* NEWDECL is a redeclaration of a function or function template OLDDECL,
1448 in any case represented as FUNCTION_DECLs (the DECL_TEMPLATE_RESULTs of
1449 the TEMPLATE_DECLs in case of function templates). This function is used
1450 to enforce the final part of C++17 11.3.6/4, about a single declaration:
1451 "If a friend declaration specifies a default argument expression, that
1452 declaration shall be a definition and shall be the only declaration of
1453 the function or function template in the translation unit." */
1455 static void
1457 {
1467 {
1468 auto_diagnostic_group d;
1470 "friend declaration of %q#D specifies default "
1475 }
1476 }
1478 /* Merge tree bits that correspond to attributes noreturn, nothrow,
1479 const, malloc, and pure from NEWDECL with those of OLDDECL. */
1481 static void
1483 {
1496 }
1498 #define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn) \
1500 DECL_ATTRIBUTES (fn)))
1502 /* A subroutine of duplicate_decls. Emits a diagnostic when newdecl
1503 ambiguates olddecl. Returns true if an error occurs. */
1505 static bool
1507 {
1511 /* Function template declarations can be differentiated by parameter
1512 and return type. */
1517 {
1518 /* ... and also by their template-heads and requires-clauses. */
1521 {
1526 }
1528 /* FIXME: The types are the same but the are differences
1529 in either the template heads or function requirements.
1530 We should be able to diagnose a set of common errors
1531 stemming from these declarations. For example:
1533 template<typename T> requires C void f(...);
1534 template<typename T> void f(...) requires C;
1536 These are functionally equivalent but not equivalent. */
1537 }
1540 }
1542 /* OLD_PARMS is the innermost set of template parameters for some template
1543 declaration, and NEW_PARMS is the corresponding set of template parameters
1544 for a redeclaration of that template. Merge the default arguments within
1545 these two sets of parameters. CLASS_P is true iff the template in
1546 question is a class template. */
1548 bool
1550 {
1554 {
1562 {
1563 auto_diagnostic_group d;
1568 }
1570 /* Update the previous template parameters (which are the ones
1571 that will really count) with the new default value. */
1574 /* Update the new parameters, too; they'll be used as the
1575 parameters for any members. */
1577 }
1579 }
1581 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1582 If the redeclaration is invalid, a diagnostic is issued, and the
1583 error_mark_node is returned. Otherwise, OLDDECL is returned.
1585 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1586 returned.
1588 HIDING is true if the new decl is being hidden. WAS_HIDDEN is true
1589 if the old decl was hidden.
1591 Hidden decls can be anticipated builtins, injected friends, or
1592 (coming soon) injected from a local-extern decl. */
1594 tree
1596 {
1600 tree new_template_info;
1609 /* If either the type of the new decl or the type of the old decl is an
1610 error_mark_node, then that implies that we have already issued an
1611 error (earlier) for some bogus type specification, and in that case,
1612 it is rather pointless to harass the user with yet more error message
1613 about the same declaration, so just pretend the types match here. */
1618 /* Check for redeclaration and other discrepancies. */
1621 {
1623 {
1624 /* Avoid warnings redeclaring built-ins which have not been
1625 explicitly declared. */
1627 {
1631 OPT_Wbuiltin_declaration_mismatch,
1633 newdecl);
1635 }
1637 /* If you declare a built-in or predefined function name as static,
1638 the old definition is overridden, but optionally warn this was a
1639 bad choice of name. */
1641 {
1643 OPT_Wshadow,
1647 /* Discard the old built-in function. */
1649 }
1650 /* If the built-in is not ansi, then programs can override
1651 it even globally without an error. */
1656 else
1658 "declaration of %q#D conflicts with built-in "
1661 }
1663 {
1664 /* Avoid warnings redeclaring built-ins which have not been
1665 explicitly declared. */
1667 {
1670 /* A new declaration doesn't match a built-in one unless it
1671 is also extern "C". */
1681 {
1684 /* FILE, tm types are not known at the time
1685 we create the builtins. */
1691 {
1698 {
1708 }
1710 }
1714 next_arg:;
1715 }
1718 OPT_Wbuiltin_declaration_mismatch,
1719 "declaration of %q#D conflicts with built-in "
1721 }
1726 {
1727 /* Don't really override olddecl for __* prefixed builtins
1728 except for __[^b]*_chk, the compiler might be using those
1729 explicitly. */
1731 {
1742 {
1744 {
1746 "definition of %q#D ambiguates built-in "
1749 }
1750 auto_diagnostic_group d;
1752 "new declaration %q#D ambiguates built-in"
1758 }
1759 }
1761 /* A near match; override the builtin. */
1765 OPT_Wbuiltin_declaration_mismatch,
1766 "new declaration %q#D ambiguates built-in "
1768 else
1773 }
1774 else
1775 /* Discard the old built-in function. */
1778 /* Replace the old RTL to avoid problems with inlining. */
1780 }
1781 else
1782 {
1783 /* Even if the types match, prefer the new declarations type
1784 for built-ins which have not been explicitly declared,
1785 for exception lists, etc... */
1792 }
1794 /* If a function is explicitly declared "throw ()", propagate that to
1795 the corresponding builtin. */
1797 && was_hidden
1800 {
1805 }
1807 /* Whether or not the builtin can throw exceptions has no
1808 bearing on this declarator. */
1812 {
1813 /* If a builtin function is redeclared as `static', merge
1814 the declarations, but make the original one static. */
1818 /* Make the old declaration consistent with the new one so
1819 that all remnants of the builtin-ness of this function
1820 will be banished. */
1823 }
1824 }
1826 {
1827 /* C++ Standard, 3.3, clause 4:
1828 "[Note: a namespace name or a class template name must be unique
1829 in its declarative region (7.3.2, clause 14). ]" */
1850 {
1851 /* One is a function and the other is a template
1852 function. */
1856 /* There can only be one! */
1860 "literal operator %q#D conflicts with"
1864 "raw literal operator %q#D conflicts with"
1866 else
1871 }
1877 /* One is an implicit typedef, that's ok. */
1884 }
1886 {
1888 /* These are certainly not duplicate declarations; they're
1889 from different scopes. */
1893 {
1897 /* The name of a class template may not be declared to refer to
1898 any other template, class, function, object, namespace, value,
1899 or type in the same scope. */
1902 {
1908 }
1912 {
1916 }
1920 }
1922 {
1924 {
1927 newdecl);
1931 }
1932 /* For function versions, params and types match, but they
1933 are not ambiguous. */
1936 // The functions have the same parameter types.
1939 // And the same constraints.
1941 {
1947 }
1948 else
1950 }
1951 else
1952 {
1957 }
1958 }
1961 {
1962 /* OMP UDRs are never duplicates. */
1969 }
1979 /* It's OK to have a template specialization and a non-template
1980 with the same type, or to have specializations of two
1981 different templates with the same type. Note that if one is a
1982 specialization, and the other is an instantiation of the same
1983 template, that we do not exit at this point. That situation
1984 can occur if we instantiate a template class, and then
1985 specialize one of its methods. This situation is valid, but
1986 the declarations must be merged in the usual way. */
1993 /* One of the declarations is a template instantiation, and the
1994 other is not a template at all. That's OK. */
1997 {
1998 /* In [namespace.alias] we have:
2000 In a declarative region, a namespace-alias-definition can be
2001 used to redefine a namespace-alias declared in that declarative
2002 region to refer only to the namespace to which it already
2003 refers.
2005 Therefore, if we encounter a second alias directive for the same
2006 alias, we can just ignore the second directive. */
2012 /* Leave it to update_binding to merge or report error. */
2014 }
2015 else
2016 {
2019 {
2020 auto_diagnostic_group d;
2028 }
2033 {
2034 /* Prototype decl follows defn w/o prototype. */
2035 auto_diagnostic_group d;
2040 }
2043 {
2044 /* [dcl.link]
2045 If two declarations of the same function or object
2046 specify different linkage-specifications ..., the program
2047 is ill-formed.... Except for functions with C++ linkage,
2048 a function declaration without a linkage specification
2049 shall not precede the first linkage specification for
2050 that function. A function can be declared without a
2051 linkage specification after an explicit linkage
2052 specification has been seen; the linkage explicitly
2053 specified in the earlier declaration is not affected by
2054 such a function declaration.
2056 DR 563 raises the question why the restrictions on
2057 functions should not also apply to objects. Older
2058 versions of G++ silently ignore the linkage-specification
2059 for this example:
2061 namespace N {
2062 extern int i;
2063 extern "C" int i;
2064 }
2066 which is clearly wrong. Therefore, we now treat objects
2067 like functions. */
2069 {
2070 /* There is no explicit linkage-specification, so we use
2071 the linkage from the previous declaration. */
2074 }
2075 else
2076 {
2077 auto_diagnostic_group d;
2084 }
2085 }
2088 ;
2090 {
2091 /* Note: free functions, as TEMPLATE_DECLs, are handled below. */
2094 as FUNCTION_DECLs. */
2096 /* C++11 8.3.6/6.
2097 Default arguments for a member function of a class
2098 template shall be specified on the initial declaration
2099 of the member function within the class template. */
2101 {
2106 {
2110 tree old_parms
2114 }
2115 }
2116 else
2117 {
2125 {
2128 {
2129 auto_diagnostic_group d;
2131 "default argument given for parameter "
2135 olddecl);
2136 }
2137 else
2138 {
2139 auto_diagnostic_group d;
2141 "default argument given for parameter %d "
2145 olddecl);
2146 }
2147 }
2149 /* C++17 11.3.6/4: "If a friend declaration specifies a default
2150 argument expression, that declaration... shall be the only
2151 declaration of the function or function template in the
2152 translation unit." */
2154 }
2155 }
2156 }
2158 /* Do not merge an implicit typedef with an explicit one. In:
2160 class A;
2161 ...
2162 typedef class A A __attribute__ ((foo));
2164 the attribute should apply only to the typedef. */
2180 {
2182 {
2185 else
2186 {
2189 }
2192 }
2196 {
2199 {
2202 }
2203 }
2206 }
2208 /* We have committed to returning OLDDECL at this point. */
2210 /* If new decl is `static' and an `extern' was seen previously,
2211 warn about it. */
2214 /* True to merge attributes between the declarations, false to
2215 set OLDDECL's attributes to those of NEWDECL (for template
2216 explicit specializations that specify their own attributes
2217 independent of those specified for the primary template). */
2223 {
2225 {
2231 /* [dcl.attr.noreturn]: The first declaration of a function shall
2232 specify the noreturn attribute if any declaration of that function
2233 specifies the noreturn attribute. */
2234 tree a;
2237 /* This applies to [[noreturn]] only, not its GNU variants. */
2241 {
2245 }
2246 }
2248 /* Now that functions must hold information normally held
2249 by field decls, there is extra work to do so that
2250 declaration information does not get destroyed during
2251 definition. */
2273 /* Optionally warn about more than one declaration for the same
2274 name, but don't warn about a function declaration followed by a
2275 definition. */
2278 /* Don't warn about extern decl followed by definition. */
2280 /* Don't warn if at least one is/was hidden. */
2282 /* Don't warn about declaration followed by specialization. */
2285 {
2286 auto_diagnostic_group d;
2288 OPT_Wredundant_decls,
2290 newdecl))
2293 }
2295 /* [dcl.fct.def.delete] A deleted definition of a function shall be the
2296 first declaration of the function or, for an explicit specialization
2297 of a function template, the first declaration of that
2298 specialization. */
2301 {
2303 {
2304 auto_diagnostic_group d;
2309 }
2311 }
2312 }
2314 /* Deal with C++: must preserve virtual function table size. */
2316 {
2326 }
2328 /* Copy all the DECL_... slots specified in the new decl except for
2329 any that we copy here from the old type. */
2333 else
2337 {
2342 /* The new decl should not already have gathered any
2343 specializations. */
2346 /* Make sure the contracts are equivalent. */
2349 /* Remove contracts from old_result so they aren't appended to
2350 old_result by the merge function. */
2357 {
2360 {
2361 /* Per C++11 8.3.6/4, default arguments cannot be added in
2362 later declarations of a function template. */
2364 /* C++17 11.3.6/4: "If a friend declaration specifies a default
2365 argument expression, that declaration... shall be the only
2366 declaration of the function or function template in the
2367 translation unit." */
2368 check_no_redeclaration_friend_default_args
2375 }
2383 {
2386 else
2397 }
2398 else
2399 {
2407 }
2408 }
2410 /* If the new declaration is a definition, update the file and
2411 line information on the declaration, and also make
2412 the old declaration the same definition. */
2414 {
2420 {
2427 }
2428 }
2431 }
2434 {
2438 /* Automatically handles default parameters. */
2440 tree newtype;
2442 /* For typedefs use the old type, as the new type's DECL_NAME points
2443 at newdecl, which will be ggc_freed. */
2445 {
2446 /* But NEWTYPE might have an attribute, honor that. */
2451 {
2455 }
2457 /* And remove the new type from the variants list. */
2459 {
2462 {
2464 /* If remove is the main variant, no need to remove that
2465 from the list. One of the DECL_ORIGINAL_TYPE
2466 variants, e.g. created for aligned attribute, might still
2467 refer to the newdecl TYPE_DECL though, so remove that one
2468 in that case. */
2474 {
2478 }
2479 }
2480 else
2484 {
2487 }
2488 }
2489 }
2492 else
2496 {
2498 /* For already initialized vars, TREE_READONLY could have been
2499 cleared in cp_finish_decl, because the var needs runtime
2500 initialization or destruction. Make sure not to set
2501 TREE_READONLY on it again. */
2518 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
2521 {
2522 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
2525 }
2526 }
2528 /* An explicit specialization of a function template or of a member
2529 function of a class template can be declared transaction_safe
2530 independently of whether the corresponding template entity is declared
2531 transaction_safe. */
2544 /* Lay the type out, unless already done. */
2558 /* Merge deprecatedness. */
2562 /* Merge unavailability. */
2566 /* Preserve function specific target and optimization options */
2568 {
2581 }
2582 else
2583 {
2584 /* Merge the const type qualifier. */
2587 /* Merge the volatile type qualifier. */
2590 }
2592 /* Merge the initialization information. */
2595 {
2599 {
2602 }
2603 }
2606 {
2619 else
2620 {
2621 /* Merge the noreturn bit. */
2627 }
2628 /* Keep the old RTL. */
2630 }
2633 {
2634 /* Keep the old RTL. We cannot keep the old RTL if the old
2635 declaration was for an incomplete object and the new
2636 declaration is not since many attributes of the RTL will
2637 change. */
2639 }
2640 }
2641 /* If cannot merge, then use the new type and qualifiers,
2642 and don't preserve the old rtl. */
2643 else
2644 {
2645 /* Clean out any memory we had of the old declaration. */
2655 }
2657 /* Merge the storage class information. */
2669 {
2671 /* This can happen if olddecl was brought in from the
2672 enclosing namespace via a using-decl. The new decl is
2673 then not a block-scope extern at all. */
2675 else
2676 {
2684 }
2685 }
2689 {
2701 {
2705 }
2708 {
2713 /* If the OLDDECL is an instantiation and/or specialization,
2714 then the NEWDECL must be too. But, it may not yet be marked
2715 as such if the caller has created NEWDECL, but has not yet
2716 figured out that it is a redeclaration. */
2723 }
2725 /* Don't really know how much of the language-specific
2726 values we should copy from old to new. */
2730 {
2733 {
2737 /* Remember the presence of explicit specialization args. */
2740 }
2742 /* We don't want to copy template info from a non-templated friend
2743 (PR105761), but these shouldn't have DECL_TEMPLATE_INFO now. */
2747 }
2750 {
2751 /* Only functions have these fields. */
2756 /* DECL_THUNKS is only valid for virtual functions,
2757 otherwise it is a DECL_FRIEND_CONTEXT. */
2762 }
2764 {
2765 /* Only variables have this field. */
2768 }
2769 }
2772 {
2773 tree parm;
2775 /* Merge parameter attributes. */
2780 {
2784 }
2788 {
2789 /* If newdecl is not a specialization, then it is not a
2790 template-related function at all. And that means that we
2791 should have exited above, returning 0. */
2795 /* From [temp.expl.spec]:
2797 If a template, a member template or the member of a class
2798 template is explicitly specialized then that
2799 specialization shall be declared before the first use of
2800 that specialization that would cause an implicit
2801 instantiation to take place, in every translation unit in
2802 which such a use occurs. */
2804 olddecl);
2810 /* Don't propagate visibility from the template to the
2811 specialization here. We'll do that in determine_visibility if
2812 appropriate. */
2815 /* [temp.expl.spec/14] We don't inline explicit specialization
2816 just because the primary template says so. */
2826 }
2828 {
2829 /* Never inline re-defined extern inline functions.
2830 FIXME: this could be better handled by keeping both
2831 function as separate declarations. */
2833 }
2834 else
2835 {
2837 {
2841 }
2843 ;
2857 }
2859 /* Preserve abstractness on cloned [cd]tors. */
2862 /* Update newdecl's parms to point at olddecl. */
2868 {
2872 }
2874 {
2875 /* These are the final DECL_ARGUMENTS that will be used within the
2876 body; update any references to old DECL_ARGUMENTS in the
2877 contracts, if present. */
2881 /* These need to be copied so that the names are available.
2882 Note that if the types do match, we'll preserve inline
2883 info and other bits, but if not, we won't. */
2887 /* In some cases, duplicate_contracts will remove contracts from
2888 OLDDECL, to avoid duplications. Sometimes, the contracts end up
2889 shared. If we removed them, re-add them. */
2892 }
2893 /* If redeclaring a builtin function, it stays built in
2894 if newdecl is a gnu_inline definition, or if newdecl is just
2895 a declaration. */
2898 {
2900 /* If we're keeping the built-in definition, keep the rtl,
2901 regardless of declaration matches. */
2904 {
2907 {
2908 /* A compatible prototype of these builtin functions
2909 is seen, assume the runtime implements it with
2910 the expected semantics. */
2912 {
2919 }
2920 }
2923 }
2924 }
2926 /* If defining a function declared with other language
2927 linkage, use the previously declared language linkage. */
2930 {
2932 /* Don't clear out the arguments if we're just redeclaring a
2933 function. */
2935 {
2936 /* If we removed contracts from previous definition, re-attach
2937 them. Otherwise, rewrite the contracts so they match the
2938 parameters of the new declaration. */
2943 else
2944 {
2945 /* Temporarily undo the re-contexting of parameters so we can
2946 actually remap parameters. The inliner won't replace
2947 parameters if we don't do this. */
2952 /* Save new argument names for use in contracts parsing,
2953 unless we've already started parsing the body of olddecl
2954 (particular issues arise when newdecl is from a prior
2955 friend decl with no argument names, see
2956 modules/contracts-tpl-friend-1). */
2960 /* And reverse this operation again. */
2963 }
2966 }
2967 }
2968 }
2972 /* Now preserve various other info from the definition. */
2978 /* Warn about conflicting visibility specifications. */
2982 {
2983 auto_diagnostic_group d;
2985 "%qD: visibility attribute ignored because it "
2989 }
2990 /* Choose the declaration which specified visibility. */
2992 {
2995 }
2996 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
2997 so keep this behavior. */
2999 {
3002 }
3003 /* Likewise for DECL_ALIGN, DECL_USER_ALIGN and DECL_PACKED. */
3005 {
3008 }
3021 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
3022 with that from NEWDECL below. */
3024 {
3028 }
3030 /* Merge the USED information. */
3037 {
3042 }
3049 /* Merge the DECL_FUNCTION_VERSIONED information. newdecl will be copied
3050 to olddecl and deleted. */
3053 {
3054 /* Set the flag for newdecl so that it gets copied to olddecl. */
3056 /* newdecl will be purged after copying to olddecl and is no longer
3057 a version. */
3059 }
3062 {
3076 /* Preserve symtab node mapping. */
3080 /* If newdecl is a template instantiation, it is possible that
3081 the following sequence of events has occurred:
3083 o A friend function was declared in a class template. The
3084 class template was instantiated.
3086 o The instantiation of the friend declaration was
3087 recorded on the instantiation list, and is newdecl.
3089 o Later, however, instantiate_class_template called pushdecl
3090 on the newdecl to perform name injection. But, pushdecl in
3091 turn called duplicate_decls when it discovered that another
3092 declaration of a global function with the same name already
3093 existed.
3095 o Here, in duplicate_decls, we decided to clobber newdecl.
3097 If we're going to do that, we'd better make sure that
3098 olddecl, and not newdecl, is on the list of
3099 instantiations so that if we try to do the instantiation
3100 again we won't get the clobbered declaration. */
3102 new_template_info,
3103 olddecl);
3104 }
3105 else
3106 {
3114 {
3122 {
3135 }
3143 }
3144 }
3147 {
3151 {
3152 /* Merge the section attribute.
3153 We want to issue an error if the sections conflict but that must be
3154 done later in decl_attributes since we are called before attributes
3155 are assigned. */
3160 {
3164 else
3168 }
3169 }
3173 {
3177 }
3178 }
3182 /* NEWDECL contains the merged attribute lists.
3183 Update OLDDECL to be the same. */
3186 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
3187 so that encode_section_info has a chance to look at the new decl
3188 flags and attributes. */
3195 /* The NEWDECL will no longer be needed. Because every out-of-class
3196 declaration of a member results in a call to duplicate_decls,
3197 freeing these nodes represents in a significant savings.
3199 Before releasing the node, be sore to remove function from symbol
3200 table that might have been inserted there to record comdat group.
3201 Be sure to however do not free DECL_STRUCT_FUNCTION because this
3202 structure is shared in between newdecl and oldecl. */
3206 {
3210 }
3213 {
3214 tree clone;
3216 {
3219 }
3220 }
3222 /* Remove the associated constraints for newdecl, if any, before
3223 reclaiming memory. */
3230 }
3231 \f
3232 /* Return zero if the declaration NEWDECL is valid
3233 when the declaration OLDDECL (assumed to be for the same name)
3234 has already been seen.
3235 Otherwise return an error message format string with a %s
3236 where the identifier should go. */
3240 {
3242 {
3243 /* Because C++ can put things into name space for free,
3244 constructs like "typedef struct foo { ... } foo"
3245 would look like an erroneous redeclaration. */
3248 else
3250 }
3252 {
3253 /* If this is a pure function, its olddecl will actually be
3254 the original initialization to `0' (which we force to call
3255 abort()). Don't complain about redefinition in this case. */
3260 /* If both functions come from different namespaces, this is not
3261 a redeclaration - this is a conflict with a used function. */
3267 /* We'll complain about linkage mismatches in
3268 warn_extern_redeclared_static. */
3270 /* Defining the same name twice is no good. */
3273 {
3279 }
3282 {
3287 {
3291 else
3294 }
3295 }
3301 /* [class.compare.default]: A definition of a comparison operator as
3302 defaulted that appears in a class shall be the first declaration of
3303 that function. */
3309 check_abi_tag_redeclaration
3314 }
3316 {
3340 {
3345 {
3349 else
3352 }
3353 }
3359 /* Core issue #226 (C++11):
3361 If a friend function template declaration specifies a
3362 default template-argument, that declaration shall be a
3363 definition and shall be the only declaration of the
3364 function template in the translation unit. */
3375 }
3382 {
3383 /* Only variables can be thread-local, and all declarations must
3384 agree on this property. */
3388 else
3391 }
3393 {
3394 /* The objects have been declared at namespace scope. If either
3395 is a member of an anonymous union, then this is an invalid
3396 redeclaration. For example:
3398 int i;
3399 union { int i; };
3401 is invalid. */
3405 /* If at least one declaration is a reference, there is no
3406 conflict. For example:
3408 int i = 3;
3409 extern int i;
3411 is valid. */
3415 /* Static data member declared outside a class definition
3416 if the variable is defined within the class with constexpr
3417 specifier is declaration rather than definition (and
3418 deprecated). */
3424 {
3426 /* For now, only warn with explicit -Wdeprecated. */
3428 {
3429 auto_diagnostic_group d;
3431 "redundant redeclaration of %<constexpr%> "
3435 }
3437 }
3439 /* Reject two definitions. */
3441 }
3442 else
3443 {
3444 /* Objects declared with block scope: */
3445 /* Reject two definitions, and reject a definition
3446 together with an external reference. */
3450 }
3451 }
3452 \f
3454 /* Hash and equality functions for the named_label table. */
3456 hashval_t
3458 {
3460 }
3462 bool
3464 {
3466 }
3468 /* Look for a label named ID in the current function. If one cannot
3469 be found, create one. Return the named_label_entry, or NULL on
3470 failure. */
3474 {
3477 /* You can't use labels at global scope. */
3479 {
3482 }
3488 named_label_entry **slot
3493 {
3498 {
3502 }
3503 }
3505 /* We are making a new decl, create or reuse the named_label_entry */
3509 else
3510 {
3515 }
3517 /* Now create the LABEL_DECL. */
3523 {
3527 }
3532 }
3534 /* Wrapper for lookup_label_1. */
3536 tree
3538 {
3541 }
3543 tree
3545 {
3548 }
3550 /* Returns nonzero if it is ill-formed to jump past the declaration of
3551 DECL. Returns 2 if it's also a real problem. */
3553 static int
3555 {
3556 /* [stmt.dcl]/3: A program that jumps from a point where a local variable
3557 with automatic storage duration is not in scope to a point where it is
3558 in scope is ill-formed unless the variable has scalar type, class type
3559 with a trivial default constructor and a trivial destructor, a
3560 cv-qualified version of one of these types, or an array of one of the
3561 preceding types and is declared without an initializer (8.5). */
3576 }
3578 /* A subroutine of check_previous_goto_1 and check_goto to identify a branch
3579 to the user. */
3581 static bool
3583 diagnostic_t diag_kind)
3584 {
3585 bool complained
3592 }
3594 /* Check that a single previously seen jump to a newly defined label
3595 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
3596 the jump context; NAMES are the names in scope in LEVEL at the jump
3597 context; LOCUS is the source position of the jump or 0. Returns
3598 true if all is well. */
3600 static bool
3603 {
3611 {
3617 }
3620 {
3626 {
3632 {
3637 }
3639 {
3643 else
3645 " enters scope of %q#D, which has "
3647 }
3648 }
3656 {
3689 {
3693 }
3695 {
3699 }
3704 }
3707 {
3713 }
3714 }
3717 }
3719 static void
3721 {
3725 }
3727 static bool
3729 {
3731 }
3733 /* Check that a new jump to a label DECL is OK. Called by
3734 finish_goto_stmt. */
3736 void
3738 {
3739 /* We can't know where a computed goto is jumping.
3740 So we assume that it's OK. */
3745 named_label_entry **slot
3749 /* If the label hasn't been defined yet, defer checking. */
3751 {
3752 /* Don't bother creating another use if the last goto had the
3753 same data, and will therefore create the same set of errors. */
3758 named_label_use_entry *new_use
3768 }
3772 tree bad;
3779 {
3788 }
3791 {
3795 {
3796 /* Can't skip init of __exception_info. */
3798 {
3802 }
3806 }
3808 {
3812 else
3814 " enters scope of %q#D which has "
3816 }
3817 }
3820 {
3833 }
3836 {
3839 }
3842 {
3846 {
3848 {
3853 }
3857 }
3858 }
3859 }
3861 /* Check that a return is ok wrt OpenMP structured blocks.
3862 Called by finish_return_stmt. Returns true if all is well. */
3864 bool
3866 {
3869 {
3872 }
3876 }
3878 /* Define a label, specifying the location in the source file.
3879 Return the LABEL_DECL node for the label. */
3881 tree
3883 {
3886 /* After labels, make any new cleanups in the function go into their
3887 own new (temporary) binding contour. */
3897 {
3900 }
3901 else
3902 {
3903 /* Mark label as having been defined. */
3905 /* Say where in the source. */
3914 }
3917 }
3919 struct cp_switch
3920 {
3923 /* The SWITCH_STMT being built. */
3924 tree switch_stmt;
3925 /* A splay-tree mapping the low element of a case range to the high
3926 element, or NULL_TREE if there is no high element. Used to
3927 determine whether or not a new case label duplicates an old case
3928 label. We need a tree, rather than simply a hash table, because
3929 of the GNU case range extension. */
3930 splay_tree cases;
3931 /* Remember whether a default: case label has been seen. */
3933 /* Remember whether a BREAK_STMT has been seen in this SWITCH_STMT. */
3935 /* Set if inside of {FOR,DO,WHILE}_BODY nested inside of a switch,
3936 where BREAK_STMT doesn't belong to the SWITCH_STMT. */
3938 };
3940 /* A stack of the currently active switch statements. The innermost
3941 switch statement is on the top of the stack. There is no need to
3942 mark the stack for garbage collection because it is only active
3943 during the processing of the body of a function, and we never
3944 collect at that point. */
3948 /* Called right after a switch-statement condition is parsed.
3949 SWITCH_STMT is the switch statement being parsed. */
3951 void
3953 {
3963 }
3965 void
3967 {
3970 /* Emit warnings as needed. */
3973 const bool bool_cond_p
3979 bool_cond_p);
3981 /* For the benefit of block_may_fallthru remember if the switch body
3982 case labels cover all possible values and if there are break; stmts. */
3984 || (!processing_template_decl
3990 /* Now that we're done with the switch warnings, set the switch type
3991 to the type of the condition if the index type was of scoped enum type.
3992 (Such types don't participate in the integer promotions.) We do this
3993 because of bit-fields whose declared type is a scoped enum type:
3994 gimplification will use the lowered index type, but convert the
3995 case values to SWITCH_STMT_TYPE, which would have been the declared type
3996 and verify_gimple_switch doesn't accept that. */
4003 }
4005 /* Note that a BREAK_STMT is about to be added. If it is inside of
4006 a SWITCH_STMT and not inside of a loop body inside of it, note
4007 in switch_stack we've seen a BREAK_STMT. */
4009 void
4011 {
4014 }
4016 /* Note the start of processing of an iteration statement's body.
4017 The note_break_stmt function will do nothing while processing it.
4018 Return a flag that should be passed to note_iteration_stmt_body_end. */
4020 bool
4022 {
4028 }
4030 /* Note the end of processing of an iteration statement's body. */
4032 void
4034 {
4037 }
4039 /* Convert a case constant VALUE in a switch to the type TYPE of the switch
4040 condition. Note that if TYPE and VALUE are already integral we don't
4041 really do the conversion because the language-independent
4042 warning/optimization code will work better that way. */
4044 static tree
4046 {
4056 /* The constant-expression VALUE shall be a converted constant expression
4057 of the adjusted type of the switch condition, which doesn't allow
4058 narrowing conversions. */
4065 else
4066 /* The already integral case. */
4070 }
4072 /* Note that we've seen a definition of a case label, and complain if this
4073 is a bad place for one. */
4075 tree
4077 {
4080 tree type;
4086 {
4087 tree label;
4089 /* For templates, just add the case label; we'll do semantic
4090 analysis at instantiation-time. */
4093 }
4095 /* Find the condition on which this switch statement depends. */
4112 /* After labels, make any new cleanups in the function go into their
4113 own new (temporary) binding contour. */
4120 }
4121 \f
4123 tree scope;
4124 tree name;
4125 tree template_id;
4128 };
4131 {
4134 /* Hash a TYPENAME_TYPE. */
4136 static hashval_t
4138 {
4143 }
4145 static hashval_t
4147 {
4149 }
4151 static hashval_t
4153 {
4155 }
4157 /* Compare two TYPENAME_TYPEs. */
4159 static bool
4161 {
4167 }
4168 };
4170 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
4171 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
4173 Returns the new TYPENAME_TYPE. */
4177 tree
4180 {
4181 typename_info ti;
4195 /* See if we already have this type. */
4200 else
4201 {
4202 /* Build the TYPENAME_TYPE. */
4209 /* Build the corresponding TYPE_DECL. */
4216 /* Store it in the hash table. */
4219 /* TYPENAME_TYPEs must always be compared structurally, because
4220 they may or may not resolve down to another type depending on
4221 the currently open classes. */
4223 }
4226 }
4228 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
4229 provided to name the type. Returns an appropriate type, unless an
4230 error occurs, in which case error_mark_node is returned. If we
4231 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
4232 return that, rather than the _TYPE it corresponds to, in other
4233 cases we look through the type decl. If TF_ERROR is set, complain
4234 about errors, otherwise be quiet. */
4236 tree
4238 tsubst_flags_t complain)
4239 {
4240 tree fullname;
4241 tree t;
4250 {
4255 else
4256 /* Create a TEMPLATE_ID_EXPR for the type. */
4260 }
4267 {
4272 {
4276 }
4277 }
4279 {
4283 }
4285 {
4289 }
4296 {
4300 }
4302 /* When the CONTEXT is a dependent type, NAME could refer to a
4303 dependent base class of CONTEXT. But look inside it anyway
4304 if CONTEXT is a currently open scope, in case it refers to a
4305 member of the current instantiation or a non-dependent base;
4306 lookup will stop when we hit a dependent base. */
4308 /* We should only set WANT_TYPE when we're a nested typename type.
4309 Then we can give better diagnostics if we find a non-type. */
4311 else
4320 {
4322 {
4325 else
4328 }
4330 }
4332 /* Pull out the template from an injected-class-name (or multiple). */
4337 {
4339 {
4342 }
4344 }
4347 {
4352 }
4354 {
4357 /* The caller permits this typename-specifier to name a template
4359 else
4360 {
4365 }
4366 }
4376 {
4384 }
4392 }
4394 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
4395 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
4396 in which case error_mark_node is returned.
4398 If PARM_LIST is non-NULL, also make sure that the template parameter
4399 list of TEMPLATE_DECL matches.
4401 If COMPLAIN zero, don't complain about any errors that occur. */
4403 tree
4405 tsubst_flags_t complain)
4406 {
4415 {
4425 {
4429 }
4433 {
4435 {
4439 }
4441 }
4444 complain))
4448 }
4451 }
4453 /* Build an UNBOUND_CLASS_TEMPLATE. */
4455 tree
4457 {
4458 /* Build the UNBOUND_CLASS_TEMPLATE. */
4464 /* Build the corresponding TEMPLATE_DECL. */
4473 }
4475 \f
4477 /* Push the declarations of builtin types into the global namespace.
4478 RID_INDEX is the index of the builtin type in the array
4479 RID_POINTERS. NAME is the name used when looking up the builtin
4480 type. TYPE is the _TYPE node for the builtin type.
4482 The calls to set_global_binding below should be
4483 eliminated. Built-in types should not be looked up name; their
4484 names are keywords that the parser can recognize. However, there
4485 is code in c-common.cc that uses identifier_global_value to look up
4486 built-in types by name. */
4488 void
4491 tree type)
4492 {
4496 {
4502 }
4507 {
4513 }
4516 {
4520 }
4521 }
4523 /* Push a type into the namespace so that the back ends ignore it. */
4525 static void
4527 {
4530 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
4537 }
4539 /* Create all the predefined identifiers. */
4541 static void
4543 {
4544 struct predefined_identifier
4545 {
4549 };
4551 /* A table of identifiers to create at startup. */
4555 /* Some of these names have a trailing space so that it is
4556 impossible for them to conflict with names written by users. */
4573 /* The demangler expects anonymous namespaces to be called
4574 something starting with '_GLOBAL__N_'. It no longer needs
4575 to be unique to the TU. */
4605 };
4609 {
4611 /* Some of these identifiers already have a special kind. */
4614 }
4615 }
4617 /* Create the predefined scalar types of C,
4618 and some nodes representing standard constants (0, 1, (void *)0).
4619 Initialize the global binding level.
4620 Make definitions for built-in primitive functions. */
4622 void
4624 {
4625 tree void_ftype;
4626 tree void_ftype_ptr;
4628 /* Create all the identifiers we need. */
4631 /* Create the global variables. */
4636 /* Enter the global namespace. */
4639 void_type_node);
4644 /* Remember whether we want the empty class passing ABI change warning
4645 in this TU. */
4648 debug_hooks->register_main_translation_unit
4656 /* Initially, C. */
4659 /* Create the `std' namespace. */
4669 tree decl
4675 /* The concrete return type of __builtin_source_location is
4676 const std::source_location::__impl*, but we can't form the type
4677 at this point. So we initially declare it with an auto return
4678 type which we then "deduce" from require_deduced_type upon first use. */
4686 NULL_TREE);
4687 decl
4689 bool_vaftype,
4690 CP_BUILT_IN_IS_CORRESPONDING_MEMBER,
4694 decl
4696 bool_vaftype,
4697 CP_BUILT_IN_IS_POINTER_INTERCONVERTIBLE_WITH_CLASS,
4703 /* Guess at the initial static decls size. */
4706 /* ... and keyed classes. */
4718 NULL_TREE);
4720 #if 0
4722 #endif
4731 void_ftype_ptr
4734 /* Create the conversion operator marker. This operator's DECL_NAME
4735 is in the identifier table, so we can use identifier equality to
4736 find it. */
4738 void_ftype);
4740 /* C++ extensions */
4745 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
4748 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
4749 result. */
4756 /* Used when parsing to distinguish parameter-lists () and (void). */
4759 {
4760 /* Make sure we get a unique function type, so we can give
4761 its pointer type a name. (This wins for gdb.) */
4768 }
4771 vtbl_type_node
4787 /* Now, C++. */
4792 {
4794 aligned_new_threshold);
4796 }
4802 {
4805 tree ptr_ftype_sizetype;
4806 tree new_eh_spec;
4808 ptr_ftype_sizetype
4811 {
4812 tree bad_alloc_id;
4813 tree bad_alloc_type_node;
4814 tree bad_alloc_decl;
4820 bad_alloc_decl
4825 new_eh_spec
4827 }
4828 else
4831 /* Ensure attribs.cc is initialized. */
4835 NULL_TREE);
4838 extvisattr);
4858 {
4859 /* Also push the sized deallocation variants:
4860 void operator delete(void*, std::size_t) throw();
4861 void operator delete[](void*, std::size_t) throw(); */
4862 tree void_ftype_ptr_size
4866 extvisattr);
4874 }
4877 {
4884 /* operator new (size_t, align_val_t); */
4898 /* operator delete (void *, align_val_t); */
4911 {
4912 /* operator delete (void *, size_t, align_val_t); */
4915 NULL_TREE);
4924 }
4925 }
4927 /* C++-specific nullptr initialization. */
4931 }
4936 abort_fndecl
4940 /* If no definition is available, resolve references to NULL. */
4943 /* Perform other language dependent initializations. */
4957 /* Show we use EH for cleanups. */
4961 /* Check that the hardware interference sizes are at least
4962 alignof(max_align_t), as required by the standard. */
4965 {
4971 "%<--param destructive-interference-size=%d%> "
4974 }
4979 /* else leave it unset. */
4982 {
4989 "%<--param constructive-interference-size=%d%> "
4992 }
4997 }
4999 /* Enter an abi node in global-module context. returns a cookie to
5000 give to pop_abi_namespace. */
5002 unsigned
5004 {
5010 }
5012 /* Pop an abi namespace, FLAGS is the cookie push_abi_namespace gave
5013 you. */
5015 void
5017 {
5021 }
5023 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give
5024 the decl, LOC is the location to give the decl, NAME is the
5025 initialization string and TYPE_DEP indicates whether NAME depended
5026 on the type of the function. We make use of that to detect
5027 __PRETTY_FUNCTION__ inside a template fn. This is being done lazily
5028 at the point of first use, so we mustn't push the decl now. */
5030 static tree
5032 {
5037 {
5044 {
5045 /* __FUNCTION__ */
5048 }
5049 else
5050 {
5051 /* __PRETTY_FUNCTION__ */
5054 }
5061 }
5068 else
5082 /* For decl_constant_var_p. */
5086 {
5091 }
5092 else
5093 {
5096 }
5099 }
5101 /* Install DECL as a builtin function at current global scope. Return
5102 the new decl (if we found an existing version). Also installs it
5103 into ::std, if it's not '_*'. */
5105 tree
5107 {
5112 /* Runtime library routines are, by definition, available in an
5113 external shared object. */
5121 /* In the user's namespace, it must be declared before use. */
5127 /* Treat __*_chk fortification functions as anticipated as well,
5128 unless they are __builtin_*_chk. */
5131 /* All builtins that don't begin with an '_' should additionally
5132 go in the 'std' namespace. */
5134 {
5141 }
5147 }
5149 /* Like cxx_builtin_function, but guarantee the function is added to the global
5150 scope. This is to allow function specific options to add new machine
5151 dependent builtins when the target ISA changes via attribute((target(...)))
5152 which saves space on program startup if the program does not use non-generic
5153 ISAs. */
5155 tree
5157 {
5163 }
5165 /* Implement LANG_HOOKS_SIMULATE_BUILTIN_FUNCTION_DECL. */
5167 tree
5169 {
5176 }
5178 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
5179 function. Not called directly. */
5181 static tree
5184 {
5192 /* Runtime library routines are, by definition, available in an
5193 external shared object. */
5198 }
5200 /* Returns the _DECL for a library function with C++ linkage. */
5202 static tree
5205 {
5210 }
5212 /* Like build_library_fn, but takes a C string instead of an
5213 IDENTIFIER_NODE. */
5215 tree
5217 {
5219 }
5221 /* Like build_cp_library_fn, but takes a C string instead of an
5222 IDENTIFIER_NODE. */
5224 tree
5226 {
5228 ecf_flags);
5229 }
5231 /* Like build_library_fn, but also pushes the function so that we will
5232 be able to find it via get_global_binding. Also, the function
5233 may throw exceptions listed in RAISES. */
5235 tree
5237 {
5243 }
5245 /* Like build_cp_library_fn, but also pushes the function so that it
5246 will be found by normal lookup. */
5248 static tree
5251 {
5258 }
5260 /* Like push_library_fn, but also note that this function throws
5261 and does not return. Used for __throw_foo and the like. */
5263 tree
5265 {
5268 }
5269 \f
5270 /* When we call finish_struct for an anonymous union, we create
5271 default copy constructors and such. But, an anonymous union
5272 shouldn't have such things; this function undoes the damage to the
5273 anonymous union type T.
5275 (The reason that we create the synthesized methods is that we don't
5276 distinguish `union { int i; }' from `typedef union { int i; } U'.
5277 The first is an anonymous union; the second is just an ordinary
5278 union type.) */
5280 void
5282 {
5283 /* Wipe out memory of synthesized methods. */
5291 /* Splice the implicitly generated functions out of TYPE_FIELDS and diagnose
5292 invalid members. */
5294 {
5297 else
5307 {
5308 /* We already complained about static data members in
5309 finish_static_data_member_decl. */
5311 {
5312 auto_diagnostic_group d;
5316 "only have public non-static data members"
5319 {
5322 {
5325 "this flexibility is deprecated and will be "
5327 }
5328 }
5329 }
5330 }
5331 }
5333 /* Splice all functions out of CLASSTYPE_MEMBER_VEC. */
5341 /* Wipe RTTI info. */
5344 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
5345 assignment operators (because they cannot have these methods themselves).
5346 For anonymous unions this is already checked because they are not allowed
5347 in any union, otherwise we have to check it. */
5349 {
5353 {
5355 /* Avoid ICE after error on anon-struct9.C. */
5357 }
5361 {
5364 {
5374 }
5375 }
5376 }
5377 }
5379 /* Warn for an attribute located at LOCATION that appertains to the
5380 class type CLASS_TYPE that has not been properly placed after its
5381 class-key, in it class-specifier. */
5383 void
5385 tree class_type)
5386 {
5389 auto_diagnostic_group d;
5391 "attribute ignored in declaration "
5396 }
5398 /* Returns the cv-qualifiers that apply to the type specified
5399 by the DECLSPECS. */
5401 static int
5403 {
5414 }
5416 /* Make sure that a declaration with no declarator is well-formed, i.e.
5417 just declares a tagged type or anonymous union.
5419 Returns the type declared; or NULL_TREE if none. */
5421 tree
5424 {
5427 /* If a class, struct, or enum type is declared by the DECLSPECS
5428 (i.e, if a class-specifier, enum-specifier, or non-typename
5429 elaborated-type-specifier appears in the DECLSPECS),
5430 DECLARED_TYPE is set to the corresponding type. */
5438 {
5444 }
5456 {
5458 "%<auto%> can only be specified for variables "
5461 }
5468 /* Check for an anonymous union. */
5471 {
5472 /* 7/3 In a simple-declaration, the optional init-declarator-list
5473 can be omitted only when declaring a class (clause 9) or
5474 enumeration (7.2), that is, when the decl-specifier-seq contains
5475 either a class-specifier, an elaborated-type-specifier with
5476 a class-key (9.1), or an enum-specifier. In these cases and
5477 whenever a class-specifier or enum-specifier is present in the
5478 decl-specifier-seq, the identifiers in these specifiers are among
5479 the names being declared by the declaration (as class-name,
5480 enum-names, or enumerators, depending on the syntax). In such
5481 cases, and except for the declaration of an unnamed bit-field (9.6),
5482 the decl-specifier-seq shall introduce one or more names into the
5483 program, or shall redeclare a name introduced by a previous
5484 declaration. [Example:
5485 enum { }; // ill-formed
5486 typedef class { }; // ill-formed
5487 --end example] */
5489 {
5493 }
5500 }
5502 else
5503 {
5511 && (!current_class_type
5520 "a storage class can only be specified for objects "
5524 "%<const%> can only be specified for objects and "
5528 "%<volatile%> can only be specified for objects and "
5532 "%<__restrict%> can only be specified for objects and "
5536 "%<__thread%> can only be specified for objects "
5550 }
5553 {
5554 location_t loc;
5557 /* For a non-template class, use the name location. */
5559 else
5560 /* For a template class (an explicit instantiation), use the
5561 current location. */
5565 /* [dcl.attr.grammar]/4:
5567 No attribute-specifier-seq shall appertain to an explicit
5568 instantiation. */
5569 {
5572 declared_type))
5574 "no attribute can be applied to "
5576 }
5577 else
5579 }
5581 /* Diagnose invalid application of contracts, if any. */
5584 else
5588 }
5590 /* Called when a declaration is seen that contains no names to declare.
5591 If its type is a reference to a structure, union or enum inherited
5592 from a containing scope, shadow that tag name for the current scope
5593 with a forward reference.
5594 If its type defines a new named structure or union
5595 or defines an enum, it is valid but we need not do anything here.
5596 Otherwise, it is an error.
5598 C++: may have to grok the declspecs to learn about static,
5599 complain for anonymous unions.
5601 Returns the TYPE declared -- or NULL_TREE if none. */
5603 tree
5605 {
5616 /* This is where the variables in an anonymous union are
5617 declared. An anonymous union declaration looks like:
5618 union { ... } ;
5619 because there is no declarator after the union, the parser
5620 sends that declaration here. */
5622 {
5626 {
5630 }
5631 }
5634 }
5635 \f
5636 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
5638 tree
5642 {
5643 tree attrs;
5644 tree type;
5645 enum decl_context context
5651 {
5656 /* A template type parameter or other dependent type. */
5659 else
5661 }
5663 }
5665 /* Process a DECLARATOR for a function-scope or namespace-scope
5666 variable or function declaration.
5667 (Function definitions go through start_function; class member
5668 declarations appearing in the body of the class go through
5669 grokfield.) The DECL corresponding to the DECLARATOR is returned.
5670 If an error occurs, the error_mark_node is returned instead.
5672 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED is
5673 SD_INITIALIZED if an explicit initializer is present, or SD_DEFAULTED
5674 for an explicitly defaulted function, or SD_DELETED for an explicitly
5675 deleted function, but 0 (SD_UNINITIALIZED) if this is a variable
5676 implicitly initialized via a default constructor. It can also be
5677 SD_DECOMPOSITION which behaves much like SD_INITIALIZED, but we also
5678 mark the new decl as DECL_DECOMPOSITION_P.
5680 ATTRIBUTES and PREFIX_ATTRIBUTES are GNU attributes associated with this
5681 declaration.
5683 The scope represented by the context of the returned DECL is pushed
5684 (if it is not the global namespace) and is assigned to
5685 *PUSHED_SCOPE_P. The caller is then responsible for calling
5686 pop_scope on *PUSHED_SCOPE_P if it is set. */
5688 tree
5692 tree attributes,
5693 tree prefix_attributes,
5695 {
5696 tree decl;
5697 tree context;
5701 tree initial;
5721 {
5726 }
5728 /* Save the DECL_INITIAL value in case it gets clobbered to assist
5729 with attribute validation. */
5733 {
5737 decl);
5741 /* Tell 'cplus_decl_attributes' this is an initialized decl,
5742 even though we might not yet have the initializer expression. */
5745 }
5751 /* If this is a typedef that names the class for linkage purposes
5752 (7.1.3p8), apply any attributes directly to the type. */
5757 else
5760 /* Set attributes here so if duplicate decl, will have proper attributes. */
5763 /* Restore the original DECL_INITIAL that we may have clobbered earlier to
5764 assist with attribute validation. */
5767 /* Dllimported symbols cannot be defined. Static data members (which
5768 can be initialized in-class and dllimported) go through grokfield,
5769 not here, so we don't need to exclude those decls when checking for
5770 a definition. */
5772 {
5776 }
5778 /* If #pragma weak was used, mark the decl weak now. */
5790 {
5794 {
5804 {
5810 }
5811 else
5812 {
5817 {
5824 }
5825 /* Static data member are tricky; an in-class initialization
5826 still doesn't provide a definition, so the in-class
5827 declaration will have DECL_EXTERNAL set, but will have an
5828 initialization. Thus, duplicate_decls won't warn
5829 about this situation, and so we check here. */
5837 }
5838 }
5839 else
5840 {
5842 this_tmpl
5843 ? current_template_parms
5848 }
5850 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
5852 /* Do not mark DECL as an explicit specialization if it was not
5853 already marked as an instantiation; a declaration should
5854 never be marked as a specialization unless we know what
5855 template is being specialized. */
5857 {
5862 else
5865 /* [temp.expl.spec] An explicit specialization of a static data
5866 member of a template is a definition if the declaration
5867 includes an initializer; otherwise, it is a declaration.
5869 We check for processing_specialization so this only applies
5870 to the new specialization syntax. */
5873 }
5876 /* Aliases are definitions. */
5878 {
5882 decl);
5886 decl);
5887 }
5888 }
5890 /* Create a DECL_LANG_SPECIFIC so that DECL_DECOMPOSITION_P works. */
5898 {
5899 /* A function-scope decl of some namespace-scope decl. */
5903 "block-scope extern declaration %q#D not permitted"
5905 }
5907 /* Enter this declaration into the symbol table. Don't push the plain
5908 VAR_DECL for a variable template. */
5922 /* But not templated variables. */
5924 {
5925 /* This is a const variable with implicit 'static'. Set
5926 DECL_THIS_STATIC so we can tell it from variables that are
5927 !TREE_PUBLIC because of the anonymous namespace. */
5930 }
5935 {
5939 "%qD defined %<thread_local%> in %qs function only "
5945 "%qD defined %<static%> in %qs function only available "
5949 else
5953 }
5959 }
5961 /* Process the declaration of a variable DECL. INITIALIZED is true
5962 iff DECL is explicitly initialized. (INITIALIZED is false if the
5963 variable is initialized via an implicitly-called constructor.)
5964 This function must be called for ordinary variables (including, for
5965 example, implicit instantiations of templates), but must not be
5966 called for template declarations. */
5968 void
5970 {
5980 bool aggregate_definition_p
5983 /* If an explicit initializer is present, or if this is a definition
5984 of an aggregate, then we need a complete type at this point.
5985 (Scalars are always complete types, so there is nothing to
5986 check.) This code just sets COMPLETE_P; errors (if necessary)
5987 are issued below. */
5989 && !complete_p
5991 {
5993 /* We will not yet have set TREE_READONLY on DECL if the type
5994 was "const", but incomplete, before this point. But, now, we
5995 have a complete type, so we can try again. */
5997 }
6000 /* Is it valid for this decl to have an initializer at all? */
6001 {
6002 /* Don't allow initializations for incomplete types except for
6003 arrays which might be completed by the initialization. */
6009 {
6012 }
6014 {
6017 /* else we already gave an error in start_decl. */
6018 }
6019 }
6021 {
6024 else
6025 {
6027 decl);
6028 /* Change the type so that assemble_variable will give
6029 DECL an rtl we can live with: (mem (const_int 0)). */
6031 }
6032 }
6034 /* Create a new scope to hold this declaration if necessary.
6035 Whether or not a new scope is necessary cannot be determined
6036 until after the type has been completed; if the type is a
6037 specialization of a class template it is not until after
6038 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
6039 will be set correctly. */
6041 }
6043 /* Given a parenthesized list of values INIT, create a CONSTRUCTOR to handle
6044 C++20 P0960. TYPE is the type of the object we're initializing. */
6046 tree
6048 {
6052 {
6053 /* If the list has a single element and it's a string literal,
6054 then it's the initializer for the array as a whole. */
6060 /* Handle non-standard extensions like compound literals. This also
6061 prevents triggering aggregate parenthesized-initialization in
6062 compiler-generated code for =default. */
6066 }
6072 }
6074 /* Handle initialization of references. DECL, TYPE, and INIT have the
6075 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
6076 but will be set to a new CLEANUP_STMT if a temporary is created
6077 that must be destroyed subsequently.
6079 Returns an initializer expression to use to initialize DECL, or
6080 NULL if the initialization can be performed statically.
6082 Quotes on semantics can be found in ARM 8.4.3. */
6084 static tree
6086 {
6088 {
6095 }
6099 {
6100 /* This handles (C++20 only) code like
6102 const A& r(1, 2, 3);
6104 where we treat the parenthesized list as a CONSTRUCTOR. */
6109 {
6110 /* We don't know yet if we should treat const A& r(1) as
6111 const A& r{1}. */
6113 {
6116 tf_warning_or_error);
6117 }
6118 /* If the list had more than one element, the code is ill-formed
6119 pre-C++20, so we can build a constructor right away. */
6120 else
6122 }
6123 else
6125 tf_warning_or_error);
6126 }
6130 /* Note: default conversion is only called in very special cases. */
6133 /* check_initializer handles this for non-reference variables, but for
6134 references we need to do it here or the initializer will get the
6135 incomplete array type and confuse later calls to
6136 cp_complete_array_type. */
6141 {
6145 }
6147 /* Convert INIT to the reference type TYPE. This may involve the
6148 creation of a temporary, whose lifetime must be the same as that
6149 of the reference. If so, a DECL_EXPR for the temporary will be
6150 added just after the DECL_EXPR for DECL. That's why we don't set
6151 DECL_INITIAL for local references (instead assigning to them
6152 explicitly); we need to allow the temporary to be initialized
6153 first. */
6155 tf_warning_or_error);
6156 }
6158 /* Designated initializers in arrays are not supported in GNU C++.
6159 The parser cannot detect this error since it does not know whether
6160 a given brace-enclosed initializer is for a class type or for an
6161 array. This function checks that CE does not use a designated
6162 initializer. If it does, an error is issued. Returns true if CE
6163 is valid, i.e., does not have a designated initializer. */
6165 bool
6168 {
6169 /* Designated initializers for array elements are not supported. */
6171 {
6172 /* The parser only allows identifiers as designated
6173 initializers. */
6175 {
6179 }
6181 {
6185 }
6193 {
6194 /* A C99 designator is OK if it matches the current index. */
6196 {
6199 }
6200 else
6202 }
6203 else
6209 }
6212 }
6214 /* When parsing `int a[] = {1, 2};' we don't know the size of the
6215 array until we finish parsing the initializer. If that's the
6216 situation we're in, update DECL accordingly. */
6218 static void
6220 {
6226 {
6227 /* do_default is really a C-ism to deal with tentative definitions.
6228 But let's leave it here to ease the eventual merge. */
6233 /* Check that there are no designated initializers in INIT, as
6234 those are not supported in GNU C++, and as the middle-end
6235 will crash if presented with a non-numeric designated
6236 initializer. */
6238 {
6241 HOST_WIDE_INT i;
6243 {
6248 /* If an un-designated initializer is type-dependent, we can't
6249 check brace elision yet. */
6253 }
6254 }
6258 else
6259 {
6261 do_default);
6263 {
6267 }
6269 {
6271 {
6274 }
6275 /* If a `static' var's size isn't known, make it extern as
6276 well as static, so it does not get allocated. If it's not
6277 `static', then don't mark it extern; finish_incomplete_decl
6278 will give it a default size and it will get allocated. */
6281 }
6283 {
6286 }
6287 }
6292 }
6293 }
6295 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
6296 any appropriate error messages regarding the layout. */
6298 static void
6300 {
6301 tree type;
6307 /* If we haven't already laid out this declaration, do so now.
6308 Note that we must not call complete type for an external object
6309 because it's type might involve templates that we are not
6310 supposed to instantiate yet. (And it's perfectly valid to say
6311 `extern X x' for some incomplete type `X'.) */
6320 {
6321 /* An automatic variable with an incomplete type: that is an error.
6322 Don't talk about array types here, since we took care of that
6323 message in grokdeclarator. */
6327 }
6328 #if 0
6329 /* Keep this code around in case we later want to control debug info
6330 based on whether a type is "used". (jason 1999-11-11) */
6333 /* Let debugger know it should output info for this type. */
6338 #endif
6343 {
6347 else
6348 {
6353 }
6354 }
6356 /* If the final element initializes a flexible array field, add the size of
6357 that initializer to DECL's size. */
6367 {
6370 {
6377 {
6383 }
6384 }
6385 }
6386 }
6388 /* If a local static variable is declared in an inline function, or if
6389 we have a weak definition, we must endeavor to create only one
6390 instance of the variable at link-time. */
6392 void
6394 {
6395 /* Don't mess with __FUNCTION__ and similar. */
6399 /* Static data in a function with comdat linkage also has comdat
6400 linkage. */
6405 {
6407 {
6408 /* With weak symbols, we simply make the variable COMDAT;
6409 that will cause copies in multiple translations units to
6410 be merged. */
6412 }
6413 else
6414 {
6417 {
6418 /* Without weak symbols, we can use COMMON to merge
6419 uninitialized variables. */
6422 }
6423 else
6424 {
6425 /* While for initialized variables, we must use internal
6426 linkage -- which means that multiple copies will not
6427 be merged. */
6434 "%q#D are wrong (you%'ll wind up with "
6436 else
6438 "static data %q#D are wrong (you%'ll wind "
6444 }
6445 }
6446 }
6447 }
6449 /* Issue an error message if DECL is an uninitialized const variable.
6450 CONSTEXPR_CONTEXT_P is true when the function is called in a constexpr
6451 context from potential_constant_expression. Returns true if all is well,
6452 false otherwise. */
6454 bool
6456 tsubst_flags_t complain)
6457 {
6460 /* ``Unless explicitly declared extern, a const object does not have
6461 external linkage and must be initialized. ($8.4; $12.1)'' ARM
6462 7.1.6 */
6466 /* C++20 permits trivial default initialization in constexpr
6467 context (P1331R2). */
6469 && (constexpr_context_p
6472 {
6480 {
6482 {
6486 }
6487 else
6488 {
6492 "uninitialized variable %qD in %<constexpr%> "
6494 else
6497 }
6498 }
6502 decl);
6505 {
6506 tree defaulted_ctor;
6513 "constructor is not user-provided because it is "
6516 "and the implicitly-defined constructor does not "
6518 }
6521 }
6524 }
6525 \f
6526 /* Structure holding the current initializer being processed by reshape_init.
6527 CUR is a pointer to the current element being processed, END is a pointer
6528 after the last element present in the initializer. */
6529 struct reshape_iter
6530 {
6533 };
6537 /* FIELD is an element of TYPE_FIELDS or NULL. In the former case, the value
6538 returned is the next FIELD_DECL (possibly FIELD itself) that can be
6539 initialized as if for an aggregate class. If there are no more such fields,
6540 the return value will be NULL. */
6542 tree
6544 {
6549 /* In C++17, aggregates can have bases. */
6554 }
6556 /* FIELD is an element of TYPE_FIELDS or NULL. In the former case, the value
6557 returned is the next FIELD_DECL (possibly FIELD itself) that corresponds
6558 to a subobject. If there are no more such fields, the return value will be
6559 NULL. */
6561 tree
6563 {
6573 }
6575 /* Return true for [dcl.init.list] direct-list-initialization from
6576 single element of enumeration with a fixed underlying type. */
6578 bool
6580 {
6587 /* DR 2374: The single element needs to be implicitly
6588 convertible to the underlying type of the enum. */
6595 }
6597 /* Subroutine of reshape_init_array and reshape_init_vector, which does
6598 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
6599 INTEGER_CST representing the size of the array minus one (the maximum index),
6600 or NULL_TREE if the array was declared without specifying the size. D is
6601 the iterator within the constructor. */
6603 static tree
6606 {
6607 tree new_init;
6612 /* The initializer for an array is always a CONSTRUCTOR. If this is the
6613 outermost CONSTRUCTOR and the element type is non-aggregate, we don't need
6614 to build a new one. But don't reuse if not complaining; if this is
6615 tentative, we might also reshape to another type (95319). */
6622 else
6626 {
6627 /* Minus 1 is used for zero sized arrays. */
6633 /* sizetype is sign extended, not zero extended. */
6634 else
6636 }
6638 /* Loop until there are no more initializers. */
6642 {
6643 tree elt_init;
6651 complain);
6656 {
6659 }
6660 else
6666 /* This can happen with an invalid initializer (c++/54501). */
6669 }
6672 }
6674 /* Subroutine of reshape_init_r, processes the initializers for arrays.
6675 Parameters are the same of reshape_init_r. */
6677 static tree
6679 tsubst_flags_t complain)
6680 {
6690 }
6692 /* Subroutine of reshape_init_r, processes the initializers for vectors.
6693 Parameters are the same of reshape_init_r. */
6695 static tree
6697 {
6703 {
6706 {
6711 }
6714 }
6716 /* For a vector, we initialize it as an array of the appropriate size. */
6722 }
6724 /* Subroutine of reshape_init*: We're initializing an element with TYPE from
6725 INIT, in isolation from any designator or other initializers. */
6727 static tree
6729 {
6730 /* We could also implement this by wrapping init in a new CONSTRUCTOR and
6731 calling reshape_init, but this way can just live on the stack. */
6736 complain);
6737 }
6739 /* Subroutine of reshape_init_r, processes the initializers for classes
6740 or union. Parameters are the same of reshape_init_r. */
6742 static tree
6744 tsubst_flags_t complain)
6745 {
6746 tree field;
6747 tree new_init;
6751 /* The initializer for a class is always a CONSTRUCTOR. */
6758 {
6759 /* We get here from maybe_aggr_guide for C++20 class template argument
6760 deduction. In this case we need to look through the binfo because a
6761 template doesn't have base fields. */
6764 }
6767 else
6771 {
6772 /* [dcl.init.aggr]
6774 An initializer for an aggregate member that is an
6775 empty class shall have the form of an empty
6776 initializer-list {}. */
6778 {
6782 }
6784 }
6786 /* For C++20 CTAD, handle pack expansions in the base list. */
6789 /* Loop through the initializable fields, gathering initializers. */
6791 {
6792 tree field_init;
6796 /* Handle C++20 designated initializers. */
6798 {
6803 {
6804 /* We already reshaped this; we should have returned early from
6805 reshape_init. */
6808 {
6813 }
6814 }
6816 {
6820 }
6821 else
6822 {
6827 }
6830 /* Apparently the designator isn't for a member of this anonymous
6831 struct, so head back to the enclosing class. */
6835 {
6840 }
6842 /* If the element is an anonymous union object and the initializer
6843 list is a designated-initializer-list, the anonymous union object
6844 is initialized by the designated-initializer-list { D }, where D
6845 is the designated-initializer-clause naming a member of the
6846 anonymous union object. */
6849 {
6850 /* Find the anon aggr that is a direct member of TYPE. */
6852 {
6857 }
6859 /* Not found, e.g. FIELD is a member of a base class. */
6864 found:
6865 /* Now find the TYPE member with that anon aggr type. */
6873 }
6874 }
6876 /* If we processed all the member of the class, we are done. */
6883 /* Each non-trailing aggregate element that is a pack expansion is
6884 assumed to correspond to no elements of the initializer list. */
6888 {
6889 /* The designated field F is initialized from this one element.
6891 Note that we don't want to do this if we found the designator
6892 inside an anon aggr above; we use the normal code to implement:
6894 "If the element is an anonymous union member and the initializer
6895 list is a brace-enclosed designated- initializer-list, the element
6896 is initialized by the designated-initializer-list { D }, where D
6897 is the designated- initializer-clause naming a member of the
6898 anonymous union member." */
6902 }
6903 else
6906 complain);
6912 {
6913 /* This can happen with an invalid initializer for a flexible
6914 array member (c++/54441). */
6918 }
6922 /* [dcl.init.aggr]
6924 When a union is initialized with a brace-enclosed
6925 initializer, the braces shall only contain an
6926 initializer for the first member of the union. */
6930 continue_:
6932 {
6935 else
6937 }
6938 else
6940 }
6942 /* A trailing aggregate element that is a pack expansion is assumed to
6943 correspond to all remaining elements of the initializer list (if any). */
6945 {
6950 }
6953 }
6955 /* Subroutine of reshape_init_r. We're in a context where C99 initializer
6956 designators are not valid; either complain or return true to indicate
6957 that reshape_init_r should return error_mark_node. */
6959 static bool
6961 {
6963 {
6968 else
6970 }
6972 }
6974 /* Subroutine of reshape_init, which processes a single initializer (part of
6975 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
6976 iterator within the CONSTRUCTOR which points to the initializer to process.
6977 If this is the first initializer of the outermost CONSTRUCTOR node,
6978 FIRST_INITIALIZER_P is that CONSTRUCTOR; otherwise, it is NULL_TREE. */
6980 static tree
6982 tsubst_flags_t complain)
6983 {
6996 {
6997 /* A complex type can be initialized from one or two initializers,
6998 but braces are not elided. */
7001 {
7003 {
7006 else
7008 }
7009 }
7011 {
7019 }
7021 }
7023 /* A non-aggregate type is always initialized with a single
7024 initializer. */
7026 /* As is an array with dependent bound, which we can see
7027 during C++20 aggregate CTAD. */
7031 {
7032 /* It is invalid to initialize a non-aggregate type with a
7033 brace-enclosed initializer before C++0x.
7034 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
7035 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
7036 a CONSTRUCTOR (with a record type). */
7038 /* Don't complain about a capture-init. */
7041 {
7043 {
7045 {
7048 type);
7050 }
7053 && (BRACE_ENCLOSED_INITIALIZER_P
7055 {
7060 }
7061 }
7062 else
7064 }
7068 }
7070 /* "If T is a class type and the initializer list has a single element of
7071 type cv U, where U is T or a class derived from T, the object is
7072 initialized from that element." Even if T is an aggregate. */
7074 && first_initializer_p
7075 /* But not if it's a designated init. */
7079 {
7082 }
7084 /* [dcl.init.aggr]
7086 All implicit type conversions (clause _conv_) are considered when
7087 initializing the aggregate member with an initializer from an
7088 initializer-list. If the initializer can initialize a member,
7089 the member is initialized. Otherwise, if the member is itself a
7090 non-empty subaggregate, brace elision is assumed and the
7091 initializer is considered for the initialization of the first
7092 member of the subaggregate. */
7094 /* But don't try this for the first initializer, since that would be
7095 looking through the outermost braces; A a2 = { a1 }; is not a
7096 valid aggregate initialization. */
7097 && !first_initializer_p
7100 complain)))
7101 {
7104 }
7106 /* [dcl.init.string]
7108 A char array (whether plain char, signed char, or unsigned char)
7109 can be initialized by a string-literal (optionally enclosed in
7110 braces); a wchar_t array can be initialized by a wide
7111 string-literal (optionally enclosed in braces). */
7114 {
7117 reshape_iter stripd = {};
7119 /* Strip one level of braces if and only if they enclose a single
7120 element (as allowed by [dcl.init.string]). */
7124 {
7128 }
7130 /* If it's a string literal, then it's the initializer for the array
7131 as a whole. Otherwise, continue with normal initialization for
7132 array types (one value per array element). */
7134 {
7140 }
7141 }
7143 /* The following cases are about aggregates. If we are not within a full
7144 initializer already, and there is not a CONSTRUCTOR, it means that there
7145 is a missing set of braces (that is, we are processing the case for
7146 which reshape_init exists). */
7149 {
7151 {
7154 /* There is no need to call reshape_init for pointer-to-member
7155 function initializers, as they are always constructed correctly
7156 by the front end. Here we have e.g. {.__pfn=0B, .__delta=0},
7157 which is missing outermost braces. We should warn below, and
7159 /* For a nested compound literal, proceed to specialized routines,
7160 to handle initialization of arrays and similar. */
7163 /* If we have an unresolved designator, we need to find the member it
7164 designates within TYPE, so proceed to the routines below. For
7165 FIELD_DECL or INTEGER_CST designators, we're already initializing
7166 the designated element. */
7169 /* Brace elision with designators is only permitted for anonymous
7170 aggregates. */
7172 /* A CONSTRUCTOR of the target's type is a previously
7173 digested initializer. */
7175 {
7178 }
7179 else
7180 {
7181 /* Something that hasn't been reshaped yet. */
7185 }
7186 }
7191 type);
7193 }
7195 /* Dispatch to specialized routines. */
7196 tree new_init;
7203 else
7211 }
7213 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
7214 brace-enclosed aggregate initializer.
7216 INIT is the CONSTRUCTOR containing the list of initializers describing
7217 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
7218 It may not presently match the shape of the TYPE; for example:
7220 struct S { int a; int b; };
7221 struct S a[] = { 1, 2, 3, 4 };
7223 Here INIT will hold a vector of four elements, rather than a
7224 vector of two elements, each itself a vector of two elements. This
7225 routine transforms INIT from the former form into the latter. The
7226 revised CONSTRUCTOR node is returned. */
7228 tree
7230 {
7232 reshape_iter d;
7233 tree new_init;
7239 /* An empty constructor does not need reshaping, and it is always a valid
7240 initializer. */
7245 /* Already reshaped. */
7248 /* Brace elision is not performed for a CONSTRUCTOR representing
7249 parenthesized aggregate initialization. */
7251 {
7253 /* If we're initializing a char array from a string-literal that is
7254 enclosed in braces, unwrap it here. */
7261 }
7263 /* Handle [dcl.init.list] direct-list-initialization from
7264 single element of enumeration with a fixed underlying type. */
7266 {
7270 {
7274 tf_warning_or_error);
7275 }
7276 else
7278 }
7280 /* Recurse on this CONSTRUCTOR. */
7288 /* Make sure all the element of the constructor were used. Otherwise,
7289 issue an error about exceeding initializers. */
7291 {
7295 }
7306 }
7308 /* Verify array initializer. Returns true if errors have been reported. */
7310 bool
7312 {
7315 /* Structured binding when initialized with an array type needs
7316 to have complete type. */
7321 {
7326 }
7328 /* The array type itself need not be complete, because the
7329 initializer may tell us how many elements are in the array.
7330 But, the elements of the array must be complete. */
7332 {
7336 else
7339 }
7345 /* A compound literal can't have variable size. */
7349 {
7352 }
7354 }
7356 /* Subroutine of check_initializer; args are passed down from that function.
7357 Set stmts_are_full_exprs_p to 1 across a call to build_aggr_init. */
7359 static tree
7361 {
7366 }
7368 /* Verify INIT (the initializer for DECL), and record the
7369 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
7370 grok_reference_init.
7372 If the return value is non-NULL, it is an expression that must be
7373 evaluated dynamically to initialize DECL. */
7375 static tree
7377 {
7378 tree type;
7380 tree core_type;
7382 /* Things that are going to be initialized need to have complete
7383 type. */
7387 {
7388 /* A variable with DECL_HAS_VALUE_EXPR_P set is just a placeholder,
7389 it doesn't have storage to be initialized. */
7392 }
7395 /* We will have already complained. */
7399 {
7402 }
7404 {
7409 }
7410 else
7411 /* There is no way to make a variable-sized class type in GNU C++. */
7415 {
7418 {
7420 {
7423 }
7425 {
7427 "scalar object %qD requires one element in "
7431 }
7432 }
7433 }
7436 {
7443 }
7445 ;
7448 {
7450 {
7453 }
7456 tf_warning_or_error);
7457 /* Do not reshape constructors of vectors (they don't need to be
7458 reshaped. */
7460 {
7462 {
7464 tf_warning_or_error);
7466 }
7468 {
7469 /* Don't reshape if the class has constructors. */
7472 "in C++98 %qD must be initialized by "
7474 decl);
7475 }
7477 {
7480 }
7481 else
7482 {
7485 }
7486 }
7487 /* [dcl.init] "Otherwise, if the destination type is an array, the object
7488 is initialized as follows..." So handle things like
7490 int a[](1, 2, 3);
7492 which is permitted in C++20 by P0960. */
7502 {
7505 /* We get here with code like `int a (2);' */
7507 tf_warning_or_error);
7508 }
7510 /* If DECL has an array type without a specific bound, deduce the
7511 array size from the initializer. */
7522 /* The call to build_aggr_init below could end up
7523 calling build_vec_init, which may break when we
7524 are processing a template. */
7525 || processing_template_decl
7529 {
7532 /* A constructor call is a non-trivial initializer even if
7533 it isn't explicitly written. */
7537 /* If this is a constexpr initializer, expand_default_init will
7538 have returned an INIT_EXPR rather than a CALL_EXPR. In that
7539 case, pull the initializer back out and pass it down into
7540 store_init_value. */
7542 {
7549 else
7551 }
7553 {
7554 /* In C++20, the call to build_aggr_init could have created
7555 an INIT_EXPR with a CONSTRUCTOR as the RHS to handle
7556 A(1, 2). */
7559 /* Avoid leaking TARGET_EXPR into template trees. */
7564 /* Don't call digest_init; it's unnecessary and will complain
7565 about aggregate initialization of non-aggregate classes. */
7567 }
7570 {
7571 /* Declared constexpr or constinit, but no suitable initializer;
7572 massage init appropriately so we can pass it into
7573 store_init_value for the error. */
7583 {
7588 }
7590 }
7591 else
7593 }
7596 {
7602 {
7607 }
7619 }
7620 }
7621 else
7622 {
7630 tf_warning_or_error);
7631 }
7641 {
7642 /* We might have set these in cp_finish_decl. */
7645 }
7650 {
7658 else
7662 {
7666 }
7668 }
7671 }
7673 /* If DECL is not a local variable, give it RTL. */
7675 static void
7677 {
7681 /* Set the DECL_ASSEMBLER_NAME for the object. */
7683 {
7684 /* The `register' keyword, when used together with an
7685 asm-specification, indicates that the variable should be
7686 placed in a particular register. */
7688 {
7691 }
7692 else
7693 {
7700 /* We have to propagate the name to the ns-alias.
7701 This is horrible, as we're affecting a
7702 possibly-shared decl. Again, a one-true-decl
7703 model breaks down. */
7706 }
7707 }
7709 /* Handle non-variables up front. */
7711 {
7714 }
7716 /* If we see a class member here, it should be a static data
7717 member. */
7719 {
7721 /* An in-class declaration of a static data member should be
7722 external; it is only a declaration, and not a definition. */
7726 }
7728 /* We don't create any RTL for local variables. */
7732 /* We defer emission of local statics until the corresponding
7733 DECL_EXPR is expanded. But with constexpr its function might never
7734 be expanded, so go ahead and tell cgraph about the variable now. */
7739 /* Defer template instantiations. */
7744 /* If we're not deferring, go ahead and assemble the variable. */
7747 }
7749 /* walk_tree helper for wrap_temporary_cleanups, below. */
7751 static tree
7753 {
7754 /* Stop at types or full-expression boundaries. */
7757 {
7760 }
7763 {
7769 {
7771 /* Tell honor_protect_cleanup_actions to handle this as a separate
7772 cleanup. */
7775 }
7776 }
7779 }
7781 /* We're initializing a local variable which has a cleanup GUARD. If there
7782 are any temporaries used in the initializer INIT of this variable, we
7783 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
7784 variable will be cleaned up properly if one of them throws.
7786 Unfortunately, there's no way to express this properly in terms of
7787 nesting, as the regions for the temporaries overlap the region for the
7788 variable itself; if there are two temporaries, the variable needs to be
7789 the first thing destroyed if either of them throws. However, we only
7790 want to run the variable's cleanup if it actually got constructed. So
7791 we need to guard the temporary cleanups with the variable's cleanup if
7792 they are run on the normal path, but not if they are run on the
7793 exceptional path. We implement this by telling
7794 honor_protect_cleanup_actions to strip the variable cleanup from the
7795 exceptional path.
7797 Another approach could be to make the variable cleanup region enclose
7798 initialization, but depend on a flag to indicate that the variable is
7799 initialized; that's effectively what we do for arrays. But the current
7800 approach works fine for non-arrays, and has no code overhead in the usual
7801 case where the temporary destructors are noexcept. */
7803 static void
7805 {
7807 {
7808 /* An array cleanup region already encloses any temporary cleanups,
7809 don't wrap it around them again. */
7812 }
7814 }
7816 /* Generate code to initialize DECL (a local variable). */
7818 static void
7820 {
7822 tree cleanup;
7830 {
7831 /* If we used it already as memory, it must stay in memory. */
7835 }
7840 /* Compute and store the initial value. */
7845 /* Generate a cleanup, if necessary. */
7848 /* Perform the initialization. */
7850 {
7855 {
7856 /* Stick simple initializers in DECL_INITIAL so that
7857 -Wno-init-self works (c++/34772). */
7861 {
7865 OPT_Winit_self,
7867 }
7868 }
7869 else
7870 {
7873 /* If we're only initializing a single object, guard the
7874 destructors of any temporaries used in its initializer with
7875 its destructor. */
7884 saved_stmts_are_full_exprs_p;
7885 }
7886 }
7888 /* Set this to 0 so we can tell whether an aggregate which was
7889 initialized was ever used. Don't do this if it has a
7890 destructor, so we don't complain about the 'resource
7891 allocation is initialization' idiom. Now set
7892 attribute((unused)) on types so decls of that type will be
7893 marked used. (see TREE_USED, above.) */
7895 && ! already_used
7904 }
7906 /* DECL is a VAR_DECL for a compiler-generated variable with static
7907 storage duration (like a virtual table) whose initializer is a
7908 compile-time constant. Initialize the variable and provide it to the
7909 back end. */
7911 void
7913 {
7914 tree init;
7920 /* Mark the decl as constexpr so that we can access its content
7921 at compile time. */
7928 }
7930 /* INIT is the initializer for a variable, as represented by the
7931 parser. Returns true iff INIT is value-dependent. */
7933 static bool
7935 {
7937 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
7940 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
7941 {
7954 }
7955 else
7956 /* It must be a simple expression, e.g., int i = 3; */
7960 }
7962 // Returns true if a DECL is VAR_DECL with the concept specifier.
7965 {
7967 // Not all variables have DECL_LANG_SPECIFIC.
7970 }
7972 /* A helper function to be called via walk_tree. If any label exists
7973 under *TP, it is (going to be) forced. Set has_forced_label_in_static. */
7975 static tree
7977 {
7983 }
7985 /* Return true if DECL has either a trivial destructor, or for C++20
7986 is constexpr and has a constexpr destructor. */
7988 static bool
7990 {
7996 }
8000 /* Helper function of omp_declare_variant_finalize. Finalize one
8001 "omp declare variant base" attribute. Return true if it should be
8002 removed. */
8004 static bool
8006 {
8008 {
8013 }
8018 {
8022 /* FIXME, adjusting simd args unimplemented. */
8024 }
8027 location_t varid_loc
8036 releasing_vec args;
8045 else
8050 {
8052 /* In C++20, we may need to perform ADL for a template
8053 name. */
8056 {
8058 {
8062 tf_warning_or_error);
8063 }
8064 else
8066 }
8068 {
8074 {
8078 tf_warning_or_error);
8079 }
8080 }
8081 }
8086 else
8096 {
8099 {
8103 }
8108 {
8111 }
8112 else
8113 {
8119 }
8120 }
8122 {
8125 }
8128 }
8130 /* Helper function, finish up "omp declare variant base" attribute
8131 now that there is a DECL. ATTR is the first "omp declare variant base"
8132 attribute. */
8134 void
8136 {
8146 {
8149 }
8151 {
8154 }
8156 {
8159 }
8161 {
8164 }
8166 {
8169 }
8170 /* This loop is like private_lookup_attribute, except that it works
8171 with tree * rather than tree, as we might want to remove the
8172 attributes that are diagnosed as errorneous. */
8174 {
8179 {
8181 {
8184 }
8185 }
8187 }
8188 }
8190 /* Finish processing of a declaration;
8191 install its line number and initial value.
8192 If the length of an array type is not known before,
8193 it must be determined now, from the initial value, or it is an error.
8195 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
8196 true, then INIT is an integral constant expression.
8198 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
8199 if the (init) syntax was used. */
8201 void
8204 {
8205 tree type;
8210 tree auto_node;
8215 {
8219 }
8222 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
8232 /* Warn about register storage specifiers except when in GNU global
8233 or local register variable extension. */
8235 {
8238 "ISO C++17 does not allow %<register%> storage "
8240 else
8243 }
8245 /* If a name was specified, get the string. */
8251 bool in_class_decl
8252 = (current_class_type
8263 {
8264 tree d_init;
8266 {
8270 {
8271 /* init is null because we're deferring instantiating the
8272 initializer until we need it. Well, we need it now. */
8275 }
8278 }
8281 {
8285 tf_warning_or_error);
8287 /* Force auto deduction now. Use tf_none to avoid redundant warnings
8288 on deprecated-14.C. */
8290 }
8299 /* The outer template arguments might be needed for satisfaction.
8300 (For function scope variables, do_auto_deduction will obtain the
8301 outer template arguments from current_function_decl.) */
8309 {
8314 }
8315 /* As in start_decl_1, complete so TREE_READONLY is set properly. */
8319 {
8325 }
8328 /* Update the type of the corresponding TEMPLATE_DECL to match. */
8333 }
8336 {
8339 {
8342 }
8343 }
8353 {
8355 ? TCTX_THREAD_STORAGE
8358 }
8361 {
8362 tree clone;
8364 {
8365 /* FIXME check this is 1st decl. */
8370 {
8374 }
8376 }
8378 {
8381 else
8383 }
8384 }
8387 {
8389 /* If DECL is a reference, then we want to know whether init is a
8390 reference constant; init_const_expr_p as passed tells us whether
8391 it's an rvalue constant. */
8395 {
8396 /* Set these flags now for templates. We'll update the flags in
8397 store_init_value for instantiations. */
8400 /* FIXME setting TREE_CONSTANT on refs breaks the back end. */
8403 }
8404 /* This is handled mostly by gimplify.cc, but we have to deal with
8405 not warning about int x = x; as it is a GCC extension to turn off
8406 this warning but only if warn_init_self is zero. */
8412 }
8416 /* #pragma omp declare variant on methods handled in finish_struct
8417 instead. */
8425 {
8428 /* Add this declaration to the statement-tree. */
8435 {
8438 }
8440 /* Generally, initializers in templates are expanded when the
8441 template is instantiated. But, if DECL is a variable constant
8442 then it can be used in future constant expressions, so its value
8443 must be available. */
8450 {
8453 }
8459 {
8460 /* This variable seems to be a non-dependent constant, so process
8461 its initializer. If check_initializer returns non-null the
8462 initialization wasn't constant after all. */
8463 tree init_code;
8469 }
8470 else
8471 {
8473 /* Try to deduce array size. */
8475 /* And complain about multiple initializers. */
8479 tf_warning_or_error);
8480 }
8486 {
8489 }
8492 {
8495 }
8497 }
8499 /* Just store non-static data member initializers for later. */
8503 /* Take care of TYPE_DECLs up front. */
8505 {
8508 {
8512 }
8514 /* If we have installed this as the canonical typedef for this
8515 type, and that type has not been defined yet, delay emitting
8516 the debug information for it, as we will emit it later. */
8522 at_eof);
8524 }
8526 /* A reference will be modified here, as it is initialized. */
8530 {
8533 }
8535 /* This needs to happen before extend_ref_init_temps. */
8537 {
8541 }
8544 {
8546 /* [dcl.constinit]/1 "The constinit specifier shall be applied
8547 only to a declaration of a variable with static or thread storage
8548 duration." */
8551 {
8553 "%<constinit%> can only be applied to a variable with "
8556 }
8558 /* If this is a local variable that will need a mangled name,
8559 register it now. We must do this before processing the
8560 initializer for the variable, since the initialization might
8561 require a guard variable, and since the mangled name of the
8562 guard variable will depend on the mangled name of this
8563 variable. */
8567 {
8568 /* The variable holding an anonymous union will have had its
8569 discriminator set in finish_anon_union, after which it's
8570 NAME will have been cleared. */
8573 /* Normally has_forced_label_in_static is set during GIMPLE
8574 lowering, but [cd]tors are never actually compiled directly.
8575 We need to set this early so we can deal with the label
8576 address extension. */
8580 {
8583 }
8584 /* And make sure it's in the symbol table for
8585 c_parse_final_cleanups to find. */
8587 }
8589 /* Convert the initializer to the type of DECL, if we have not
8590 already initialized DECL. */
8592 /* If !DECL_EXTERNAL then DECL is being defined. In the
8593 case of a static data member initialized inside the
8594 class-specifier, there can be an initializer even if DECL
8595 is *not* defined. */
8597 {
8601 /* Handle:
8603 [dcl.init]
8605 The memory occupied by any object of static storage
8606 duration is zero-initialized at program startup before
8607 any other initialization takes place.
8609 We cannot create an appropriate initializer until after
8610 the type of DECL is finalized. If DECL_INITIAL is set,
8611 then the DECL is statically initialized, and any
8612 necessary zero-initialization has already been performed. */
8617 /* Remember that the initialization for this variable has
8618 taken place. */
8620 /* This declaration is the definition of this variable,
8621 unless we are initializing a static data member within
8622 the class specifier. */
8625 }
8626 /* If the variable has an array type, lay out the type, even if
8627 there is no initializer. It is valid to index through the
8628 array, and we must get TYPE_ALIGN set correctly on the array
8629 type. */
8636 /* So decl is a global variable or a static member of a
8637 non local class. Record the types it uses
8638 so that we can decide later to emit debug info for them. */
8640 }
8642 /* Add this declaration to the statement-tree. This needs to happen
8643 after the call to check_initializer so that the DECL_EXPR for a
8644 reference temp is added before the DECL_EXPR for the reference itself. */
8646 {
8647 /* If we're building a variable sized type, and we might be
8648 reachable other than via the top of the current binding
8649 level, then create a new BIND_EXPR so that we deallocate
8650 the object at the right time. */
8655 {
8656 tree bind;
8661 }
8663 }
8665 /* Let the middle end know about variables and functions -- but not
8666 static data members in uninstantiated class templates. */
8668 {
8670 {
8673 /* Check again now that we have an initializer. */
8675 /* A class-scope constexpr variable with an out-of-class declaration.
8676 C++17 makes them implicitly inline, but still force it out. */
8682 }
8685 /* With -fmerge-all-constants, gimplify_init_constructor
8686 might add TREE_STATIC to the variable. */
8688 {
8689 /* If a TREE_READONLY variable needs initialization
8690 at runtime, it is no longer readonly and we need to
8691 avoid MEM_READONLY_P being set on RTL created for it. */
8693 {
8697 }
8701 /* Likewise if it needs destruction. */
8704 }
8708 /* Check for abstractness of the type. */
8713 /* No initialization required. */
8714 ;
8716 {
8718 {
8720 {
8721 /* An out-of-class default definition is defined at
8722 the point where it is explicitly defaulted. */
8727 }
8728 else
8732 decl);
8733 }
8734 /* else no initialization required. */
8735 }
8739 {
8740 /* check_initializer will have done any constant initialization. */
8741 }
8742 /* A variable definition. */
8744 /* Initialize the local variable. */
8747 /* If a variable is defined, and then a subsequent
8748 definition with external linkage is encountered, we will
8749 get here twice for the same variable. We want to avoid
8750 calling expand_static_init more than once. For variables
8751 that are not static data members, we can call
8752 expand_static_init only when we actually process the
8753 initializer. It is not legal to redeclare a static data
8754 member, so this issue does not arise in that case. */
8757 }
8759 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
8760 reference, insert it in the statement-tree now. */
8762 {
8764 {
8766 /* As in initialize_local_var. */
8768 }
8770 }
8779 {
8785 {
8791 }
8796 {
8802 {
8805 {
8809 }
8810 }
8811 }
8812 }
8814 /* This is the last point we can lower alignment so give the target the
8815 chance to do so. */
8822 }
8824 /* For class TYPE return itself or some its bases that contain
8825 any direct non-static data members. Return error_mark_node if an
8826 error has been diagnosed. */
8828 static tree
8830 {
8840 {
8844 else
8849 }
8851 {
8859 }
8860 else
8870 {
8875 {
8877 {
8882 }
8886 {
8888 "classes %qT and %qT have non-static data "
8891 }
8892 else
8894 }
8895 }
8897 }
8899 /* Return std::tuple_size<TYPE>::value. */
8901 static tree
8903 {
8919 else
8921 }
8923 /* Return std::tuple_element<I,TYPE>::type. */
8925 static tree
8927 {
8935 tf_warning_or_error);
8938 }
8940 /* Return e.get<i>() or get<i>(e). */
8942 static tree
8944 {
8951 /* [The id-expression] e is an lvalue if the type of the entity e is an
8952 lvalue reference and an xvalue otherwise. */
8961 /* To use a member get, member lookup must find at least one
8962 declaration that is a function template
8963 whose first template parameter is a non-type parameter. */
8965 {
8968 {
8972 {
8975 }
8976 }
8977 }
8980 {
8985 }
8986 else
8987 {
8993 }
8994 }
8996 /* It's impossible to recover the decltype of a tuple decomposition variable
8997 based on the actual type of the variable, so store it in a hash table. */
9001 tree
9003 {
9005 }
9007 /* Mangle a decomposition declaration if needed. Arguments like
9008 in cp_finish_decomp. */
9010 void
9012 {
9016 {
9024 }
9025 }
9027 /* Finish a decomposition declaration. DECL is the underlying declaration
9028 "e", FIRST is the head of a chain of decls for the individual identifiers
9029 chained through DECL_CHAIN in reverse order and COUNT is the number of
9030 those decls. */
9032 void
9034 {
9036 {
9037 error_out:
9039 {
9042 {
9045 }
9047 }
9051 }
9055 /* This happens for range for when not in templates.
9056 Still add the DECL_VALUE_EXPRs for later processing. */
9057 || (!processing_template_decl
9059 {
9061 {
9063 {
9069 }
9073 }
9075 }
9081 {
9084 }
9090 {
9096 {
9098 type);
9100 }
9101 }
9106 {
9107 tree nelts;
9112 {
9115 }
9118 {
9119 cnt_mismatch:
9124 else
9133 }
9136 {
9145 }
9146 }
9147 /* 2 GNU extensions. */
9149 {
9155 {
9164 }
9165 }
9167 {
9169 {
9172 }
9177 {
9188 }
9189 }
9191 {
9193 {
9197 }
9199 {
9206 }
9212 {
9223 {
9227 }
9229 {
9233 }
9234 /* Save the decltype away before reference collapse. */
9240 {
9241 /* In this case the names are variables, not just proxies. */
9244 }
9246 {
9250 }
9251 }
9252 /* Ignore reads from the underlying decl performed during initialization
9253 of the individual variables. If those will be read, we'll mark
9254 the underlying decl as read at that point. */
9256 }
9258 {
9261 }
9263 {
9266 }
9268 {
9271 }
9276 type);
9277 else
9278 {
9283 {
9287 }
9293 else
9294 eltscnt++;
9299 {
9303 }
9310 else
9311 {
9313 NULL_TREE);
9319 {
9322 }
9323 i++;
9324 }
9325 }
9327 {
9330 {
9335 }
9336 }
9337 }
9339 /* Returns a declaration for a VAR_DECL as if:
9341 extern "C" TYPE NAME;
9343 had been seen. Used to create compiler-generated global
9344 variables. */
9346 static tree
9348 {
9355 /* If the user has explicitly declared this variable (perhaps
9356 because the code we are compiling is part of a low-level runtime
9357 library), then it is possible that our declaration will be merged
9358 with theirs by pushdecl. */
9364 }
9366 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
9367 if "__cxa_atexit" is not being used) corresponding to the function
9368 to be called when the program exits. */
9370 static tree
9372 {
9373 tree fn_type;
9376 {
9377 tree arg_type;
9380 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
9382 else
9383 /* The parameter to "atexit" is "void (*)(void)". */
9389 }
9392 }
9394 /* Returns a pointer to the `atexit' function. Note that if
9395 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
9396 `__cxa_atexit' function specified in the IA64 C++ ABI. */
9398 static tree
9400 {
9401 tree atexit_fndecl;
9402 tree fn_type;
9403 tree fn_ptr_type;
9412 {
9413 /* The declaration for `__cxa_atexit' is:
9415 int __cxa_atexit (void (*)(void *), void *, void *)
9417 We build up the argument types and then the function type
9418 itself. */
9422 /* First, build the pointer-to-function type for the first
9423 argument. */
9425 /* Then, build the rest of the argument types. */
9428 {
9431 }
9432 else
9433 {
9436 }
9437 /* And the final __cxa_atexit type. */
9440 NULL_TREE);
9441 /* ... which needs noexcept. */
9444 {
9452 }
9453 else
9454 {
9457 }
9458 }
9459 else
9460 {
9461 /* The declaration for `atexit' is:
9463 int atexit (void (*)());
9465 We build up the argument types and then the function type
9466 itself. */
9468 /* Build the final atexit type. */
9471 /* ... which needs noexcept. */
9474 }
9476 /* Now, build the function declaration. */
9481 /* Install as hidden builtin so we're (a) more relaxed about
9482 exception spec matching and (b) will not give a confusing location
9483 in diagnostic and (c) won't magically appear in user-visible name
9484 lookups. */
9493 }
9495 /* Like get_atexit_node, but for thread-local cleanups. */
9497 static tree
9499 {
9500 /* The declaration for `__cxa_thread_atexit' is:
9502 int __cxa_thread_atexit (void (*)(void *), void *, void *) */
9506 NULL_TREE);
9508 /* Now, build the function declaration. */
9512 }
9514 /* Returns the __dso_handle VAR_DECL. */
9516 static tree
9518 {
9522 /* Declare the variable. */
9524 ptr_type_node);
9526 #ifdef HAVE_GAS_HIDDEN
9528 {
9531 }
9532 #endif
9535 }
9537 /* Begin a new function with internal linkage whose job will be simply
9538 to destroy some particular variable. */
9542 static tree
9544 {
9549 /* No need to mangle this. */
9552 /* Build the name of the function. */
9554 /* Build the function declaration. */
9558 /* It's a function with internal linkage, generated by the
9559 compiler. */
9562 /* Make the function `inline' so that it is only emitted if it is
9563 actually needed. It is unlikely that it will be inlined, since
9564 it is only called via a function pointer, but we avoid unnecessary
9565 emissions this way. */
9569 {
9570 /* Build the parameter. */
9575 }
9583 }
9585 /* Finish the cleanup function begun by start_cleanup_fn. */
9587 static void
9589 {
9593 }
9595 /* Generate code to handle the destruction of DECL, an object with
9596 static storage duration. */
9598 tree
9600 {
9601 tree cleanup;
9602 tree addr;
9603 tree compound_stmt;
9604 tree fcall;
9605 tree type;
9608 tree atex_node;
9616 {
9619 }
9621 /* If we're using "__cxa_atexit" (or "__cxa_thread_atexit" or
9622 "__aeabi_atexit"), and DECL is a class object, we can just pass the
9623 destructor to "__cxa_atexit"; we don't have to build a temporary
9624 function to do the cleanup. */
9625 dso_parm = (flag_use_cxa_atexit
9630 {
9633 /* Make sure it is accessible. */
9635 tf_warning_or_error);
9636 }
9637 else
9638 {
9639 /* Call build_cleanup before we enter the anonymous function so
9640 that any access checks will be done relative to the current
9641 scope, rather than the scope of the anonymous function. */
9644 /* Now start the function. */
9647 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
9648 to the original function, rather than the anonymous one. That
9649 will make the back end think that nested functions are in use,
9650 which causes confusion. */
9655 /* Create the body of the anonymous function. */
9660 }
9662 /* Call atexit with the cleanup function. */
9668 else
9672 {
9673 /* We must convert CLEANUP to the type that "__cxa_atexit"
9674 expects. */
9676 /* "__cxa_atexit" will pass the address of DECL to the
9677 cleanup function. */
9680 /* The declared type of the parameter to "__cxa_atexit" is
9681 "void *". For plain "T*", we could just let the
9682 machinery in cp_build_function_call convert it -- but if the
9683 type is "cv-qualified T *", then we need to convert it
9684 before passing it in, to avoid spurious errors. */
9686 }
9687 else
9688 /* Since the cleanup functions we build ignore the address
9689 they're given, there's no reason to pass the actual address
9690 in, and, in general, it's cheaper to pass NULL than any
9691 other value. */
9696 tf_warning_or_error);
9698 /* Just pass NULL to the dso handle parm if we don't actually
9699 have a DSO handle on this target. */
9701 else
9705 {
9708 {
9711 }
9712 else
9713 {
9716 }
9717 }
9718 else
9719 {
9722 }
9725 }
9727 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
9728 is its initializer. Generate code to handle the construction
9729 and destruction of DECL. */
9731 static void
9733 {
9737 /* Some variables require no dynamic initialization. */
9739 {
9740 /* Make sure the destructor is callable. */
9744 }
9748 {
9753 else
9758 {
9762 }
9764 }
9767 {
9768 /* Emit code to perform this initialization but once. */
9773 /* We don't need thread-safety code for thread-local vars. */
9777 /* Emit code to perform this initialization but once. This code
9778 looks like:
9780 static <type> guard;
9781 if (!__atomic_load (guard.first_byte)) {
9782 if (__cxa_guard_acquire (&guard)) {
9783 bool flag = false;
9784 try {
9785 // Do initialization.
9786 flag = true; __cxa_guard_release (&guard);
9787 // Register variable for destruction at end of program.
9788 } catch {
9789 if (!flag) __cxa_guard_abort (&guard);
9790 }
9791 }
9792 }
9794 Note that the `flag' variable is only set to 1 *after* the
9795 initialization is complete. This ensures that an exception,
9796 thrown during the construction, will cause the variable to
9797 reinitialized when we pass through this code again, as per:
9799 [stmt.dcl]
9801 If the initialization exits by throwing an exception, the
9802 initialization is not complete, so it will be tried again
9803 the next time control enters the declaration.
9805 This process should be thread-safe, too; multiple threads
9806 should not be able to initialize the variable more than
9807 once. */
9809 /* Create the guard variable. */
9812 /* Begin the conditional initialization. */
9819 {
9832 acquire_fn = push_library_fn
9835 NULL_TREE),
9840 NULL_TREE);
9843 ECF_NOTHROW);
9850 inner_if_stmt);
9858 void_node,
9862 /* Do the initialization itself. */
9868 /* Use atexit to register a function for destroying this static
9869 variable. Do this before calling __cxa_guard_release. */
9873 guard_addr));
9874 }
9875 else
9876 {
9879 /* Use atexit to register a function for destroying this static
9880 variable. */
9882 }
9887 {
9891 }
9896 }
9899 else
9901 }
9903 \f
9904 /* Make TYPE a complete type based on INITIAL_VALUE.
9905 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
9906 2 if there was no information (in which case assume 0 if DO_DEFAULT),
9907 3 if the initializer list is empty (in pedantic mode). */
9909 int
9911 {
9915 /* Don't get confused by a CONSTRUCTOR for some other type. */
9922 {
9923 /* An array of character type can be initialized from a
9924 brace-enclosed string constant so call reshape_init to
9925 remove the optional braces from a braced string literal. */
9929 tf_warning_or_error);
9931 /* If any of the elements are parameter packs, we can't actually
9932 complete this type now because the array size is dependent. */
9937 }
9941 /* We can create the array before the element type is complete, which
9942 means that we didn't have these two bits set in the original type
9943 either. In completing the type, we are expected to propagate these
9944 bits. See also complete_type which does the same thing for arrays
9945 of fixed size. */
9948 {
9953 }
9956 }
9958 /* As above, but either give an error or reject zero-size arrays, depending
9959 on COMPLAIN. */
9961 int
9964 {
9967 /* In SFINAE context we can't be lenient about zero-size arrays. */
9974 {
9980 {
9983 }
9987 }
9989 }
9990 \f
9991 /* Return zero if something is declared to be a member of type
9992 CTYPE when in the context of CUR_TYPE. STRING is the error
9993 message to print in that case. Otherwise, quietly return 1. */
9995 static int
9997 {
9999 {
10002 else
10005 }
10007 }
10008 \f
10009 /* Subroutine of `grokdeclarator'. */
10011 /* Generate errors possibly applicable for a given set of specifiers.
10012 This is for ARM $7.1.2. */
10014 static void
10023 {
10025 {
10069 }
10073 && !flag_noexcept_type
10079 }
10081 /* DECL is a member function or static data member and is presently
10082 being defined. Check that the definition is taking place in a
10083 valid namespace. */
10085 static void
10087 {
10088 /* These checks only apply to member functions and static data
10089 members. */
10091 /* We check for problems with specializations in pt.cc in
10092 check_specialization_namespace, where we can issue better
10093 diagnostics. */
10096 /* We check this in check_explicit_instantiation_namespace. */
10099 /* [class.mfct]
10101 A member function definition that appears outside of the
10102 class definition shall appear in a namespace scope enclosing
10103 the class definition.
10105 [class.static.data]
10107 The definition for a static data member shall appear in a
10108 namespace scope enclosing the member's class definition. */
10112 }
10114 /* Build a PARM_DECL for the "this" parameter of FN. TYPE is the
10115 METHOD_TYPE for a non-static member function; QUALS are the
10116 cv-qualifiers that apply to the function. */
10118 tree
10120 {
10121 tree this_type;
10122 tree qual_type;
10123 tree parm;
10124 cp_cv_quals this_quals;
10127 {
10128 this_type
10131 }
10132 else
10134 /* The `this' parameter is implicitly `const'; it cannot be
10135 assigned to. */
10141 }
10143 /* DECL is a static member function. Complain if it was declared
10144 with function-cv-quals. */
10146 static void
10148 {
10151 decl);
10152 }
10154 // Check that FN takes no arguments and returns bool.
10155 static void
10157 {
10158 // A constraint is nullary.
10163 // The declared return type of the concept shall be bool, and
10164 // it shall not be deduced from it definition.
10172 }
10174 /* Helper function. Replace the temporary this parameter injected
10175 during cp_finish_omp_declare_simd with the real this parameter. */
10177 static tree
10179 {
10188 }
10190 /* CTYPE is class type, or null if non-class.
10191 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
10192 or METHOD_TYPE.
10193 DECLARATOR is the function's name.
10194 PARMS is a chain of PARM_DECLs for the function.
10195 VIRTUALP is truthvalue of whether the function is virtual or not.
10196 FLAGS are to be passed through to `grokclassfn'.
10197 QUALS are qualifiers indicating whether the function is `const'
10198 or `volatile'.
10199 RAISES is a list of exceptions that this function can raise.
10200 CHECK is 1 if we must find this method in CTYPE, 0 if we should
10201 not look, and -1 if we should not call `grokclassfn' at all.
10203 SFK is the kind of special function (if any) for the new function.
10205 Returns `NULL_TREE' if something goes wrong, after issuing
10206 applicable error messages. */
10208 static tree
10210 tree type,
10211 tree declarator,
10212 tree parms,
10213 tree orig_declarator,
10215 tree decl_reqs,
10218 cp_cv_quals quals,
10219 cp_ref_qualifier rqual,
10220 tree raises,
10226 special_function_kind sfk,
10230 tree in_namespace,
10232 location_t location)
10233 {
10234 tree decl;
10236 tree t;
10241 /* Was the concept specifier present? */
10244 /* Concept declarations must have a corresponding definition. */
10246 {
10249 }
10255 /* Set the constraints on the declaration. */
10257 {
10262 && (current_template_depth
10265 {
10267 /* If there are no template parameters, something must have
10268 gone wrong. */
10270 else
10272 }
10275 {
10278 }
10279 /* C++20 CA378: Remove non-templated constrained functions. */
10281 && (block_local
10282 || (!flag_concepts_ts
10283 && (!processing_template_decl
10285 {
10288 }
10290 }
10293 {
10298 /* Allocate space to hold the vptr bit if needed. */
10300 }
10306 /* Propagate volatile out from type to decl. */
10310 /* Setup decl according to sfk. */
10312 {
10325 }
10328 {
10332 orig_declarator);
10333 else
10334 {
10339 {
10340 /* Something like `template <class T> friend void f<T>()'. */
10342 "invalid use of template-id %qD in declaration "
10344 orig_declarator);
10346 }
10348 /* A friend declaration of the form friend void f<>(). Record
10349 the information in the TEMPLATE_ID_EXPR. */
10358 {
10360 "default arguments are not allowed in declaration "
10362 decl);
10364 }
10367 {
10369 "%<inline%> is not allowed in declaration of friend "
10371 decl);
10373 }
10374 }
10375 }
10377 /* C++17 11.3.6/4: "If a friend declaration specifies a default argument
10378 expression, that declaration shall be a definition..." */
10380 {
10384 {
10386 "friend declaration of %qD specifies default "
10389 }
10390 }
10392 /* If this decl has namespace scope, set that up. */
10397 else
10400 /* `main' and builtins have implicit 'C' linkage. */
10415 /* Should probably propagate const out from type to decl I bet (mrs). */
10417 {
10420 }
10429 {
10445 }
10447 /* Members of anonymous types and local classes have no linkage; make
10448 them internal. If a typedef is made later, this will be changed. */
10454 {
10455 /* [basic.link]: A name with no linkage (notably, the name of a class
10456 or enumeration declared in a local scope) shall not be used to
10457 declare an entity with linkage.
10459 DR 757 relaxes this restriction for C++0x. */
10461 }
10465 {
10468 }
10470 /* If the declaration was declared inline, mark it as such. */
10472 {
10476 }
10480 {
10483 }
10485 // If the concept declaration specifier was found, check
10486 // that the declaration satisfies the necessary requirements.
10488 {
10491 }
10495 {
10498 TYPE_UNQUALIFIED,
10499 REF_QUAL_NONE);
10502 {
10506 decl);
10508 }
10511 {
10515 decl);
10517 }
10518 }
10521 {
10525 {
10530 }
10533 {
10537 }
10541 }
10546 {
10550 /* [over.literal]/6: Literal operators shall not have C linkage. */
10552 {
10556 }
10559 {
10562 {
10565 }
10569 {
10573 }
10575 {
10579 }
10580 /* 17.6.3.3.5 */
10584 "literal operator suffixes not preceded by %<_%>"
10586 }
10587 else
10588 {
10591 }
10592 }
10595 /* Make the init_value nonzero so pushdecl knows this is not
10596 tentative. error_mark_node is replaced later with the BLOCK. */
10603 {
10604 /* Adjust "omp declare simd" attributes. */
10607 {
10608 tree attr;
10611 {
10616 {
10618 cl = c_omp_declare_simd_clauses_to_numbers
10622 else
10624 }
10625 }
10626 }
10627 }
10629 /* Caller will do the rest of this. */
10636 /* 12.4/3 */
10646 template_count,
10658 {
10661 }
10666 /* Check main's type after attributes have been applied. */
10668 {
10670 integer_type_node))
10671 {
10673 tree newtype;
10678 }
10681 }
10684 {
10686 (current_template_depth
10688 ? current_template_parms
10695 {
10696 tree ok;
10697 tree pushed_scope;
10700 /* Because grokfndecl is always supposed to return a
10701 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
10702 here. We depend on our callers to figure out that its
10703 really a template that's being returned. */
10708 {
10709 /* Remove the `this' parm added by grokclassfn. */
10712 }
10714 {
10717 }
10719 {
10724 }
10726 /* Since we've smashed OLD_DECL to its
10727 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
10731 /* Attempt to merge the declarations. This can fail, in
10732 the case of some invalid specialization declarations. */
10738 {
10742 }
10746 }
10747 }
10759 }
10761 /* decl is a FUNCTION_DECL.
10762 specifiers are the parsed virt-specifiers.
10764 Set flags to reflect the virt-specifiers.
10766 Returns decl. */
10768 static tree
10770 {
10778 }
10780 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
10781 the linkage that DECL will receive in the object file. */
10783 static void
10785 {
10786 /* A static data member always has static storage duration and
10787 external linkage. Note that static data members are forbidden in
10788 local classes -- the only situation in which a class has
10789 non-external linkage. */
10792 /* For non-template classes, static data members are always put
10793 out in exactly those files where they are defined, just as
10794 with ordinary namespace-scope variables. */
10797 }
10799 /* Create a VAR_DECL named NAME with the indicated TYPE.
10801 If SCOPE is non-NULL, it is the class type or namespace containing
10802 the variable. If SCOPE is NULL, the variable should is created in
10803 the innermost enclosing scope. */
10805 static tree
10807 tree name,
10808 tree orig_declarator,
10815 tree scope,
10816 location_t location)
10817 {
10818 tree decl;
10819 tree explicit_scope;
10826 /* Compute the scope in which to place the variable, but remember
10827 whether or not that scope was explicitly specified by the user. */
10830 {
10831 /* An explicit "extern" specifier indicates a namespace-scope
10832 variable. */
10837 }
10841 template, we need DECL_LANG_SPECIFIC. */
10843 /* Similarly for namespace-scope variables with language linkage
10844 other than C++. */
10847 /* Similarly for static data members. */
10849 /* Similarly for explicit specializations. */
10850 || (orig_declarator
10853 else
10858 else
10862 {
10865 }
10868 {
10870 /* This function is only called with out-of-class definitions. */
10873 }
10874 /* At top level, either `static' or no s.c. makes a definition
10875 (perhaps tentative), and absence of `static' makes it public. */
10877 {
10880 || ! constp
10881 || volatilep
10884 }
10885 /* Not at top level, only `static' makes a static definition. */
10886 else
10887 {
10890 }
10895 {
10897 {
10901 }
10904 }
10906 /* If the type of the decl has no linkage, make sure that we'll
10907 notice that in mark_used. */
10916 {
10917 /* [basic.link]: A name with no linkage (notably, the name of a class
10918 or enumeration declared in a local scope) shall not be used to
10919 declare an entity with linkage.
10921 DR 757 relaxes this restriction for C++0x. */
10924 }
10925 else
10934 /* Check that the variable can be safely declared as a concept.
10935 Note that this also forbids explicit specializations. */
10937 {
10939 {
10943 }
10945 {
10949 }
10950 else
10956 {
10959 }
10960 }
10963 {
10966 }
10968 // Handle explicit specializations and instantiations of variable templates.
10974 }
10976 /* Create and return a canonical pointer to member function type, for
10977 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
10979 tree
10981 {
10983 tree t;
10988 /* Make sure that we always have the unqualified pointer-to-member
10989 type first. */
10991 {
10994 }
10996 /* If a canonical type already exists for this type, use it. We use
10997 this method instead of type_hash_canon, because it only does a
10998 simple equality check on the list of field members. */
11006 /* Let the front end know this is a pointer to member function. */
11014 delta_type_node);
11021 /* Zap out the name so that the back end will give us the debugging
11022 information for this anonymous RECORD_TYPE. */
11025 /* Cache this pointer-to-member type so that we can find it again
11026 later. */
11035 }
11037 /* Create and return a pointer to data member type. */
11039 tree
11041 {
11043 {
11048 }
11049 else
11050 {
11053 }
11054 }
11056 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
11057 Check to see that the definition is valid. Issue appropriate error
11058 messages. */
11060 static void
11062 {
11063 /* Avoid redundant diagnostics on out-of-class definitions. */
11065 ;
11066 /* Can't check yet if we don't know the type. */
11068 ;
11069 /* If DECL is declared constexpr, we'll do the appropriate checks
11070 in check_initializer. Similarly for inline static data members. */
11074 ;
11076 {
11079 "in-class initialization of static data member %q#D of "
11083 "%<constexpr%> needed for in-class initialization of "
11085 else
11087 "in-class initialization of static data member %q#D of "
11089 }
11090 /* Motion 10 at San Diego: If a static const integral data member is
11091 initialized with an integral constant expression, the initializer
11092 may appear either in the declaration (within the class), or in
11093 the definition, but not both. If it appears in the class, the
11094 member is a member constant. The file-scope definition is always
11095 required. */
11098 "invalid in-class initialization of static data member "
11100 type);
11103 "ISO C++ forbids in-class initialization of non-const "
11105 decl);
11108 "ISO C++ forbids initialization of member constant "
11110 }
11112 /* *expr_p is part of the TYPE_SIZE of a variably-sized array. If any
11113 SAVE_EXPRs in *expr_p wrap expressions with side-effects, break those
11114 expressions out into temporary variables so that walk_tree doesn't
11115 step into them (c++/15764). */
11117 static tree
11119 {
11123 {
11129 }
11133 }
11135 /* Entry point for the above. */
11137 static void
11139 {
11141 /* Break out any function calls into temporary variables. */
11143 }
11145 /* Reduce a SIZEOF_EXPR to its value. */
11147 tree
11149 {
11150 tree r;
11159 else
11166 }
11168 /* Given the SIZE (i.e., number of elements) in an array, compute
11169 an appropriate index type for the array. If non-NULL, NAME is
11170 the name of the entity being declared. */
11172 static tree
11174 tsubst_flags_t complain)
11175 {
11179 /* The type of the index being computed. */
11180 tree itype;
11182 /* The original numeric size as seen in the source code before
11183 conversion to size_t. */
11189 {
11194 /* In C++98, we mark a non-constant array bound with a magic
11196 else
11197 {
11199 /* Pedantically a constant expression is required here and so
11200 __builtin_is_constant_evaluated () should fold to true if it
11201 is successfully folded into a constant. */
11207 }
11212 /* The array bound must be an integer type. */
11215 {
11221 else
11224 }
11225 }
11227 /* A type is dependent if it is...an array type constructed from any
11228 dependent type or whose size is specified by a constant expression
11229 that is value-dependent. */
11230 /* We can only call value_dependent_expression_p on integral constant
11231 expressions. */
11235 {
11236 /* Just build the index type and mark that it requires
11237 structural equality checks. */
11238 in_template:
11245 }
11248 {
11251 {
11255 else
11258 }
11260 /* We might have lost the TREE_CONSTANT flag e.g. when we are
11261 folding a conversion from a pointer to integral type. In that
11263 else
11264 /* Use the folded result for VLAs, too; it will have resolved
11265 SIZEOF_EXPR. */
11267 }
11269 /* Normally, the array-bound will be a constant. */
11271 {
11272 /* The size to use in diagnostics that reflects the constant
11273 size used in the source, rather than SIZE massaged above. */
11276 /* If the original size before conversion to size_t was signed
11277 and negative, convert it to ssizetype to restore the sign. */
11281 {
11284 /* Clear the overflow bit that may have been set as a result
11285 of the conversion from the sizetype of the new size to
11286 ssizetype. */
11288 }
11290 /* Verify that the array has a positive number of elements
11291 and issue the appropriate diagnostic if it doesn't. */
11293 {
11297 }
11298 /* As an extension we allow zero-sized arrays. */
11300 {
11302 /* We must fail if performing argument deduction (as
11303 indicated by the state of complain), so that
11304 another substitution can be found. */
11309 else
11312 }
11313 }
11315 /* We don't allow VLAs at non-function scopes, or during
11316 tentative template substitution. */
11319 {
11322 /* `(int) &fn' is not a valid array bound. */
11326 name);
11327 else
11330 }
11332 {
11336 else
11339 }
11341 {
11345 else
11348 }
11352 else
11353 {
11355 {
11356 /* A variable sized array. Arrange for the SAVE_EXPR on the inside
11357 of the MINUS_EXPR, which allows the -1 to get folded with the +1
11358 that happens when building TYPE_SIZE. */
11361 }
11363 /* Compute the index of the largest element in the array. It is
11364 one less than the number of elements in the array. We save
11365 and restore PROCESSING_TEMPLATE_DECL so that computations in
11366 cp_build_binary_op will be appropriately folded. */
11367 {
11368 processing_template_decl_sentinel s;
11370 MINUS_EXPR,
11373 complain),
11374 complain);
11376 }
11379 {
11382 {
11383 /* We have to add 1 -- in the ubsan routine we generate
11384 LE_EXPR rather than LT_EXPR. */
11389 }
11390 }
11391 /* Make sure that there was no overflow when creating to a signed
11392 index type. (For example, on a 32-bit machine, an array with
11393 size 2^32 - 1 is too big.) */
11396 {
11401 }
11402 }
11404 /* Create and return the appropriate index type. */
11407 /* If the index type were dependent, we would have returned early, so
11408 remember that it isn't. */
11412 }
11414 tree
11416 {
11418 }
11420 /* Returns the scope (if any) in which the entity declared by
11421 DECLARATOR will be located. If the entity was declared with an
11422 unqualified name, NULL_TREE is returned. */
11424 tree
11426 {
11430 /* If the declarator-id is a SCOPE_REF, the scope in which the
11431 declaration occurs is the first operand. */
11436 /* Otherwise, the declarator is not a qualified name; the entity will
11437 be declared in the current scope. */
11439 }
11441 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
11442 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
11443 with this type. */
11445 static tree
11447 {
11450 /* If things have already gone awry, bail now. */
11454 /* [dcl.type.class.deduct] prohibits forming an array of placeholder
11455 for a deduced class type. */
11457 {
11461 else
11464 }
11466 /* If there are some types which cannot be array elements,
11467 issue an error-message and return. */
11469 {
11473 else
11480 else
11487 else
11494 name);
11495 else
11501 }
11507 /* [dcl.array]
11509 The constant expressions that specify the bounds of the arrays
11510 can be omitted only for the first member of the sequence. */
11512 {
11516 name);
11517 else
11522 }
11524 /* Figure out the index type for the array. */
11526 {
11528 tf_warning_or_error);
11531 {
11534 }
11535 }
11538 }
11540 /* Returns the smallest location that is not UNKNOWN_LOCATION. */
11542 static location_t
11544 {
11550 }
11552 /* Returns the smallest location != UNKNOWN_LOCATION among the
11553 three stored in LOCATIONS[ds_const], LOCATIONS[ds_volatile],
11554 and LOCATIONS[ds_restrict]. */
11556 static location_t
11558 {
11571 }
11573 /* Returns the smallest among the latter and locations[ds_type_spec]. */
11575 static location_t
11577 {
11580 }
11582 static location_t
11584 {
11587 }
11589 /* Check that it's OK to declare a function with the indicated TYPE
11590 and TYPE_QUALS. SFK indicates the kind of special function (if any)
11591 that this function is. OPTYPE is the type given in a conversion
11592 operator declaration, or the class type for a constructor/destructor.
11593 Returns the actual return type of the function; that may be different
11594 than TYPE if an error occurs, or for certain special functions. */
11596 static tree
11598 tree type,
11599 tree optype,
11602 {
11604 {
11615 else
11627 /* We can't use the proper return type here because we run into
11628 problems with ambiguous bases and covariant returns. */
11631 else
11641 "qualifiers are not allowed on declaration of "
11653 "qualifiers are not allowed on declaration of "
11656 {
11660 }
11661 else
11671 }
11674 }
11676 /* A variable or data member (whose unqualified name is IDENTIFIER)
11677 has been declared with the indicated TYPE. If the TYPE is not
11678 acceptable, issue an error message and return a type to use for
11679 error-recovery purposes. */
11681 tree
11683 {
11685 {
11689 {
11692 identifier);
11693 }
11694 else
11697 }
11700 }
11702 /* Handle declaring DECL as an inline variable. */
11704 static void
11706 {
11709 {
11713 }
11718 {
11721 }
11722 }
11725 /* Assign a typedef-given name to a class or enumeration type declared
11726 as anonymous at first. This was split out of grokdeclarator
11727 because it is also used in libcc1. */
11729 void
11731 {
11734 /* Replace the anonymous decl with the real decl. Be careful not to
11735 rename other typedefs (such as the self-reference) of type. */
11741 /* If this is a typedef within a template class, the nested
11742 type is a (non-primary) template. The name for the
11743 template needs updating as well. */
11747 /* Adjust linkage now that we aren't unnamed anymore. */
11750 /* FIXME remangle member functions; member functions of a
11751 type with external linkage have external linkage. */
11753 /* Check that our job is done, and that it would fail if we
11754 attempted to do it again. */
11756 }
11758 /* Check that decltype(auto) was well-formed: only plain decltype(auto)
11759 is allowed. TYPE might contain a decltype(auto). Returns true if
11760 there was a problem, false otherwise. */
11762 static bool
11764 {
11766 {
11768 {
11770 {
11774 }
11776 {
11779 }
11780 }
11781 }
11783 }
11785 /* Given declspecs and a declarator (abstract or otherwise), determine
11786 the name and type of the object declared and construct a DECL node
11787 for it.
11789 DECLSPECS points to the representation of declaration-specifier
11790 sequence that precedes declarator.
11792 DECL_CONTEXT says which syntactic context this declaration is in:
11793 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
11794 FUNCDEF for a function definition. Like NORMAL but a few different
11795 error messages in each case. Return value may be zero meaning
11796 this definition is too screwy to try to parse.
11797 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
11798 handle member functions (which have FIELD context).
11799 Return value may be zero meaning this definition is too screwy to
11800 try to parse.
11801 PARM for a parameter declaration (either within a function prototype
11802 or before a function body). Make a PARM_DECL, or return void_type_node.
11803 TPARM for a template parameter declaration.
11804 CATCHPARM for a parameter declaration before a catch clause.
11805 TYPENAME if for a typename (in a cast or sizeof).
11806 Don't make a DECL node; just return the ..._TYPE node.
11807 FIELD for a struct or union field; make a FIELD_DECL.
11808 BITFIELD for a field with specified width.
11810 INITIALIZED is as for start_decl.
11812 ATTRLIST is a pointer to the list of attributes, which may be NULL
11813 if there are none; *ATTRLIST may be modified if attributes from inside
11814 the declarator should be applied to the declaration.
11816 When this function is called, scoping variables (such as
11817 CURRENT_CLASS_TYPE) should reflect the scope in which the
11818 declaration occurs, not the scope in which the new declaration will
11819 be placed. For example, on:
11821 void S::f() { ... }
11823 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
11824 should not be `S'.
11826 Returns a DECL (if a declarator is present), a TYPE (if there is no
11827 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
11828 error occurs. */
11830 tree
11836 {
11849 /* True if this declarator is a function definition. */
11853 #if 0
11854 /* See the code below that used this. */
11856 #endif
11858 /* Keep track of what sort of function is being processed
11859 so that we can warn about default return values, or explicit
11860 return values which do not match prescribed defaults. */
11866 /* cv-qualifiers that apply to the declarator, for a declaration of
11867 a member function. */
11869 /* virt-specifiers that apply to the declarator, for a declaration of
11870 a member function. */
11872 /* ref-qualifier that applies to the declarator, for a declaration of
11873 a member function. */
11875 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
11882 /* The unqualified name of the declarator; either an
11883 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
11884 tree unqualified_id;
11885 /* The class type, if any, in which this entity is located,
11886 or NULL_TREE if none. Note that this value may be different from
11887 the current class type; for example if an attempt is made to declare
11888 "A::f" inside "B", this value will be "A". */
11890 /* The NAMESPACE_DECL for the namespace in which this entity is
11891 located. If an unqualified name is used to declare the entity,
11892 this value will be NULL_TREE, even if the entity is located at
11893 namespace scope. */
11895 cp_storage_class storage_class;
11918 // Was concept_p specified? Note that ds_concept
11919 // implies ds_constexpr!
11941 location_t id_loc;
11942 location_t init_loc;
11944 {
11947 }
11948 else
11951 /* Look inside a declarator for the name being declared
11952 and get it as a string, for an error message. */
11954 id_declarator;
11956 {
11961 {
11965 {
11969 }
11973 {
11979 {
11984 {
11985 /* [dcl.meaning]
11987 A declarator-id shall not be qualified except
11988 for ...
11990 None of the cases are permitted in block
11991 scope. */
11994 decl);
11998 else
12002 }
12004 {
12007 {
12011 }
12013 && current_class_type
12015 current_class_type))
12016 {
12021 }
12022 }
12025 }
12027 {
12029 {
12031 {
12035 }
12038 {
12042 }
12049 }
12053 {
12059 }
12060 /* Fall through. */
12067 {
12069 dname);
12071 }
12074 else
12075 {
12082 else
12084 }
12089 }
12091 }
12108 }
12111 }
12113 /* [dcl.fct.edf]
12115 The declarator in a function-definition shall have the form
12116 D1 ( parameter-declaration-clause) ... */
12118 {
12121 }
12126 {
12129 }
12132 {
12135 {
12138 }
12141 {
12143 {
12146 }
12148 {
12151 }
12152 }
12153 }
12155 /* Anything declared one level down from the top level
12156 must be one of the parameters of a function
12157 (because the body is at least two levels down). */
12159 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
12160 by not allowing C++ class definitions to specify their parameters
12161 with xdecls (must be spec.d in the parmlist).
12163 Since we now wait to push a class scope until we are sure that
12164 we are in a legitimate method context, we must set oldcname
12165 explicitly (since current_class_name is not yet alive).
12167 We also want to avoid calling this a PARM if it is in a namespace. */
12170 {
12176 }
12182 {
12186 }
12189 {
12193 }
12196 {
12200 }
12203 {
12207 }
12210 {
12214 }
12216 /* [dcl.spec]/2 "At most one of the constexpr, consteval, and constinit
12217 keywords shall appear in a decl-specifier-seq." */
12219 {
12223 "can use at most one of the %<constinit%> and %<constexpr%> "
12226 }
12228 /* If there were multiple types specified in the decl-specifier-seq,
12229 issue an error message. */
12231 {
12235 }
12240 /* Extract the basic type from the decl-specifier-seq. */
12243 {
12246 }
12248 /* Ignore erroneous attributes. */
12252 /* An object declared as __attribute__((unavailable)) suppresses
12253 any reports of being declared with unavailable or deprecated
12254 items. An object declared as __attribute__((deprecated))
12255 suppresses warnings of uses of other deprecated items. */
12264 {
12270 }
12271 /* No type at all: default to `int', and set DEFAULTED_INT
12272 because it was not a user-defined typedef. */
12274 {
12276 {
12277 /* These imply 'int'. */
12280 }
12281 /* If we just have "complex", it is equivalent to "complex double". */
12284 {
12287 "ISO C++ does not support plain %<complex%> meaning "
12289 }
12290 }
12291 /* Gather flags. */
12295 #if 0
12296 /* See the code below that used this. */
12299 #endif
12304 else
12308 {
12310 ctor_return_type,
12311 type_quals,
12314 }
12316 {
12321 /* We handle `main' specially here, because 'main () { }' is so
12322 common. With no options, it is allowed. With -Wreturn-type,
12323 it is a warning. It is only an error with -pedantic-errors. */
12324 is_main = (funcdef_flag
12337 name);
12341 else
12346 /* FIXME we should be able to propagate the error_mark_node as is
12347 for other contexts too. */
12349 else
12351 }
12356 {
12358 {
12363 }
12364 /* Don't pedwarn if the alternate "__intN__" form has been used instead
12365 of "__intN". */
12370 }
12372 /* Now process the modifiers that were specified
12373 and check for invalid combinations. */
12375 /* Long double is a special combination. */
12377 {
12381 }
12383 /* Check all other uses of type modifiers. */
12386 {
12387 location_t loc;
12390 {
12393 }
12395 {
12398 }
12400 {
12403 }
12405 {
12408 }
12410 {
12413 }
12418 {
12423 }
12425 {
12429 }
12439 {
12441 {
12447 }
12450 else
12452 }
12453 else
12456 /* Discard the type modifiers if they are invalid. */
12458 {
12464 }
12465 }
12467 /* Decide whether an integer type is signed or not.
12468 Optionally treat bitfields as signed by default. */
12470 /* [class.bit]
12472 It is implementation-defined whether a plain (neither
12473 explicitly signed or unsigned) char, short, int, or long
12474 bit-field is signed or unsigned.
12476 Naturally, we extend this to long long as well. Note that
12477 this does not include wchar_t. */
12479 && !signed_p
12480 /* A typedef for plain `int' without `signed' can be
12481 controlled just like plain `int', but a typedef for
12482 `signed int' cannot be so controlled. */
12483 && !(typedef_decl
12487 {
12500 else
12502 }
12515 {
12519 /* If a modifier is specified, the resulting complex is the complex
12520 form of TYPE. E.g, "complex short" is "complex short int". */
12529 else
12531 }
12533 /* If we're using the injected-class-name to form a compound type or a
12534 declaration, replace it with the underlying class so we don't get
12535 redundant typedefs in the debug output. But if we are returning the
12536 type unchanged, leave it alone so that it's available to
12537 maybe_get_template_decl_from_type_decl. */
12545 type = cp_build_qualified_type
12549 /* We might have ignored or rejected some of the qualifiers. */
12554 /* Placeholder in parm gets a better error below. */
12558 {
12559 auto_diagnostic_group g;
12563 "for deduction, template placeholder must be followed "
12567 }
12578 /* Treat class-scope deduction guides as static member functions
12579 so that they get a FUNCTION_TYPE instead of a METHOD_TYPE. */
12583 {
12585 {
12592 }
12594 {
12598 "declared both %<virtual%> and %<constexpr%> only in "
12600 }
12601 }
12604 /* Issue errors about use of storage classes for parameters. */
12606 {
12608 {
12612 }
12614 {
12618 name);
12620 }
12624 {
12629 }
12631 /* Function parameters cannot be concept. */
12633 {
12638 }
12639 /* Function parameters cannot be constexpr. If we saw one, moan
12640 and pretend it wasn't there. */
12642 {
12646 }
12648 {
12652 }
12654 {
12658 }
12659 }
12661 /* Give error if `virtual' is used outside of class declaration. */
12664 {
12668 }
12671 {
12688 "structured binding declaration can be %qs only in "
12690 declspecs->gnu_thread_keyword_p
12695 /* [dcl.struct.bind] "A cv that includes volatile is deprecated." */
12700 {
12710 "structured binding declaration can be %qs only in "
12727 }
12730 {
12732 {
12733 auto_diagnostic_group d;
12737 "type must be cv-qualified %<auto%> or reference to "
12739 }
12742 }
12745 "structured binding declaration cannot have constrained "
12753 {
12756 }
12757 }
12759 /* Static anonymous unions are dealt with here. */
12765 /* Warn about storage classes that are invalid for certain
12766 kinds of declarations (parameters, typenames, etc.). */
12768 && ((storage_class
12772 {
12773 location_t loc
12778 }
12783 {
12787 ;
12789 ;
12791 /* C++ allows static class elements. */
12793 /* C++ also allows inlines and signed and unsigned elements,
12794 but in those cases we don't come in here. */
12795 ;
12796 else
12797 {
12798 location_t loc
12805 else
12812 }
12813 }
12818 {
12822 }
12826 {
12832 /* When thread_local is applied to a variable of block scope the
12833 storage-class-specifier static is implied if it does not appear
12834 explicitly. */
12837 }
12840 {
12843 "storage class specifiers invalid in friend function "
12847 }
12851 else
12852 {
12855 {
12868 }
12869 }
12873 {
12878 }
12883 /* Determine the type of the entity declared by recurring on the
12884 declarator. */
12886 {
12888 tree attrs;
12895 {
12907 /* Assume that any attributes that get applied late to
12908 templates will DTRT when applied to the declaration
12909 as a whole. */
12913 attrs),
12914 attr_flags);
12916 }
12920 /* Check that contracts aren't misapplied. */
12926 /* We don't want to warn in parameter context because we don't
12927 yet know if the parse will succeed, and this might turn out
12928 to be a constructor call. */
12931 && !typedef_p
12933 /* If the type is class-like and the inner name used a
12934 global namespace qualifier, we need the parens.
12935 Unfortunately all we can tell is whether a qualified name
12936 was used or not. */
12937 && !(inner_declarator
12942 {
12945 name))
12946 {
12951 }
12952 }
12957 {
12968 /* [dcl.array]/1:
12970 The optional attribute-specifier-seq appertains to the
12971 array. */
12977 {
12978 tree arg_types;
12981 /* Declaring a function type. */
12983 /* Pick up type qualifiers which should be applied to `this'. */
12985 /* Pick up virt-specifiers. */
12987 /* And ref-qualifier, too */
12989 /* And tx-qualifier. */
12991 /* Pick up the exception specifications. */
12993 /* If the exception-specification is ill-formed, let's pretend
12994 there wasn't one. */
13002 /* Say it's a definition only for the CALL_EXPR
13003 closest to the identifier. */
13006 /* Handle a late-specified return type. */
13009 {
13011 {
13018 {
13020 "%<auto%> type specifier without "
13023 "deduced return type only available "
13025 }
13027 {
13031 }
13032 }
13034 {
13036 "return type has %qT as its type rather "
13039 }
13041 {
13044 "%qs function with trailing return type "
13045 "has %<decltype(auto)%> as its type "
13047 else
13051 }
13057 {
13059 {
13060 auto_diagnostic_group g;
13067 }
13069 {
13071 "for %qT must have trailing return "
13076 }
13082 else
13086 }
13087 }
13090 {
13094 /* Not using maybe_warn_cpp0x because this should
13095 always be an error. */
13097 "trailing return type only available "
13099 else
13101 "return type not declared with %<auto%> "
13104 }
13106 {
13109 }
13115 {
13118 }
13121 {
13122 /* It's wrong, for instance, to issue a -Wignored-qualifiers
13123 warning for
13124 static_assert(!is_same_v<void(*)(), const void(*)()>);
13125 because there the qualifier matters. */
13129 /* [dcl.fct] "A volatile-qualified return type is
13130 deprecated." */
13133 "%<volatile%>-qualified return type is "
13136 /* We now know that the TYPE_QUALS don't apply to the
13137 decl, but to its return type. */
13139 }
13141 /* Error about some types functions can't return. */
13144 {
13148 }
13150 {
13154 }
13156 {
13158 "%<constinit%> on function return type is not "
13161 }
13168 && funcdecl_p
13174 {
13175 /* We are within a class's scope. If our declarator name
13176 is the same as the class name, and we are defining
13177 a function, then it is a constructor/destructor, and
13178 therefore returns a void type. */
13180 /* ISO C++ 12.4/2. A destructor may not be declared
13181 const or volatile. A destructor may not be static.
13182 A destructor may not be declared with ref-qualifier.
13184 ISO C++ 12.1. A constructor may not be declared
13185 const or volatile. A constructor may not be
13186 virtual. A constructor may not be static.
13187 A constructor may not be declared with ref-qualifier. */
13196 {
13201 }
13204 {
13210 }
13214 current_class_type,
13215 flags))
13219 {
13220 /* It's a constructor. */
13224 {
13228 }
13232 }
13235 }
13237 {
13239 {
13240 /* Cannot be both friend and virtual. */
13245 }
13250 {
13252 "cannot define friend function %qs in a local "
13255 }
13256 /* [class.friend]/6: A function can be defined in a friend
13257 declaration if the function name is unqualified. */
13259 {
13262 "friend function definition %qs cannot have "
13264 else
13266 "friend function definition %qs cannot have "
13268 in_namespace);
13269 }
13270 }
13272 {
13274 {
13277 }
13278 }
13280 {
13283 }
13290 pushed_scope
13302 {
13307 }
13313 {
13315 /* transaction_safe applies to the type, but
13316 transaction_safe_dynamic applies to the function. */
13319 else
13321 }
13323 /* Actually apply the contract attributes to the declaration. */
13325 {
13328 {
13330 /* Intentionally reverse order of contracts so they're
13331 reversed back into their lexical order. */
13334 }
13335 else
13337 }
13340 /* [dcl.fct]/2:
13342 The optional attribute-specifier-seq appertains to
13343 the function type. */
13348 }
13354 /* Filter out pointers-to-references and references-to-references.
13355 We can get these if a TYPE_DECL is used. */
13358 {
13360 {
13363 }
13365 /* In C++0x, we allow reference to reference declarations
13366 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
13367 and template type arguments [14.3.1/4 temp.arg.type]. The
13368 check for direct reference to reference declarations, which
13369 are still forbidden, occurs below. Reasoning behind the change
13370 can be found in DR106, DR540, and the rvalue reference
13371 proposals. */
13373 {
13376 }
13377 }
13379 {
13384 }
13386 /* We now know that the TYPE_QUALS don't apply to the decl,
13387 but to the target of the pointer. */
13390 /* This code used to handle METHOD_TYPE, but I don't think it's
13391 possible to get it here anymore. */
13395 {
13399 memfn_quals,
13400 rqual);
13406 }
13414 type);
13416 /* When the pointed-to type involves components of variable size,
13417 care must be taken to ensure that the size evaluation code is
13418 emitted early enough to dominate all the possible later uses
13419 and late enough for the variables on which it depends to have
13420 been assigned.
13422 This is expected to happen automatically when the pointed-to
13423 type has a name/declaration of it's own, but special attention
13424 is required if the type is anonymous.
13426 We handle the NORMAL and FIELD contexts here by inserting a
13427 dummy statement that just evaluates the size at a safe point
13428 and ensures it is not deferred until e.g. within a deeper
13429 conditional context (c++/43555).
13431 We expect nothing to be needed here for PARM or TYPENAME.
13432 Evaluating the size at this point for TYPENAME would
13433 actually be incorrect, as we might be in the middle of an
13434 expression with side effects on the pointed-to type size
13435 "arguments" prior to the pointer declaration point and the
13436 size evaluation could end up prior to the side effects. */
13442 {
13446 }
13449 {
13450 /* In C++0x, the type we are creating a reference to might be
13451 a typedef which is itself a reference type. In that case,
13452 we follow the reference collapsing rules in
13453 [7.1.3/8 dcl.typedef] to create the final reference type:
13455 "If a typedef TD names a type that is a reference to a type
13456 T, an attempt to create the type 'lvalue reference to cv TD'
13457 creates the type 'lvalue reference to T,' while an attempt
13458 to create the type "rvalue reference to cv TD' creates the
13459 type TD."
13460 */
13464 {
13467 else
13469 }
13470 else
13471 type = cp_build_reference_type
13474 /* In C++0x, we need this check for direct reference to
13475 reference declarations, which are forbidden by
13476 [8.3.2/5 dcl.ref]. Reference to reference declarations
13477 are only allowed indirectly through typedefs and template
13478 type arguments. Example:
13480 void foo(int & &); // invalid ref-to-ref decl
13482 typedef int & int_ref;
13483 void foo(int_ref &); // valid ref-to-ref decl
13484 */
13488 }
13492 {
13496 /* We will already have complained. */
13498 else
13500 type);
13501 }
13502 else
13505 /* Process a list of type modifier keywords (such as
13506 const or volatile) that were given inside the `*' or `&'. */
13509 {
13510 type
13514 }
13516 /* Apply C++11 attributes to the pointer, and not to the
13517 type pointed to. This is unlike what is done for GNU
13518 attributes above. It is to comply with [dcl.ptr]/1:
13520 [the optional attribute-specifier-seq (7.6.1) appertains
13521 to the pointer and not to the object pointed to]. */
13534 }
13535 }
13540 /* Don't check this if it can be the artifical decltype(auto)
13541 we created when building a constraint in a compound-requirement:
13542 that the type-constraint is plain is going to be checked in
13543 cp_parser_compound_requirement. */
13548 /* A `constexpr' specifier used in an object declaration declares
13549 the object as `const'. */
13551 {
13552 /* DR1688 says that a `constexpr' specifier in combination with
13553 `volatile' is valid. */
13556 {
13559 }
13560 }
13565 {
13567 unqualified_id);
13569 }
13571 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
13572 qualified with a class-name, turn it into a METHOD_TYPE, unless
13573 we know that the function is static. We take advantage of this
13574 opportunity to do other processing that pertains to entities
13575 explicitly declared to be class members. Note that if DECLARATOR
13576 is non-NULL, we know it is a cdk_id declarator; otherwise, we
13577 would not have exited the loop above. */
13582 {
13588 {
13590 {
13592 "member functions are implicitly "
13595 }
13596 else
13599 }
13601 can skip the following checks. */
13604 qualifying type must certainly be complete. */
13605 funcdef_flag
13606 /* A friend declaration of "T::f" is OK, even if
13607 "T" is a template parameter. But, if this
13608 function is not a friend, the qualifying type
13609 must be a class. */
13611 /* For a declaration, the type need not be
13612 complete, if either it is dependent (since there
13613 is no meaningful definition of complete in that
13614 case) or the qualifying class is currently being
13615 defined. */
13618 /* Check that the qualifying type is complete. */
13622 {
13625 {
13633 }
13634 }
13636 {
13640 }
13641 }
13646 /* Now TYPE has the actual type. */
13649 {
13652 else
13654 }
13660 {
13661 /* [dcl.meaning]/1: The optional attribute-specifier-seq following
13662 a declarator-id appertains to the entity that is declared. */
13665 else
13666 /* We should have already diagnosed the issue (c++/78344). */
13668 }
13670 /* Handle parameter packs. */
13672 {
13674 /* Turn the type into a pack expansion.*/
13676 else
13678 }
13681 && !processing_template_decl
13683 {
13687 else
13691 }
13694 {
13695 /* [dcl.fct.spec] (C++11) The explicit specifier shall be used only
13696 in the declaration of a constructor or conversion function within
13697 a class definition. */
13704 else
13706 "only declarations of constructors and conversion operators "
13709 }
13712 {
13715 {
13717 name);
13719 }
13721 {
13724 name);
13726 }
13728 {
13730 name);
13732 }
13734 {
13736 name);
13738 }
13740 {
13742 name);
13744 }
13746 {
13748 name);
13750 }
13751 }
13753 /* If this is declaring a typedef name, return a TYPE_DECL. */
13755 {
13757 tree decl;
13760 {
13764 else
13768 }
13770 /* This declaration:
13772 typedef void f(int) const;
13774 declares a function type which is not a member of any
13775 particular class, but which is cv-qualified; for
13776 example "f S::*" declares a pointer to a const-qualified
13777 member function of S. We record the cv-qualification in the
13778 function type. */
13780 {
13783 /* We have now dealt with these qualifiers. */
13786 }
13789 {
13793 else
13797 }
13803 {
13806 }
13810 else
13814 {
13818 /* The TYPE_DECL is "abstract" because there will be
13819 clones of this constructor/destructor, and there will
13820 be copies of this TYPE_DECL generated in those
13821 clones. The decloning optimization (for space) may
13822 revert this subsequently if it determines that
13823 the clones should share a common implementation. */
13827 }
13832 unqualified_id);
13834 /* If the user declares "typedef struct {...} foo" then the
13835 struct will have an anonymous name. Fill that name in now.
13836 Nothing can refer to it, so nothing needs know about the name
13837 change. */
13839 && unqualified_id
13858 /* Acknowledge that this was written:
13859 `using analias = atype;'. */
13863 }
13865 /* Detect the case of an array type of unspecified size
13866 which came, as such, direct from a typedef name.
13867 We must copy the type, so that the array's domain can be
13868 individually set by the object's initializer. */
13875 /* Detect where we're using a typedef of function type to declare a
13876 function. PARMS will not be set, so we must create it now. */
13879 {
13881 tree args;
13886 {
13892 }
13897 {
13898 /* The qualifiers on the function type become the qualifiers on
13899 the non-static member function. */
13904 }
13905 }
13907 /* If this is a type name (such as, in a cast or sizeof),
13908 compute the type and return it now. */
13911 {
13912 /* Note that here we don't care about type_quals. */
13914 /* Special case: "friend class foo" looks like a TYPENAME context. */
13916 {
13918 {
13921 }
13924 {
13925 /* Don't allow friend declaration without a class-key. */
13932 else
13935 type);
13936 }
13938 /* Only try to do this stuff if we didn't already give up. */
13940 {
13941 /* A friendly class? */
13945 else
13947 type);
13950 }
13951 }
13953 {
13960 /* Core issue #547: need to allow this in template type args.
13961 Allow it in general in C++11 for alias-declarations. */
13965 else
13967 }
13973 }
13977 && ! bitfield
13979 {
13982 }
13985 {
13986 /* Only functions may be declared using an operator-function-id. */
13988 {
13991 }
13996 type);
13997 }
13999 /* We don't check parameter types here because we can emit a better
14000 error message later. */
14002 {
14006 }
14008 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
14009 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
14012 {
14018 {
14020 {
14025 {
14026 auto_diagnostic_group g;
14030 "missing template argument list after %qE; template "
14036 }
14037 else
14040 }
14041 else
14044 }
14046 /* A parameter declared as an array of T is really a pointer to T.
14047 One declared as a function is really a pointer to a function.
14048 One declared as a member is really a pointer to member. */
14051 {
14052 /* Transfer const-ness of array into that of type pointed to. */
14056 }
14059 }
14062 && !(unqualified_id
14065 {
14071 }
14073 {
14077 {
14085 }
14087 {
14090 {
14096 else
14100 }
14102 /* The C99 flexible array extension. */
14105 {
14109 {
14112 }
14113 else
14114 {
14115 /* Array is a flexible member. */
14119 else
14123 /* Flexible array member has a null domain. */
14125 }
14126 }
14129 {
14130 /* Happens when declaring arrays of sizes which
14131 are error_mark_node, for example. */
14133 }
14135 {
14136 /* Something like struct S { int N::j; }; */
14139 }
14141 {
14143 tree function_context;
14146 {
14147 /* This should never happen in pure C++ (the check
14148 could be an assert). It could happen in
14149 Objective-C++ if someone writes invalid code that
14150 uses a function declaration for an instance
14151 variable or property (instance variables and
14152 properties are parsed as FIELD_DECLs, but they are
14153 part of an Objective-C class, not a C++ class).
14154 That code is invalid and is caught by this
14155 check. */
14157 {
14159 unqualified_id);
14161 }
14163 /* ``A union may [ ... ] not [ have ] virtual functions.''
14164 ARM 9.5 */
14166 {
14169 unqualified_id);
14171 }
14176 {
14178 "%qD cannot be declared %<virtual%>, since it "
14181 }
14182 }
14184 /* Check that the name used for a destructor makes sense. */
14186 {
14190 {
14195 }
14198 {
14202 }
14204 {
14208 }
14210 {
14212 "%<constexpr%> destructors only available"
14215 }
14217 {
14221 }
14222 }
14224 {
14229 }
14232 {
14236 }
14238 {
14242 }
14246 {
14250 }
14253 {
14256 {
14262 }
14263 }
14265 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
14266 function_context
14275 parms,
14276 unqualified_id,
14277 declspecs,
14278 reqs,
14290 #if 0
14291 /* This clobbers the attrs stored in `decl' from `attrlist'. */
14292 /* The decl and setting of decl_attr is also turned off. */
14294 #endif
14296 /* [class.conv.ctor]
14298 A constructor declared without the function-specifier
14299 explicit that can be called with a single parameter
14300 specifies a conversion from the type of its first
14301 parameter to the type of its class. Such a constructor
14302 is called a converting constructor. */
14308 }
14310 && ((current_class_type
14316 {
14319 {
14321 {
14325 }
14326 else
14331 }
14332 }
14334 staticp
14335 ? TCTX_STATIC_STORAGE
14337 {
14340 }
14341 else
14342 {
14344 {
14347 "%qE is neither function nor member function; "
14349 else
14353 }
14355 }
14358 {
14359 /* Packages tend to use GNU attributes on friends, so we only
14360 warn for standard attributes. */
14362 && !funcdef_flag
14365 {
14370 }
14371 /* Friends are treated specially. */
14375 {
14379 /* Kludge: We need funcdef_flag to be true in do_friend for
14380 in-class defaulted functions, but that breaks grokfndecl.
14381 So set it here. */
14390 }
14391 else
14393 }
14395 /* Structure field. It may not be a function, except for C++. */
14398 {
14400 {
14401 /* C++ allows static class members. All other work
14402 for this is done by grokfield. */
14411 {
14413 "%<constexpr%> static data member %qD must "
14416 }
14427 /* Even if there is an in-class initialization, DECL
14428 is considered undefined until an out-of-class
14429 definition is provided, unless this is an inline
14430 variable. */
14434 {
14440 }
14442 /* Set the constraints on the declaration. */
14446 {
14449 }
14450 }
14451 else
14452 {
14454 {
14460 }
14462 {
14467 }
14469 {
14474 }
14476 {
14481 }
14488 {
14491 }
14494 {
14495 /* An attempt is being made to initialize a non-static
14496 member. This is new in C++11. */
14499 /* If this has been parsed with static storage class, but
14500 errors forced staticp to be cleared, ensure NSDMI is
14501 not present. */
14504 }
14505 }
14512 }
14513 }
14515 {
14516 tree original_name;
14524 else
14526 // FIXME:gcc_assert (original_name == dname);
14534 name);
14536 {
14540 name);
14541 else
14543 "storage class %<thread_local%> invalid for "
14545 }
14550 /* Function declaration not at top level.
14551 Storage classes other than `extern' are not allowed
14552 and `extern' makes no difference. */
14557 {
14560 "%<static%> specifier invalid for function %qs "
14562 else
14564 "%<inline%> specifier invalid for function %qs "
14566 }
14569 {
14571 {
14574 }
14577 {
14582 }
14583 }
14587 {
14591 }
14593 /* Record whether the function is public. */
14598 declspecs,
14601 publicp,
14605 sfk,
14606 funcdef_flag,
14607 late_return_type_p,
14609 id_loc);
14616 {
14619 /* Don't allow a static member function in a class, and forbid
14620 declaring main to be static. */
14622 {
14626 }
14628 {
14629 /* 7.1.1: There can be no static function declarations within a
14630 block. */
14634 }
14637 {
14640 }
14641 }
14644 }
14645 else
14646 {
14647 /* It's a variable. */
14649 /* An uninitialized decl with `extern' is a reference. */
14651 declspecs,
14652 initialized,
14653 type_quals,
14654 inlinep,
14655 concept_p,
14656 template_count,
14658 id_loc);
14668 {
14671 {
14673 "%<static%> may not be used when defining "
14677 }
14679 {
14682 }
14684 {
14686 "cannot explicitly declare member %q#D to have "
14689 }
14690 }
14692 {
14694 "declaration of %<constexpr%> variable %qD "
14697 }
14699 {
14703 }
14708 {
14713 }
14714 }
14719 {
14723 }
14726 {
14728 {
14729 /* It's common practice (and completely valid) to have a const
14730 be initialized and declared extern. */
14734 }
14735 else
14736 {
14740 }
14741 }
14743 /* Record `register' declaration for warnings on &
14744 and in case doing stupid register allocation. */
14747 {
14749 /* Warn about register storage specifiers on PARM_DECLs. */
14751 {
14754 "ISO C++17 does not allow %<register%> storage "
14756 else
14759 }
14760 }
14767 {
14768 /* Set constexpr flag on vars (functions got it in grokfndecl). */
14771 /* And the constinit flag (which only applies to variables). */
14774 }
14776 {
14777 /* If we saw a return type, record its location. */
14782 {
14788 }
14791 }
14793 /* Record constancy and volatility on the DECL itself . There's
14794 no need to do this when processing a template; we'll do this
14795 for the instantiated declaration based on the type of DECL. */
14800 }
14801 }
14802 \f
14803 /* Subroutine of start_function. Ensure that each of the parameter
14804 types (as listed in PARMS) is complete, as is required for a
14805 function definition. */
14807 static void
14809 {
14811 {
14816 {
14823 }
14824 else
14825 /* grokparms or complete_type_or_else will have already issued
14826 an error. */
14828 }
14829 }
14831 /* Returns nonzero if T is a local variable. */
14833 int
14835 {
14844 }
14846 /* Like local_variable_p, but suitable for use as a tree-walking
14847 function. */
14849 static tree
14852 {
14854 {
14855 /* DR 2082 permits local variables in unevaluated contexts
14856 within a default argument. */
14859 }
14868 }
14870 /* Check that ARG, which is a default-argument expression for a
14871 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
14872 something goes wrong. DECL may also be a _TYPE node, rather than a
14873 DECL, if there is no DECL available. */
14875 tree
14877 {
14878 tree var;
14879 tree decl_type;
14882 /* We get a DEFERRED_PARSE when looking at an in-class declaration
14883 with a default argument. Ignore the argument for now; we'll
14884 deal with it after the class is complete. */
14888 {
14891 }
14892 else
14899 /* Something already went wrong. There's no need to check
14900 further. */
14903 /* [dcl.fct.default]
14905 A default argument expression is implicitly converted to the
14906 parameter type. */
14908 /* Avoid digest_init clobbering the initializer. */
14911 LOOKUP_IMPLICIT);
14914 /* Avoid redundant -Wzero-as-null-pointer-constant warnings at
14915 the call sites. */
14918 /* Don't lose side-effects as in PR90473. */
14922 /* [dcl.fct.default]
14924 Local variables shall not be used in default argument
14925 expressions.
14927 The keyword `this' shall not be used in a default argument of a
14928 member function. */
14931 {
14933 {
14937 else
14939 }
14941 }
14943 /* All is well. */
14945 }
14947 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
14949 static tree
14951 {
14956 {
14959 else
14960 {
14963 }
14964 }
14966 /* Do warn about using typedefs to a deprecated class. */
14978 return type_is_deprecated
14982 }
14984 /* Returns an unavailable type used within TYPE, or NULL_TREE if none. */
14986 static tree
14988 {
14993 {
14996 else
14997 {
15000 }
15001 }
15003 /* Do warn about using typedefs to a deprecated class. */
15015 return type_is_unavailable
15019 }
15021 /* Decode the list of parameter types for a function type.
15022 Given the list of things declared inside the parens,
15023 return a list of types.
15025 If this parameter does not end with an ellipsis, we append
15026 void_list_node.
15028 *PARMS is set to the chain of PARM_DECLs created. */
15030 tree
15032 {
15035 tree parm;
15039 {
15048 {
15051 }
15055 {
15057 && !init
15060 /* DR 577: A parameter list consisting of a single
15061 unnamed parameter of non-dependent type 'void'. */
15065 "invalid use of cv-qualified type %qT in "
15067 else
15069 "invalid use of type %<void%> in parameter "
15071 /* It's not a good idea to actually create parameters of
15072 type `void'; other parts of the compiler assume that a
15073 void type terminates the parameter list. */
15076 }
15079 {
15081 {
15085 }
15088 {
15092 }
15094 /* [dcl.fct] "A parameter with volatile-qualified type is
15095 deprecated." */
15098 "%<volatile%>-qualified parameter is "
15101 /* Top-level qualifiers on the parameters are
15102 ignored for function types. */
15105 {
15109 }
15111 {
15112 /* Before C++17 DR 393:
15113 [dcl.fct]/6, parameter types cannot contain pointers
15114 (references) to arrays of unknown bound. */
15119 {
15127 }
15130 ptr
15136 }
15140 }
15145 }
15155 /* We had parm errors, recover by giving the function (...) type. */
15159 }
15161 \f
15162 /* D is a constructor or overloaded `operator='.
15164 Let T be the class in which D is declared. Then, this function
15165 returns:
15167 -1 if D's is an ill-formed constructor or copy assignment operator
15168 whose first parameter is of type `T'.
15169 0 if D is not a copy constructor or copy assignment
15170 operator.
15171 1 if D is a copy constructor or copy assignment operator whose
15172 first parameter is a reference to non-const qualified T.
15173 2 if D is a copy constructor or copy assignment operator whose
15174 first parameter is a reference to const qualified T.
15176 This function can be used as a predicate. Positive values indicate
15177 a copy constructor and nonzero values indicate a copy assignment
15178 operator. */
15180 int
15182 {
15183 tree args;
15184 tree arg_type;
15192 /* Instantiations of template member functions are never copy
15193 functions. Note that member functions of templated classes are
15194 represented as template functions internally, and we must
15195 accept those as copy functions. */
15211 {
15212 /* Pass by value copy assignment operator. */
15214 }
15218 {
15221 }
15222 else
15228 /* There are more non-optional args. */
15232 }
15234 /* D is a constructor or overloaded `operator='.
15236 Let T be the class in which D is declared. Then, this function
15237 returns true when D is a move constructor or move assignment
15238 operator, false otherwise. */
15240 bool
15242 {
15244 /* There are no move constructors if we are in C++98 mode. */
15250 /* Instantiations of template member functions are never move
15251 functions. Note that member functions of templated classes are
15252 represented as template functions internally, and we must
15253 accept those as move functions. */
15257 }
15259 /* D is a constructor or overloaded `operator='.
15261 Then, this function returns true when D has the same signature as a move
15262 constructor or move assignment operator (because either it is such a
15263 ctor/op= or it is a template specialization with the same signature),
15264 false otherwise. */
15266 bool
15268 {
15269 tree args;
15270 tree arg_type;
15294 /* There are more non-optional args. */
15298 }
15300 /* Remember any special properties of member function DECL. */
15302 void
15304 {
15305 tree class_type;
15313 {
15320 {
15321 /* [class.copy]
15323 A non-template constructor for class X is a copy
15324 constructor if its first parameter is of type X&, const
15325 X&, volatile X& or const volatile X&, and either there
15326 are no other parameters or else all other parameters have
15327 default arguments. */
15331 }
15342 }
15344 {
15345 /* [class.copy]
15347 A non-template assignment operator for class X is a copy
15348 assignment operator if its parameter is of type X, X&, const
15349 X&, volatile X& or const volatile X&. */
15354 {
15358 }
15359 }
15363 /* Destructors are handled in check_methods. */
15364 }
15366 /* Check a constructor DECL has the correct form. Complains
15367 if the class has a constructor of the form X(X). */
15369 bool
15371 {
15375 {
15376 /* [class.copy]
15378 A declaration of a constructor for a class X is ill-formed if
15379 its first parameter is of type (optionally cv-qualified) X
15380 and either there are no other parameters or else all other
15381 parameters have default arguments.
15383 We *don't* complain about member template instantiations that
15384 have this form, though; they can occur as we try to decide
15385 what constructor to use during overload resolution. Since
15386 overload resolution will never prefer such a constructor to
15387 the non-template copy constructor (which is either explicitly
15388 or implicitly defined), there's no need to worry about their
15389 existence. Theoretically, they should never even be
15390 instantiated, but that's hard to forestall. */
15395 }
15398 }
15400 /* DECL is a declaration for an overloaded or conversion operator. If
15401 COMPLAIN is true, errors are issued for invalid declarations. */
15403 bool
15405 {
15415 tree_code operator_code;
15418 {
15419 /* Conversion operators are TYPE_EXPR for the purposes of this
15420 function. */
15423 }
15424 else
15425 {
15432 }
15435 {
15436 /* operator new and operator delete are quite special. */
15439 {
15458 }
15460 /* [basic.std.dynamic.allocation]/1:
15462 A program is ill-formed if an allocation function is declared
15463 in a namespace scope other than global scope or declared
15464 static in global scope.
15466 The same also holds true for deallocation functions. */
15468 {
15470 {
15472 decl);
15474 }
15477 {
15480 }
15481 }
15484 {
15487 }
15488 else
15489 {
15492 }
15495 }
15497 /* An operator function must either be a non-static member function
15498 or have at least one parameter of a class, a reference to a class,
15499 an enumeration, or a reference to an enumeration. 13.4.0.6 */
15501 {
15505 {
15508 }
15511 {
15513 {
15516 }
15518 /* For lambdas we diagnose static lambda specifier elsewhere. */
15520 /* For instantiations, we have diagnosed this already. */
15524 decl);
15526 /* static operator[] should have exactly one argument
15527 for C++20 and earlier, so that it isn't multidimensional. */
15529 }
15531 {
15535 }
15536 else
15538 {
15540 {
15545 }
15551 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
15552 because these checks are performed even on template
15553 functions. */
15557 }
15558 }
15561 /* There are no further restrictions on the arguments to an overloaded
15562 "operator ()". */
15565 /* C++23 allows an arbitrary number of parameters and default arguments for
15566 operator[], and none of the other checks below apply. */
15571 {
15572 /* 13.4.0.3 */
15575 }
15577 /* Count the number of arguments and check for ellipsis. */
15580 {
15582 {
15584 decl);
15586 }
15588 }
15590 /* Verify correct number of arguments. */
15592 {
15595 {
15596 /* We have a unary instance of an ambi-ary op. Remap to the
15597 unary one. */
15603 }
15605 {
15606 /* This was an ambiguous operator but is invalid. */
15608 methodp
15612 }
15615 && ! processing_template_decl
15616 /* x++ and x--'s second argument must be an int. */
15618 integer_type_node))
15619 {
15621 methodp
15624 decl);
15626 }
15631 {
15633 methodp
15637 }
15642 {
15644 methodp
15648 }
15653 }
15655 /* There can be no default arguments. */
15659 {
15663 }
15665 /* At this point the declaration is well-formed. It may not be
15666 sensible though. */
15668 /* Check member function warnings only on the in-class declaration.
15669 There's no point warning on an out-of-class definition. */
15673 /* Warn about conversion operators that will never be used. */
15677 {
15688 {
15691 ref
15696 class_type);
15697 /* Don't force t to be complete here. */
15702 ref
15708 }
15709 }
15714 /* Effective C++ rules below. */
15716 /* More Effective C++ rule 7. */
15723 /* More Effective C++ rule 6. */
15728 {
15737 {
15742 }
15743 else
15744 {
15748 }
15749 }
15751 /* Effective C++ rule 23. */
15762 }
15763 \f
15764 /* Return a string giving the keyword associate with CODE. */
15768 {
15770 {
15783 }
15784 }
15786 /* Name lookup in an elaborated-type-specifier (after the keyword
15787 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
15788 elaborated-type-specifier is invalid, issue a diagnostic and return
15789 error_mark_node; otherwise, return the *_TYPE to which it referred.
15790 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
15792 tree
15794 tree decl,
15796 {
15797 tree type;
15799 /* In the case of:
15801 struct S { struct S *p; };
15803 name lookup will find the TYPE_DECL for the implicit "S::S"
15804 typedef. Adjust for that here. */
15810 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
15811 is false for this case as well. */
15813 {
15817 }
15818 /* Accept template template parameters. */
15822 ;
15823 /* [dcl.type.elab]
15825 If the identifier resolves to a typedef-name or the
15826 simple-template-id resolves to an alias template
15827 specialization, the elaborated-type-specifier is ill-formed.
15829 In other words, the only legitimate declaration to use in the
15830 elaborated type specifier is the implicit typedef created when
15831 the type is declared. */
15835 {
15839 else
15844 }
15849 {
15853 }
15856 {
15860 }
15864 {
15865 /* If a class template appears as elaborated type specifier
15866 without a template header such as:
15868 template <class T> class C {};
15869 void f(class C); // No template header here
15871 then the required template argument is missing. */
15876 }
15879 }
15881 /* Lookup NAME of an elaborated type specifier according to SCOPE and
15882 issue diagnostics if necessary. Return *_TYPE node upon success,
15883 NULL_TREE when the NAME is not found, and ERROR_MARK_NODE for type
15884 error. */
15886 static tree
15889 {
15890 tree decl;
15892 {
15893 /* First try ordinary name lookup, ignoring hidden class name
15894 injected via friend declaration. */
15897 /* If that fails, the name will be placed in the smallest
15898 non-class, non-function-prototype scope according to 3.3.1/5.
15899 We may already have a hidden name declared as friend in this
15900 scope. So lookup again but not ignoring hidden names.
15901 If we find one, that name will be made visible rather than
15902 creating a new tag. */
15905 }
15906 else
15910 /* We found nothing. */
15914 {
15918 }
15921 && !template_header_p
15923 {
15928 }
15931 /* If scope is TAG_how::CURRENT_ONLY we're defining a class,
15932 so ignore a template template parameter. */
15937 /* Found not-a-type. */
15940 /* Look for invalid nested type:
15941 class C {
15942 class C {};
15943 }; */
15945 {
15949 }
15951 /* Two cases we need to consider when deciding if a class
15952 template is allowed as an elaborated type specifier:
15953 1. It is a self reference to its own class.
15954 2. It comes with a template header.
15956 For example:
15958 template <class T> class C {
15959 class C *c1; // DECL_SELF_REFERENCE_P is true
15960 class D;
15961 };
15962 template <class U> class C; // template_header_p is true
15963 template <class T> class C<T>::D {
15964 class C *c2; // DECL_SELF_REFERENCE_P is true
15965 }; */
15968 template_header_p
15973 {
15982 }
15985 }
15987 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
15988 Define the tag as a forward-reference if it is not defined.
15990 If a declaration is given, process it here, and report an error if
15991 multiple declarations are not identical.
15993 SCOPE is TS_CURRENT when this is also a definition. Only look in
15994 the current frame for the name (since C++ allows new names in any
15995 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
15996 declaration. Only look beginning from the current scope outward up
15997 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
15999 TEMPLATE_HEADER_P is true when this declaration is preceded by
16000 a set of template parameters. */
16002 tree
16005 {
16014 {
16027 }
16029 /* In case of anonymous name, xref_tag is only called to
16030 make type node and push name. Name lookup is not required. */
16041 {
16045 /* Since HOW is not TAG_how::CURRENT_ONLY, we are not looking at
16046 a definition of this tag. Since, in addition, we are
16047 currently processing a (member) template declaration of a
16048 template class, we must be very careful; consider:
16050 template <class X> struct S1
16052 template <class U> struct S2
16053 {
16054 template <class V> friend struct S1;
16055 };
16057 Here, the S2::S1 declaration should not be confused with the
16058 outer declaration. In particular, the inner version should
16059 have a template parameter of level 2, not level 1.
16061 On the other hand, when presented with:
16063 template <class T> struct S1
16064 {
16065 template <class U> struct S2 {};
16066 template <class U> friend struct S2;
16067 };
16069 the friend must find S1::S2 eventually. We accomplish this
16070 by making sure that the new type we create to represent this
16071 declaration has the right TYPE_CONTEXT. */
16074 }
16077 {
16078 /* If no such tag is yet defined, create a forward-reference node
16079 and record it as the "definition".
16080 When a real declaration of this type is found,
16081 the forward-reference will be altered into a real type. */
16083 {
16086 }
16091 /* Mark it as a lambda type right now. Our caller will
16092 correct the value. */
16095 }
16096 else
16097 {
16099 {
16100 /* Check that we aren't trying to overload a class with different
16101 constraints. */
16105 }
16109 {
16113 }
16117 {
16120 {
16124 }
16133 {
16134 /* Push it into this TU's symbol slot. */
16137 /* We're in the template parm binding level.
16138 Pushtag has logic to slide under that, but we're
16139 not pushing a *new* type. */
16145 }
16148 }
16149 }
16152 }
16154 /* Create the binfo hierarchy for REF with (possibly NULL) base list
16155 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
16156 access_* node, and the TREE_VALUE is the type of the base-class.
16157 Non-NULL TREE_TYPE indicates virtual inheritance. */
16159 void
16161 {
16168 tree default_access;
16174 /* The base of a derived class is private by default, all others are
16175 public. */
16180 /* First, make sure that any templates in base-classes are
16181 instantiated. This ensures that if we call ourselves recursively
16182 we do not get confused about which classes are marked and which
16183 are not. */
16186 {
16189 /* The dependent_type_p call below should really be dependent_scope_p
16190 so that we give a hard error about using an incomplete type as a
16191 base, but we allow it with a pedwarn for backward
16192 compatibility. */
16198 /* An incomplete type. Remove it from the list. */
16200 else
16201 {
16202 max_bases++;
16204 max_dvbases++;
16208 }
16209 }
16214 /* The binfo slot should be empty, unless this is an (ill-formed)
16215 redefinition. */
16226 /* Apply base-class info set up to the variants of this type. */
16230 {
16232 /* A C++98 POD cannot have base classes. */
16236 {
16239 }
16240 }
16247 {
16248 /* An aggregate can't have virtual base classes. */
16256 }
16259 {
16267 /* Before C++17, an aggregate cannot have base classes. In C++17, an
16268 aggregate can't have virtual, private, or protected base classes. */
16279 {
16281 basetype);
16283 }
16287 {
16289 /* The original basetype could have been a typedef'd type. */
16292 /* Inherit flags from the base. */
16303 }
16305 /* We must do this test after we've seen through a typedef
16306 type. */
16308 {
16311 else
16314 }
16317 /* Regenerate the pack expansion for the bases. */
16331 dropped_base:
16332 /* Update max_vbases to reflect the reality that we are dropping
16333 this base: if it reaches zero we want to undo the vec_alloc
16334 above to avoid inconsistencies during error-recovery: eg, in
16335 build_special_member_call, CLASSTYPE_VBASECLASSES non null
16336 and vtt null (c++/27952). */
16338 max_vbases--;
16340 max_vbases
16342 }
16349 /* If we didn't get max_vbases vbases, we must have shared at
16350 least one of them, and are therefore diamond shaped. */
16353 /* Unmark all the types. */
16358 /* Now see if we have a repeated base type. */
16360 {
16363 {
16365 {
16368 }
16370 }
16375 else
16377 }
16378 }
16380 \f
16381 /* Copies the enum-related properties from type SRC to type DST.
16382 Used with the underlying type of an enum and the enum itself. */
16383 static void
16385 {
16386 tree t;
16388 {
16398 else
16402 }
16403 }
16405 /* Begin compiling the definition of an enumeration type.
16406 NAME is its name,
16408 if ENUMTYPE is not NULL_TREE then the type has alredy been found.
16410 UNDERLYING_TYPE is the type that will be used as the storage for
16411 the enumeration type. This should be NULL_TREE if no storage type
16412 was specified.
16414 ATTRIBUTES are any attributes specified after the enum-key.
16416 SCOPED_ENUM_P is true if this is a scoped enumeration type.
16418 if IS_NEW is not NULL, gets TRUE iff a new type is created.
16420 Returns the type object, as yet incomplete.
16421 Also records info about it so that build_enumerator
16422 may be used to declare the individual values as they are read. */
16424 tree
16427 {
16433 /* [C++0x dcl.enum]p5:
16435 If not explicitly specified, the underlying type of a scoped
16436 enumeration type is int. */
16443 /* If this is the real definition for a previous forward reference,
16444 fill in the contents in the same object that used to be the
16445 forward reference. */
16451 /* In case of a template_decl, the only check that should be deferred
16452 to instantiation time is the comparison of underlying types. */
16454 {
16456 {
16462 }
16464 {
16470 }
16474 {
16480 }
16483 {
16485 {
16491 }
16493 }
16494 }
16498 {
16499 /* In case of error, make a dummy enum to allow parsing to
16500 continue. */
16502 {
16505 }
16507 /* enumtype may be an ENUMERAL_TYPE if this is a redefinition
16508 of an opaque enum, or an opaque enum of an already defined
16509 enumeration (C++11).
16510 In any other case, it'll be NULL_TREE. */
16512 {
16515 }
16518 /* Do not push the decl more than once. */
16521 {
16525 /* std::byte aliases anything. */
16530 }
16531 else
16537 /* The enum is considered opaque until the opening '{' of the
16538 enumerator list. */
16541 }
16548 {
16550 /* We already checked that it matches, don't change it to a different
16553 {
16556 }
16559 else
16560 {
16564 }
16565 }
16567 /* If into a template class, the returned enum is always the first
16568 declaration (opaque or not) seen. This way all the references to
16569 this type will be to the same declaration. The following ones are used
16570 only to check for definition errors. */
16573 else
16575 }
16577 /* After processing and defining all the values of an enumeration type,
16578 install their decls in the enumeration type.
16579 ENUMTYPE is the type object. */
16581 void
16583 {
16584 tree values;
16585 tree underlying_type;
16586 tree decl;
16587 tree value;
16589 tree t;
16591 bool fixed_underlying_type_p
16594 /* We built up the VALUES in reverse order. */
16597 /* For an enum defined in a template, just set the type of the values;
16598 all further processing is postponed until the template is
16599 instantiated. We need to set the type so that tsubst of a CONST_DECL
16600 works. */
16602 {
16604 values;
16608 }
16610 /* Determine the minimum and maximum values of the enumerators. */
16612 {
16616 values;
16618 {
16621 /* [dcl.enum]: Following the closing brace of an enum-specifier,
16622 each enumerator has the type of its enumeration. Prior to the
16623 closing brace, the type of each enumerator is the type of its
16624 initializing value. */
16627 /* Update the minimum and maximum values, if appropriate. */
16631 /* Figure out what the minimum and maximum values of the
16632 enumerators are. */
16639 }
16640 }
16641 else
16642 /* [dcl.enum]
16644 If the enumerator-list is empty, the underlying type is as if
16645 the enumeration had a single enumerator with value 0. */
16649 {
16650 /* Compute the number of bits require to represent all values of the
16651 enumeration. We must do this before the type of MINNODE and
16652 MAXNODE are transformed, since tree_int_cst_min_precision relies
16653 on the TREE_TYPE of the value it is passed. */
16661 /* Determine the underlying type of the enumeration.
16663 [dcl.enum]
16665 The underlying type of an enumeration is an integral type that
16666 can represent all the enumerator values defined in the
16667 enumeration. It is implementation-defined which integral type is
16668 used as the underlying type for an enumeration except that the
16669 underlying type shall not be larger than int unless the value of
16670 an enumerator cannot fit in an int or unsigned int.
16672 We use "int" or an "unsigned int" as the underlying type, even if
16673 a smaller integral type would work, unless the user has
16674 explicitly requested that we use the smallest possible type. The
16675 user can request that for all enumerations with a command line
16676 flag, or for just one enumeration with an attribute. */
16678 use_short_enum = flag_short_enums
16681 /* If the precision of the type was specified with an attribute and it
16682 was too small, give an error. Otherwise, use it. */
16684 {
16687 else
16688 {
16691 }
16692 }
16696 itk++)
16697 {
16703 }
16705 {
16706 /* DR 377
16708 IF no integral type can represent all the enumerator values, the
16709 enumeration is ill-formed. */
16714 }
16716 /* [dcl.enum]
16718 The value of sizeof() applied to an enumeration type, an object
16719 of an enumeration type, or an enumerator, is the value of sizeof()
16720 applied to the underlying type. */
16723 /* Compute the minimum and maximum values for the type.
16725 [dcl.enum]
16727 For an enumeration where emin is the smallest enumerator and emax
16728 is the largest, the values of the enumeration are the values of the
16729 underlying type in the range bmin to bmax, where bmin and bmax are,
16730 respectively, the smallest and largest values of the smallest bit-
16731 field that can store emin and emax. */
16733 /* The middle-end currently assumes that types with TYPE_PRECISION
16734 narrower than their underlying type are suitably zero or sign
16735 extended to fill their mode. Similarly, it assumes that the front
16736 end assures that a value of a particular type must be within
16737 TYPE_MIN_VALUE and TYPE_MAX_VALUE.
16739 We used to set these fields based on bmin and bmax, but that led
16740 to invalid assumptions like optimizing away bounds checking. So
16741 now we just set the TYPE_PRECISION, TYPE_MIN_VALUE, and
16742 TYPE_MAX_VALUE to the values for the mode above and only restrict
16743 the ENUM_UNDERLYING_TYPE for the benefit of diagnostics. */
16747 set_min_and_max_values_for_integral_type
16750 /* If -fstrict-enums, still constrain TYPE_MIN/MAX_VALUE. */
16753 }
16754 else
16757 /* If the enum is exported, mark the consts too. */
16762 /* Convert each of the enumerators to the type of the underlying
16763 type of the enumeration. */
16765 {
16769 /* If the enumeration type has a fixed underlying type, we
16770 already checked all of the enumerator values. */
16772 else
16775 tf_warning_or_error);
16776 /* Do not clobber shared ints. */
16778 {
16782 }
16786 }
16788 /* Fix up all variant types of this enum type. */
16795 {
16797 /* TYPE_FIELDS needs fixup. */
16799 }
16801 /* Finish debugging output for this type. */
16804 /* Each enumerator now has the type of its enumeration. Clear the cache
16805 so that this change in types doesn't confuse us later on. */
16807 }
16809 /* Finishes the enum type. This is called only the first time an
16810 enumeration is seen, be it opaque or odinary.
16811 ENUMTYPE is the type object. */
16813 void
16815 {
16817 {
16821 }
16823 /* If this is a forward declaration, there should not be any variants,
16824 though we can get a variant in the middle of an enum-specifier with
16825 wacky code like 'enum E { e = sizeof(const E*) };' */
16829 }
16831 /* Build and install a CONST_DECL for an enumeration constant of the
16832 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
16833 Apply ATTRIBUTES if available. LOC is the location of NAME.
16834 Assignment of sequential values by default is handled here. */
16836 tree
16838 location_t loc)
16839 {
16840 tree decl;
16841 tree context;
16842 tree type;
16844 /* scalar_constant_value will pull out this expression, so make sure
16845 it's folded as appropriate. */
16849 /* If the VALUE was erroneous, pretend it wasn't there; that will
16850 result in the enum being assigned the next value in sequence. */
16854 /* Remove no-op casts from the value. */
16859 {
16860 /* Validate and default VALUE. */
16862 {
16864 {
16869 }
16872 value = perform_implicit_conversion_flags
16880 {
16883 {
16885 "enumerator value for %qD must have integral or "
16888 }
16889 else
16890 {
16894 {
16898 }
16899 }
16900 }
16901 }
16903 /* Default based on previous value. */
16905 {
16907 {
16908 tree prev_value;
16910 /* C++03 7.2/4: If no initializer is specified for the first
16911 enumerator, the type is an unspecified integral
16912 type. Otherwise the type is the same as the type of the
16913 initializing value of the preceding enumerator unless the
16914 incremented value is not representable in that type, in
16915 which case the type is an unspecified integral type
16916 sufficient to contain the incremented value. */
16920 else
16921 {
16928 {
16931 {
16934 {
16940 }
16947 }
16950 else
16952 }
16955 {
16958 }
16959 }
16960 }
16961 else
16963 }
16965 /* Remove no-op casts from the value. */
16968 /* If the underlying type of the enum is fixed, check whether
16969 the enumerator values fits in the underlying type. If it
16970 does not fit, the program is ill-formed [C++0x dcl.enum]. */
16972 && value
16974 {
16979 /* Convert the value to the appropriate type. */
16981 }
16982 }
16984 /* C++ associates enums with global, function, or class declarations. */
16987 /* Build the actual enumeration constant. Note that the enumeration
16988 constants have the underlying type of the enum (if it is fixed)
16989 or the type of their initializer (if the underlying type of the
16990 enum is not fixed):
16992 [ C++0x dcl.enum ]
16994 If the underlying type is fixed, the type of each enumerator
16995 prior to the closing brace is the underlying type; if the
16996 initializing value of an enumerator cannot be represented by
16997 the underlying type, the program is ill-formed. If the
16998 underlying type is not fixed, the type of each enumerator is
16999 the type of its initializing value.
17001 If the underlying type is not fixed, it will be computed by
17002 finish_enum and we will reset the type of this enumerator. Of
17003 course, if we're processing a template, there may be no value. */
17017 {
17018 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
17019 on the TYPE_FIELDS list for `S'. (That's so that you can say
17020 things like `S::i' later.) */
17022 /* The enumerator may be getting declared outside of its enclosing
17023 class, like so:
17025 class S { public: enum E : int; }; enum S::E : int { i = 7; };
17027 For which case we need to make sure that the access of `S::i'
17028 matches the access of `S::E'. */
17032 }
17033 else
17036 /* Add this enumeration constant to the list for this type. */
17040 }
17042 /* Look for an enumerator with the given NAME within the enumeration
17043 type ENUMTYPE. This routine is used primarily for qualified name
17044 lookup into an enumerator in C++0x, e.g.,
17046 enum class Color { Red, Green, Blue };
17048 Color color = Color::Red;
17050 Returns the value corresponding to the enumerator, or
17051 NULL_TREE if no such enumerator was found. */
17052 tree
17054 {
17055 tree e;
17060 }
17062 /* Implement LANG_HOOKS_SIMULATE_ENUM_DECL. */
17064 tree
17067 {
17074 {
17079 }
17093 }
17095 /* Implement LANG_HOOKS_SIMULATE_RECORD_DECL. */
17097 tree
17100 {
17107 {
17110 }
17129 }
17130 \f
17131 /* We're defining DECL. Make sure that its type is OK. */
17133 static void
17135 {
17139 /* In a function definition, arg types must be complete. */
17146 {
17151 /* Make it return void instead. */
17154 void_type_node,
17156 else
17158 fntype = (cp_build_type_attribute_variant
17162 }
17163 else
17164 {
17168 }
17169 }
17171 /* True iff FN is an implicitly-defined default constructor. */
17173 static bool
17175 {
17179 }
17181 /* Clobber the contents of *this to let the back end know that the object
17182 storage is dead when we enter the constructor or leave the destructor. */
17184 static tree
17186 {
17187 /* Clobbering an empty base is pointless, and harmful if its one byte
17188 TYPE_SIZE overlays real data. */
17192 /* If we have virtual bases, clobber the whole object, but only if we're in
17193 charge. If we don't have virtual bases, clobber the as-base type so we
17194 don't mess with tail padding. */
17205 {
17208 }
17215 }
17217 /* Create the FUNCTION_DECL for a function definition.
17218 DECLSPECS and DECLARATOR are the parts of the declaration;
17219 they describe the function's name and the type it returns,
17220 but twisted together in a fashion that parallels the syntax of C.
17222 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
17223 DECLARATOR is really the DECL for the function we are about to
17224 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
17225 indicating that the function is an inline defined in-class.
17227 This function creates a binding context for the function body
17228 as well as setting up the FUNCTION_DECL in current_function_decl.
17230 For C++, we must first check whether that datum makes any sense.
17231 For example, "class A local_a(1,2);" means that variable local_a
17232 is an aggregate of type A, which should have a constructor
17233 applied to it with the argument list [1, 2].
17235 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
17236 or may be a BLOCK if the function has been defined previously
17237 in this translation unit. On exit, DECL_INITIAL (decl1) will be
17238 error_mark_node if the function has never been defined, or
17239 a BLOCK if the function has been defined somewhere. */
17241 bool
17243 {
17247 /* Sanity check. */
17254 else
17255 {
17260 }
17267 /* Handle gnu_inline attribute. */
17269 {
17274 }
17277 /* This is a constructor, we must ensure that any default args
17278 introduced by this definition are propagated to the clones
17279 now. The clones are used directly in overload resolution. */
17282 /* Sometimes we don't notice that a function is a static member, and
17283 build a METHOD_TYPE for it. Fix that up now. */
17287 /* Set up current_class_type, and enter the scope of the class, if
17288 appropriate. */
17294 /* Now that we have entered the scope of the class, we must restore
17295 the bindings for any template parameters surrounding DECL1, if it
17296 is an inline member template. (Order is important; consider the
17297 case where a template parameter has the same name as a field of
17298 the class.) It is not until after this point that
17299 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
17303 /* Effective C++ rule 15. */
17311 /* Make the init_value nonzero so pushdecl knows this is not tentative.
17312 error_mark_node is replaced below (in poplevel) with the BLOCK. */
17316 /* This function exists in static storage.
17317 (This does not mean `static' in the C sense!) */
17320 /* We must call push_template_decl after current_class_type is set
17321 up. (If we are processing inline definitions after exiting a
17322 class scope, current_class_type will be NULL_TREE until set above
17323 by push_nested_class.) */
17325 {
17328 {
17332 }
17334 }
17336 /* Make sure the parameter and return types are reasonable. When
17337 you declare a function, these types can be incomplete, but they
17338 must be complete when you define the function. */
17341 /* Build the return declaration for the function. */
17345 {
17346 /* In a template instantiation, copy the return type location. When
17347 parsing, the location will be set in grokdeclarator. */
17350 {
17354 }
17362 }
17364 /* Record the decl so that the function name is defined.
17365 If we already have a decl for this name, and it is a FUNCTION_DECL,
17366 use the old decl. */
17368 {
17369 /* A specialization is not used to guide overload resolution. */
17373 {
17377 /* If something went wrong when registering the declaration,
17378 use DECL1; we have to have a FUNCTION_DECL to use when
17379 parsing the body of the function. */
17380 ;
17381 else
17382 {
17383 /* Otherwise, OLDDECL is either a previous declaration
17384 of the same function or DECL1 itself. */
17391 {
17392 tree context;
17394 /* Check whether DECL1 is in an anonymous
17395 namespace. */
17397 context;
17399 {
17403 }
17407 OPT_Wmissing_declarations,
17409 }
17412 }
17413 }
17414 else
17415 {
17416 /* We need to set the DECL_CONTEXT. */
17419 }
17423 /* If #pragma weak applies, mark the decl appropriately now.
17424 The pragma only applies to global functions. Because
17425 determining whether or not the #pragma applies involves
17426 computing the mangled name for the declaration, we cannot
17427 apply the pragma until after we have merged this declaration
17428 with any previous declarations; if the original declaration
17429 has a linkage specification, that specification applies to
17430 the definition as well, and may affect the mangled name. */
17433 }
17435 /* We are now in the scope of the function being defined. */
17438 /* Save the parm names or decls from this function's declarator
17439 where store_parm_decls will find them. */
17442 /* Let the user know we're compiling this function. */
17447 /* This function may already have been parsed, in which case just
17448 return; our caller will skip over the body without parsing. */
17452 /* Initialize RTL machinery. We cannot do this until
17453 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
17454 even when processing a template; this is how we get
17455 CFUN set up, and our per-function variables initialized.
17456 FIXME factor out the non-RTL stuff. */
17460 /* Initialize the language data structures. Whenever we start
17461 a new function, we destroy temporaries in the usual way. */
17466 /* If we are (erroneously) defining a function that we have already
17467 defined before, wipe out what we knew before. */
17473 {
17476 }
17478 /* Start the statement-tree, start the tree now. */
17482 {
17483 /* We know that this was set up by `grokclassfn'. We do not
17484 wait until `store_parm_decls', since evil parse errors may
17485 never get us to that point. Here we keep the consistency
17486 between `current_class_type' and `current_class_ptr'. */
17492 cp_function_chain->x_current_class_ref
17494 /* Set this second to avoid shortcut in cp_build_indirect_ref. */
17497 /* Constructors and destructors need to know whether they're "in
17498 charge" of initializing virtual base classes. */
17501 {
17504 }
17506 {
17509 }
17510 }
17513 /* Implicitly-defined methods (like the
17514 destructor for a class in which no destructor
17515 is explicitly declared) must not be defined
17516 until their definition is needed. So, we
17517 ignore interface specifications for
17518 compiler-generated functions. */
17526 {
17533 /* This is a function in a local class in an extern inline
17534 or template function. */
17536 }
17537 /* If this function belongs to an interface, it is public.
17538 If it belongs to someone else's interface, it is also external.
17539 This only affects inlines and template instantiations. */
17541 {
17544 {
17548 && ! flag_implement_inlines
17551 /* For WIN32 we also want to put these in linkonce sections. */
17553 }
17554 else
17557 /* If this function is in an interface implemented in this file,
17558 make sure that the back end knows to emit this function
17559 here. */
17562 }
17565 {
17566 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
17567 interface, we will have both finfo->interface_unknown and
17568 finfo->interface_only set. In that case, we don't want to
17569 use the normal heuristics because someone will supply a
17570 #pragma implementation elsewhere, and deducing it here would
17571 produce a conflict. */
17576 }
17577 else
17578 {
17579 /* This is a definition, not a reference.
17580 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
17588 else
17590 }
17592 /* Determine the ELF visibility attribute for the function. We must not
17593 do this before calling "pushdecl", as we must allow "duplicate_decls"
17594 to merge any attributes appropriately. We also need to wait until
17595 linkage is set. */
17616 /* Clobbering an empty base is harmful if it overlays real data. */
17618 /* We can't clobber safely for an implicitly-defined default constructor
17619 because part of the initialization might happen before we enter the
17620 constructor, via AGGR_INIT_ZERO_FIRST (c++/68006). */
17635 }
17638 /* Like start_preparsed_function, except that instead of a
17639 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
17641 Returns true on success. If the DECLARATOR is not suitable
17642 for a function, we return false, which tells the parser to
17643 skip the entire function. */
17645 bool
17648 tree attrs)
17649 {
17650 tree decl1;
17658 /* main must return int. grokfndecl should have corrected it
17659 (and issued a diagnostic) if the user got it wrong. */
17661 integer_type_node));
17664 }
17665 \f
17666 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
17667 FN. */
17669 static bool
17671 {
17673 && !processing_template_decl
17674 /* We insert the EH_SPEC_BLOCK only in the original
17675 function; then, it is copied automatically to the
17676 clones. */
17678 /* Implicitly-generated constructors and destructors have
17679 exception specifications. However, those specifications
17680 are the union of the possible exceptions specified by the
17681 constructors/destructors for bases and members, so no
17682 unallowed exception will ever reach this function. By
17683 not creating the EH_SPEC_BLOCK we save a little memory,
17684 and we avoid spurious warnings about unreachable
17685 code. */
17688 }
17690 /* Helper function to push ARGS into the current lexical scope. DECL
17691 is the function declaration. NONPARMS is used to handle enum
17692 constants. */
17694 void
17696 {
17697 /* If we're doing semantic analysis, then we'll call pushdecl
17698 for each of these. We must do them in reverse order so that
17699 they end in the correct forward order. */
17702 tree next;
17704 {
17709 {
17710 /* If we find an enum constant or a type tag, put it aside for
17711 the moment. */
17714 }
17715 }
17717 /* Get the decls in their original chain order and record in the
17718 function. This is all and only the PARM_DECLs that were
17719 pushed into scope by the loop above. */
17721 }
17723 /* Store the parameter declarations into the current function declaration.
17724 This is called after parsing the parameter declarations, before
17725 digesting the body of the function.
17727 Also install to binding contour return value identifier, if any. */
17729 static void
17731 {
17734 /* This is a chain of any other decls that came in among the parm
17735 declarations. If a parm is declared with enum {foo, bar} x;
17736 then CONST_DECLs for foo and bar are put here. */
17740 {
17741 /* This case is when the function was defined with an ANSI prototype.
17742 The parms already have decls, so we need not do anything here
17743 except record them as in effect
17744 and complain if any redundant old-style parm decls were written. */
17748 /* Must clear this because it might contain TYPE_DECLs declared
17749 at class level. */
17753 }
17754 else
17757 /* Now store the final chain of decls for the arguments
17758 as the decl-chain of the current lexical scope.
17759 Put the enumerators in as well, at the front so that
17760 DECL_ARGUMENTS is not modified. */
17765 }
17767 \f
17768 /* Set the return value of the [cd]tor if the ABI wants that. */
17770 void
17772 {
17774 {
17775 /* Return the address of the object. */
17783 }
17784 }
17786 /* Do all the processing for the beginning of a destructor; set up the
17787 vtable pointers and cleanups for bases and members. */
17789 static void
17791 {
17792 tree compound_stmt;
17794 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
17795 issued an error message. We still want to try to process the
17796 body of the function, but initialize_vtbl_ptrs will crash if
17797 TYPE_BINFO is NULL. */
17799 {
17801 /* Make all virtual function table pointers in non-virtual base
17802 classes point to CURRENT_CLASS_TYPE's virtual function
17803 tables. */
17808 /* Clobbering an empty base is harmful if it overlays real data. */
17810 {
17814 {
17816 tree ref
17823 tf_warning_or_error);
17824 /* If the vptr is shared with some virtual nearly empty base,
17825 don't clear it if not in charge, the dtor of the virtual
17826 nearly empty base will do that later. */
17828 {
17831 {
17833 {
17835 tf_warning_or_error);
17838 }
17840 }
17841 }
17843 }
17844 else
17846 }
17848 /* And insert cleanups for our bases and members so that they
17849 will be properly destroyed if we throw. */
17851 }
17852 }
17854 /* Do the necessary processing for the beginning of a function body, which
17855 in this case includes member-initializers, but not the catch clauses of
17856 a function-try-block. Currently, this means opening a binding level
17857 for the member-initializers (in a ctor), member cleanups (in a dtor),
17858 and capture proxies (in a lambda operator()). */
17860 tree
17862 {
17868 else
17869 /* Always keep the BLOCK node associated with the outermost pair of
17870 curly braces of a function. These are needed for correct
17871 operation of dwarfout.c. */
17882 }
17884 /* Do the processing for the end of a function body. Currently, this means
17885 closing out the cleanups for fully-constructed bases and members, and in
17886 the case of the destructor, deleting the object if desired. Again, this
17887 is only meaningful for [cd]tors, since they are the only functions where
17888 there is a significant distinction between the main body and any
17889 function catch clauses. Handling, say, main() return semantics here
17890 would be wrong, as flowing off the end of a function catch clause for
17891 main() would also need to return 0. */
17893 void
17895 {
17899 /* Close the block. */
17907 }
17909 /* Given a function, returns the BLOCK corresponding to the outermost level
17910 of curly braces, skipping the artificial block created for constructor
17911 initializers. */
17913 tree
17915 {
17925 }
17927 /* If FNDECL is a class's key method, add the class to the list of
17928 keyed classes that should be emitted. */
17930 static void
17932 {
17936 {
17940 }
17941 }
17943 /* Attempt to add a fix-it hint to RICHLOC suggesting the insertion
17944 of "return *this;" immediately before its location, using FNDECL's
17945 first statement (if any) to give the indentation, if appropriate. */
17947 static void
17949 {
17956 indent);
17957 }
17959 /* This function carries out the subset of finish_function operations needed
17960 to emit the compiler-generated outlined helper functions used by the
17961 coroutines implementation. */
17963 static void
17965 {
17966 /* This is a partial set of the operations done by finish_function()
17967 plus emitting the result. */
17977 /* We must start each function with a clear fold cache. */
17982 /* This function has coroutine IFNs that we should handle in middle
17983 end lowering. */
17987 }
17989 /* Finish up a function declaration and compile that function
17990 all the way to assembler language output. The free the storage
17991 for the function definition. INLINE_P is TRUE if we just
17992 finished processing the body of an in-class inline function
17993 definition. (This processing will have taken place after the
17994 class definition is complete.) */
17996 tree
17998 {
18003 && !processing_template_decl
18007 /* When we get some parse errors, we can end up without a
18008 current_function_decl, so cope. */
18022 /* TREE_READONLY (fndecl) = 1;
18023 This caused &foo to be of type ptr-to-const-function
18024 which then got a warning when stored in a ptr-to-function variable. */
18027 /* The current function is being defined, so its DECL_INITIAL should
18028 be set, and unless there's a multiple definition, it should be
18029 error_mark_node. */
18033 {
18034 /* Only try to emit the coroutine outlined helper functions if the
18035 transforms succeeded. Otherwise, treat errors in the same way as
18036 a regular function. */
18039 /* We should handle coroutine IFNs in middle end lowering. */
18042 /* Do not try to process the ramp's EH unless outlining succeeded. */
18046 current_eh_spec_block);
18047 }
18048 else
18049 /* For a cloned function, we've already got all the code we need;
18050 there's no need to add any extra bits. */
18052 {
18053 /* Make it so that `main' always returns 0 by default. */
18061 current_eh_spec_block);
18062 }
18064 /* If we're saving up tree structure, tie off the function now. */
18069 /* This must come after expand_function_end because cleanups might
18070 have declarations (from inline functions) that need to go into
18071 this function's blocks. */
18073 /* If the current binding level isn't the outermost binding level
18074 for this function, either there is a bug, or we have experienced
18075 syntax errors and the statement tree is malformed. */
18077 {
18078 /* Make sure we have already experienced errors. */
18081 /* Throw away the broken statement tree and extra binding
18082 levels. */
18086 {
18089 else
18091 }
18092 }
18095 /* Statements should always be full-expressions at the outermost set
18096 of curly braces for a function. */
18099 /* If there are no return statements in a function with auto return type,
18100 the return type is void. But if the declared type is something like
18101 auto*, this is an error. */
18104 {
18106 && !current_function_returns_value
18108 {
18109 /* We haven't applied return type deduction because we haven't
18110 seen any return statements. Do that now. */
18114 adc_return_type);
18118 }
18121 {
18126 }
18127 }
18129 /* Remember that we were in class scope. */
18134 {
18138 }
18140 // If this is a concept, check that the definition is reasonable.
18149 /* Complain if there's just no return statement. */
18156 /* Don't complain if we abort or throw. */
18157 && !current_function_returns_abnormally
18158 /* Don't complain if there's an infinite loop. */
18159 && !current_function_infinite_loop
18160 /* Don't complain if we are declared noreturn. */
18164 /* Structor return values (if any) are set by the compiler. */
18168 {
18170 /* Potentially add a "return *this;" fix-it hint for
18171 assignment operators. */
18173 {
18176 && current_class_ref
18177 && same_type_ignoring_top_level_qualifiers_p
18183 }
18189 "no return statement in function returning "
18192 }
18194 /* Lambda closure members are implicitly constexpr if possible. */
18198 = ((processing_template_decl
18202 /* Save constexpr function body before it gets munged by
18203 the NRV transformation. */
18206 /* Invoke the pre-genericize plugin before we start munging things. */
18210 /* Perform delayed folding before NRV transformation. */
18216 /* Set up the named return value optimization, if we can. Candidate
18217 variables are selected in check_return_expr. */
18219 {
18221 tree outer;
18224 /* This is only worth doing for fns that return in memory--and
18225 simpler, since we don't have to worry about promoted modes. */
18227 /* Only allow this for variables declared in the outer scope of
18228 the function so we know that their lifetime always ends with a
18229 return; see g++.dg/opt/nrv6.C. We could be more flexible if
18230 we were to do this optimization in tree-ssa. */
18236 }
18238 /* Must mark the RESULT_DECL as being in this function. */
18241 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
18242 to the FUNCTION_DECL node itself. */
18245 /* Store the end of the function, so that we get good line number
18246 info for the epilogue. */
18249 /* Complain about parameters that are only set, but never otherwise used. */
18251 && !processing_template_decl
18254 {
18255 tree decl;
18258 decl;
18272 OPT_Wunused_but_set_parameter,
18275 }
18277 /* Complain about locally defined typedefs that are not used in this
18278 function. */
18281 /* Possibly warn about unused parameters. */
18283 && !processing_template_decl
18287 /* Genericize before inlining. */
18293 /* If this function can't throw any exceptions, remember that. */
18296 && !flag_non_call_exceptions
18301 /* Emit the resumer and destroyer functions now, providing that we have
18302 not encountered some fatal error. */
18304 {
18307 }
18309 cleanup:
18310 /* We're leaving the context of this function, so zap cfun. It's still in
18311 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
18315 /* If this is an in-class inline definition, we may have to pop the
18316 bindings for the template parameters that we added in
18317 maybe_begin_member_template_processing when start_function was
18318 called. */
18322 /* Leave the scope of the class. */
18328 /* Clean up. */
18336 }
18337 \f
18338 /* Create the FUNCTION_DECL for a function definition.
18339 DECLSPECS and DECLARATOR are the parts of the declaration;
18340 they describe the return type and the name of the function,
18341 but twisted together in a fashion that parallels the syntax of C.
18343 This function creates a binding context for the function body
18344 as well as setting up the FUNCTION_DECL in current_function_decl.
18346 Returns a FUNCTION_DECL on success.
18348 If the DECLARATOR is not suitable for a function (it defines a datum
18349 instead), we return 0, which tells yyparse to report a parse error.
18351 May return void_type_node indicating that this method is actually
18352 a friend. See grokfield for more details.
18354 Came here with a `.pushlevel' .
18356 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
18357 CHANGES TO CODE IN `grokfield'. */
18359 tree
18362 {
18372 /* Pass friends other than inline friend functions back. */
18377 {
18382 }
18386 /* p1779 ABI-Isolation makes inline not a default for in-class
18387 definitions in named module purview. If the user explicitly
18388 made it inline, grokdeclarator will already have done the right
18389 things. */
18391 || flag_module_implicit_inline
18392 /* Lambda's operator function remains inline. */
18394 /* If the user explicitly asked for this to be inline, we don't
18395 need to do more, but more importantly we want to warn if we
18396 can't inline it. */
18398 {
18402 /* It's ok if we can't inline this. */
18404 }
18406 /* We process method specializations in finish_struct_1. */
18408 {
18409 /* Avoid calling decl_spec_seq... until we have to. */
18414 }
18417 {
18420 }
18426 }
18427 \f
18429 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
18430 we can lay it out later, when and if its type becomes complete.
18432 Also handle constexpr variables where the initializer involves
18433 an unlowered PTRMEM_CST because the class isn't complete yet. */
18435 void
18437 {
18440 /* Keep track of variables with incomplete types. */
18443 {
18451 /* RTTI TD entries are created while defining the type_info. */
18454 {
18457 }
18461 {
18462 /* When the outermost open class is complete we can resolve any
18463 pointers-to-members. */
18467 }
18468 }
18469 }
18471 /* Called when a class type (given by TYPE) is defined. If there are
18472 any existing VAR_DECLs whose type has been completed by this
18473 declaration, update them now. */
18475 void
18477 {
18482 {
18484 {
18491 {
18492 /* Complete the type of the variable. */
18497 }
18499 /* Remove this entry from the list. */
18501 }
18502 else
18503 ix++;
18504 }
18505 }
18507 /* If DECL is of a type which needs a cleanup, build and return an
18508 expression to perform that cleanup here. Return NULL_TREE if no
18509 cleanup need be done. DECL can also be a _REF when called from
18510 split_nonconstant_init_1. */
18512 tree
18514 {
18515 tree type;
18516 tree attr;
18517 tree cleanup;
18519 /* Assume no cleanup is required. */
18525 /* Handle "__attribute__((cleanup))". We run the cleanup function
18526 before the destructor since the destructor is what actually
18527 terminates the lifetime of the object. */
18530 else
18533 {
18534 tree id;
18535 tree fn;
18536 tree arg;
18538 /* Get the name specified by the user for the cleanup function. */
18540 /* Look up the name to find the cleanup function to call. It is
18541 important to use lookup_name here because that is what is
18542 used in c-common.cc:handle_cleanup_attribute when performing
18543 initial checks on the attribute. Note that those checks
18544 include ensuring that the function found is not an overloaded
18545 function, or an object with an overloaded call operator,
18546 etc.; we can rely on the fact that the function found is an
18547 ordinary FUNCTION_DECL. */
18555 }
18556 /* Handle ordinary C++ destructors. */
18559 {
18561 tree addr;
18562 tree call;
18566 else
18580 else
18582 }
18584 /* build_delete sets the location of the destructor call to the
18585 current location, even though the destructor is going to be
18586 called later, at the end of the current scope. This can lead to
18587 a "jumpy" behavior for users of debuggers when they step around
18588 the end of the block. So let's unset the location of the
18589 destructor call instead. */
18597 /* Treat objects with destructors as used; the destructor may do
18598 something substantive. */
18607 }
18609 \f
18610 /* Return the FUNCTION_TYPE that corresponds to MEMFNTYPE, which can be a
18611 FUNCTION_DECL, METHOD_TYPE, FUNCTION_TYPE, pointer or reference to
18612 METHOD_TYPE or FUNCTION_TYPE, or pointer to member function. */
18614 tree
18616 {
18617 tree fntype;
18618 tree args;
18631 fntype = (cp_build_type_attribute_variant
18635 }
18637 /* DECL was originally constructed as a non-static member function,
18638 but turned out to be static. Update it accordingly. */
18640 void
18642 {
18655 }
18657 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
18658 one of the language-independent trees. */
18660 enum cp_tree_node_structure_enum
18662 {
18664 {
18682 }
18683 }
18685 bool
18687 {
18688 /* A missing noreturn is ok for the `main' function. */
18690 }
18692 /* Return the decl used to identify the COMDAT group into which DECL should
18693 be placed. */
18695 tree
18697 {
18698 /* Virtual tables, construction virtual tables, and virtual table
18699 tables all go in a single COMDAT group, named after the primary
18700 virtual table. */
18703 /* For all other DECLs, the COMDAT group is the mangled name of the
18704 declaration itself. */
18705 else
18706 {
18708 {
18709 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
18710 into the same section as the target function. In that case
18711 we must return target's name. */
18717 else
18719 }
18720 }
18723 }
18725 /* Returns the return type for FN as written by the user, which may include
18726 a placeholder for a deduced return type. */
18728 tree
18730 {
18736 }
18738 /* Returns true iff DECL is a variable or function declared with an auto type
18739 that has not yet been deduced to a real type. */
18741 bool
18743 {
18750 }
18752 /* Complain if DECL has an undeduced return type. */
18754 bool
18756 {
18758 {
18762 {
18763 /* Set the return type of __builtin_source_location. */
18766 {
18769 }
18774 }
18782 }
18784 }
18786 /* Create a representation of the explicit-specifier with
18787 constant-expression of EXPR. COMPLAIN is as for tsubst. */
18789 tree
18791 {
18796 /* Wait for instantiation, tsubst_function_decl will handle it. */
18803 }