| blob | 792ebcc978c09810b42658c2ee4c73fc1e3d10ea |
1 /* Process declarations and variables for C++ compiler.
2 Copyright (C) 1988-2017 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. */
54 /* Possible cases of bad specifiers type used by bad_specifiers. */
59 BSP_FIELD /* field */
60 };
99 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 /* Indicates that there is a type value in some namespace, although
143 that is not necessarily in scope at the moment. */
145 tree global_type_node;
147 /* The node that holds the "name" of the global scope. */
148 tree global_scope_name;
150 #define local_names cp_function_chain->x_local_names
152 /* A list of objects which have constructors or destructors
153 which reside in the global scope. The decl is stored in
154 the TREE_VALUE slot and the initializer is stored
155 in the TREE_PURPOSE slot. */
156 tree static_aggregates;
158 /* Like static_aggregates, but for thread_local variables. */
159 tree tls_aggregates;
161 /* -- end of C++ */
163 /* A node for the integer constant 2. */
165 tree integer_two_node;
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. */
193 /* The decl itself. */
194 tree label_decl;
196 /* The binding level to which the label is *currently* attached.
197 This is initially set to the binding level in which the label
198 is defined, but is modified as scopes are closed. */
200 /* The head of the names list that was current when the label was
201 defined, or the inner scope popped. These are the decls that will
202 be skipped when jumping to the label. */
203 tree names_in_scope;
204 /* A vector of all decls from all binding levels that would be
205 crossed by a backward branch to the label. */
208 /* A list of uses of the label, before the label is defined. */
211 /* The following bits are set after the label is defined, and are
212 updated as scopes are popped. They indicate that a backward jump
213 to the label will illegally enter a scope of the given flavor. */
219 };
221 #define named_labels cp_function_chain->x_named_labels
222 \f
223 /* The number of function bodies which we are currently processing.
224 (Zero if we are at namespace scope, one inside the body of a
225 function, two inside the body of a function in a local class, etc.) */
228 /* Whether the exception-specifier is part of a function type (i.e. C++17). */
231 /* States indicating how grokdeclarator() should handle declspecs marked
232 with __attribute__((deprecated)). An object declared as
233 __attribute__((deprecated)) suppresses warnings of uses of other
234 deprecated items. */
237 \f
238 /* A list of VAR_DECLs whose type was incomplete at the time the
239 variable was declared. */
242 tree decl;
243 tree incomplete_type;
244 };
248 \f
249 /* Returns the kind of template specialization we are currently
250 processing, given that it's declaration contained N_CLASS_SCOPES
251 explicit scope qualifications. */
253 tmpl_spec_kind
255 {
261 /* Scan through the template parameter scopes. */
265 {
266 /* If we see a specialization scope inside a parameter scope,
267 then something is wrong. That corresponds to a declaration
268 like:
270 template <class T> template <> ...
272 which is always invalid since [temp.expl.spec] forbids the
273 specialization of a class member template if the enclosing
274 class templates are not explicitly specialized as well. */
276 {
279 else
281 }
286 }
288 /* Handle explicit instantiations. */
290 {
292 /* We've seen a template parameter list during an explicit
293 instantiation. For example:
295 template <class T> template void f(int);
297 This is erroneous. */
299 else
301 }
304 /* We've not seen enough template headers to match all the
305 specialized classes present. For example:
307 template <class T> void R<T>::S<T>::f(int);
309 This is invalid; there needs to be one set of template
310 parameters for each class. */
313 /* We're processing a non-template declaration (even though it may
314 be a member of a template class.) For example:
316 template <class T> void S<T>::f(int);
318 The `class T' matches the `S<T>', leaving no template headers
319 corresponding to the `f'. */
322 /* We've got too many template headers. For example:
324 template <> template <class T> void f (T);
326 There need to be more enclosing classes. */
328 else
329 /* This must be a template. It's of the form:
331 template <class T> template <class U> void S<T>::f(U);
333 This is a specialization if the innermost level was a
334 specialization; otherwise it's just a definition of the
335 template. */
337 }
339 /* Exit the current scope. */
341 void
343 {
345 }
347 /* When a label goes out of scope, check to see if that label was used
348 in a valid manner, and issue any appropriate warnings or errors. */
350 static void
352 {
354 {
356 {
357 location_t location;
361 /* FIXME want (LOCATION_FILE (input_location), (line)0) */
362 /* Avoid crashing later. */
364 }
365 else
367 }
370 }
372 /* Push all named labels into a vector, so that we can sort it on DECL_UID
373 to avoid code generation differences. */
375 int
377 {
380 }
382 /* Helper function to sort named label entries in a vector by DECL_UID. */
384 static int
386 {
394 }
396 /* At the end of a function, all labels declared within the function
397 go out of scope. BLOCK is the top-level block for the
398 function. */
400 static void
402 {
404 {
409 /* Push all the labels into a vector and sort them by DECL_UID,
410 so that gaps between DECL_UIDs don't affect code generation. */
415 {
420 /* Put the labels into the "variables" of the top-level block,
421 so debugger can see them. */
426 }
428 }
429 }
431 /* At the end of a block with local labels, restore the outer definition. */
433 static void
435 {
443 }
445 /* The following two routines are used to interface to Objective-C++.
446 The binding level is purposely treated as an opaque type. */
450 {
452 }
454 /* The following routine is used by the NeXT-style SJLJ exceptions;
455 variables get marked 'volatile' so as to not be clobbered by
456 _setjmp()/_longjmp() calls. All variables in the current scope,
457 as well as parent scopes up to (but not including) ENCLOSING_BLK
458 shall be thusly marked. */
460 void
462 {
468 {
469 tree decl;
474 /* Do not climb up past the current function. */
477 }
478 }
480 /* True if B is the level for the condition of a constexpr if. */
482 static bool
484 {
488 }
490 /* Update data for defined and undefined labels when leaving a scope. */
492 int
494 {
499 {
500 tree decl;
502 /* ENT->NAMES_IN_SCOPE may contain a mixture of DECLs and
503 TREE_LISTs representing OVERLOADs, so be careful. */
513 {
532 }
533 }
535 {
540 {
545 }
546 }
549 }
551 /* Saved errorcount to avoid -Wunused-but-set-{parameter,variable} warnings
552 when errors were reported, except for -Werror-unused-but-set-*. */
555 /* Exit a binding level.
556 Pop the level off, and restore the state of the identifier-decl mappings
557 that were in effect when this level was entered.
559 If KEEP == 1, this level had explicit declarations, so
560 and create a "block" (a BLOCK node) for the level
561 to record its declarations and subblocks for symbol table output.
563 If FUNCTIONBODY is nonzero, this level is the body of a function,
564 so create a block as if KEEP were set and also clear out all
565 label names.
567 If REVERSE is nonzero, reverse the order of decls before putting
568 them into the BLOCK. */
570 tree
572 {
573 tree link;
574 /* The chain of decls was accumulated in reverse order.
575 Put it into forward order, just for cleanliness. */
576 tree decls;
577 tree subblocks;
578 tree block;
579 tree decl;
581 scope_kind kind;
586 restart:
598 /* We used to use KEEP == 2 to indicate that the new block should go
599 at the beginning of the list of blocks at this binding level,
600 rather than the end. This hack is no longer used. */
606 /* Any uses of undefined labels, and any defined labels, now operate
607 under constraints of next binding contour. */
612 /* Get the decls in the order they were written.
613 Usually current_binding_level->names is in reverse order.
614 But parameter decls were previously put in forward order. */
617 current_binding_level->names
619 else
622 /* If there were any declarations or structure tags in that level,
623 or if this level is a function body,
624 create a BLOCK to record them for the life of this function. */
626 /* Avoid function body block if possible. */
632 {
635 }
637 /* In each subblock, record that this is its superior. */
642 /* We still support the old for-scope rules, whereby the variables
643 in a init statement were in scope after the for-statement ended.
644 We only use the new rules if flag_new_for_scope is nonzero. */
645 leaving_for_scope
648 /* Before we remove the declarations first check for unused variables. */
653 {
654 /* There are cases where D itself is a TREE_LIST. See in
655 push_local_binding where the list of decls returned by
656 getdecls is built. */
668 {
673 // For -Wunused-but-set-variable leave references alone.
676 {
678 OPT_Wunused_but_set_variable,
681 }
682 }
683 }
685 /* Remove declarations for all the DECLs in this level. */
687 {
689 /* It's hard to make this ARM compatibility hack play nicely with
690 lambdas, and it really isn't necessary in C++11 mode. */
693 {
696 tree ns_binding;
703 else
707 /* We have something like:
709 int i;
710 for (int i; ;);
712 and we are leaving the `for' scope. There's no reason to
713 keep the binding of the inner `i' in this case. */
717 /* Here, we have something like:
719 typedef int I;
721 void f () {
722 for (int I; ;);
723 }
725 We must pop the for-scope binding so we know what's a
726 type and what isn't. */
728 else
729 {
730 /* Mark this VAR_DECL as dead so that we can tell we left it
731 there only for backward compatibility. */
734 /* Keep track of what should have happened when we
735 popped the binding. */
737 {
740 }
742 /* Add it to the list of dead variables in the next
743 outermost binding to that we can remove these when we
744 leave that binding. */
747 link);
749 /* Although we don't pop the cxx_binding, we do clear
750 its SCOPE since the scope is going away now. */
753 }
754 }
755 else
756 {
757 tree name;
759 /* Remove the binding. */
771 }
772 }
774 /* Remove declarations for any `for' variables from inner scopes
775 that we kept around. */
780 /* Restore the IDENTIFIER_TYPE_VALUEs. */
785 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
790 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
791 list if a `using' declaration put them there. The debugging
792 back ends won't understand OVERLOAD, so we remove them here.
793 Because the BLOCK_VARS are (temporarily) shared with
794 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
795 popped all the bindings. */
797 {
801 {
804 else
806 }
807 }
809 /* If the level being exited is the top level of a function,
810 check over all the labels. */
812 {
814 {
815 /* Since this is the top level block of a function, the vars are
816 the function's parameters. Don't leave them in the BLOCK
817 because they are found in the FUNCTION_DECL instead. */
820 }
821 else
823 }
827 {
828 tree stmt;
830 /* If this is a temporary binding created for a cleanup, then we'll
831 have pushed a statement list level. Pop that, create a new
832 BIND_EXPR for the block, and insert it into the stream. */
836 }
840 {
841 /* The current function is being defined, so its DECL_INITIAL
842 should be error_mark_node. */
846 {
848 {
851 }
852 else
854 }
855 }
857 current_binding_level->blocks
860 /* If we did not make a block for the level just exited,
861 any blocks made for inner levels
862 (since they cannot be recorded as subblocks in that level)
863 must be carried forward so they will later become subblocks
864 of something else. */
866 current_binding_level->blocks
869 /* Each and every BLOCK node created here in `poplevel' is important
870 (e.g. for proper debugging information) so if we created one
871 earlier, mark it as "used". */
875 /* All temporary bindings created for cleanups are popped silently. */
881 }
883 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
884 itself, calling F for each. The DATA is passed to F as well. */
886 static int
888 {
898 }
900 /* Walk all the namespaces, calling F for each. The DATA is passed to
901 F as well. */
903 int
905 {
907 }
909 /* Call wrapup_globals_declarations for the globals in NAMESPACE. */
911 int
913 {
920 {
921 tree decl;
931 {
933 OPT_Wunused_function,
936 }
937 }
939 /* Write out any globals that need to be output. */
941 }
943 /* Diagnose odr-used extern inline variables without definitions
944 in the current TU. */
945 int
947 {
950 tree decl;
962 }
963 \f
964 /* In C++, you don't have to write `struct S' to refer to `S'; you
965 can just use `S'. We accomplish this by creating a TYPE_DECL as
966 if the user had written `typedef struct S S'. Create and return
967 the TYPE_DECL for TYPE. */
969 tree
971 {
972 tree decl;
976 /* There are other implicit type declarations, like the one *within*
977 a class that allows you to write `S::S'. We must distinguish
978 amongst these. */
984 }
986 /* Remember a local name for name-mangling purposes. */
988 static void
990 {
1000 {
1003 {
1009 else
1015 }
1016 }
1020 }
1021 \f
1022 /* Subroutine of duplicate_decls: return truthvalue of whether
1023 or not types of these decls match.
1025 For C++, we must compare the parameter list so that `int' can match
1026 `int&' in a parameter position, but `int&' is not confused with
1027 `const int&'. */
1029 int
1031 {
1038 /* If the two DECLs are not even the same kind of thing, we're not
1039 interested in their types. */
1045 {
1050 tree r2;
1052 /* Specializations of different templates are different functions
1053 even if they have the same type. */
1068 /* A new declaration doesn't match a built-in one unless it
1069 is also extern "C". */
1077 /* A declaration with deduced return type should use its pre-deduction
1078 type for declaration matching. */
1082 {
1085 #ifndef NO_IMPLICIT_EXTERN_C
1088 #endif
1089 ))
1090 {
1094 }
1095 #ifndef NO_IMPLICIT_EXTERN_C
1103 {
1106 }
1107 #endif
1108 else
1109 types_match =
1115 }
1116 else
1119 /* The decls dont match if they correspond to two different versions
1120 of the same function. Disallow extern "C" functions to be
1121 versions for now. */
1126 {
1127 /* Mark functions as versions if necessary. Modify the mangled decl
1128 name if necessary. */
1133 {
1137 }
1139 {
1143 }
1146 }
1147 }
1149 {
1163 else
1164 // We don't need to check equivalently_constrained for variable and
1165 // function templates because we check it on the results.
1167 }
1168 else
1169 {
1170 /* Need to check scope for variable declaration (VAR_DECL).
1171 For typedef (TYPE_DECL), scope is ignored. */
1174 /* [dcl.link]
1175 Two declarations for an object with C language linkage
1176 with the same name (ignoring the namespace that qualify
1177 it) that appear in different namespace scopes refer to
1178 the same object. */
1188 else
1191 COMPARE_REDECLARATION);
1192 }
1194 // Normal functions can be constrained, as can variable partial
1195 // specializations.
1200 }
1202 /* If NEWDECL is `static' and an `extern' was seen previously,
1203 warn about it. OLDDECL is the previous declaration.
1205 Note that this does not apply to the C++ case of declaring
1206 a variable `extern const' and then later `const'.
1208 Don't complain about built-in functions, since they are beyond
1209 the user's control. */
1211 void
1213 {
1220 /* Don't get confused by static member functions; that's a different
1221 use of `static'. */
1226 /* If the old declaration was `static', or the new one isn't, then
1227 everything is OK. */
1231 /* It's OK to declare a builtin function as `static'. */
1240 }
1242 /* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1243 function templates. If their exception specifications do not
1244 match, issue a diagnostic. */
1246 static void
1248 tree old_decl)
1249 {
1253 /* Two default specs are equivalent, don't force evaluation. */
1263 /* [except.spec]
1265 If any declaration of a function has an exception-specification,
1266 all declarations, including the definition and an explicit
1267 specialization, of that function shall have an
1268 exception-specification with the same set of type-ids. */
1271 {
1279 /* We used to silently permit mismatched eh specs with
1280 -fno-exceptions, so make them a pedwarn now. */
1282 else
1287 }
1288 }
1290 /* Return true if OLD_DECL and NEW_DECL agree on constexprness.
1291 Otherwise issue diagnostics. */
1293 static bool
1295 {
1305 {
1307 {
1308 /* Hide a built-in declaration. */
1312 }
1313 /* 7.1.5 [dcl.constexpr]
1314 Note: An explicit specialization can differ from the template
1315 declaration with respect to the constexpr specifier. */
1321 "redeclaration %qD differs in %<constexpr%> "
1326 }
1328 }
1330 // If OLDDECL and NEWDECL are concept declarations with the same type
1331 // (i.e., and template parameters), but different requirements,
1332 // emit diagnostics and return true. Otherwise, return false.
1335 {
1347 {
1352 {
1355 }
1356 }
1358 }
1360 /* DECL is a redeclaration of a function or function template. If
1361 it does have default arguments issue a diagnostic. Note: this
1362 function is used to enforce the requirements in C++11 8.3.6 about
1363 no default arguments in redeclarations. */
1365 static void
1367 {
1373 {
1375 "redeclaration of %q#D may not have default "
1378 }
1379 }
1381 #define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn) \
1383 DECL_ATTRIBUTES (fn)))
1385 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1386 If the redeclaration is invalid, a diagnostic is issued, and the
1387 error_mark_node is returned. Otherwise, OLDDECL is returned.
1389 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1390 returned.
1392 NEWDECL_IS_FRIEND is true if NEWDECL was declared as a friend. */
1394 tree
1396 {
1400 tree new_template_info;
1407 /* If either the type of the new decl or the type of the old decl is an
1408 error_mark_node, then that implies that we have already issued an
1409 error (earlier) for some bogus type specification, and in that case,
1410 it is rather pointless to harass the user with yet more error message
1411 about the same declaration, so just pretend the types match here. */
1418 {
1429 }
1435 {
1439 else
1442 }
1444 /* Check for redeclaration and other discrepancies. */
1447 {
1450 {
1451 /* Avoid warnings redeclaring built-ins which have not been
1452 explicitly declared. */
1456 /* If you declare a built-in or predefined function name as static,
1457 the old definition is overridden, but optionally warn this was a
1458 bad choice of name. */
1460 {
1465 /* Discard the old built-in function. */
1467 }
1468 /* If the built-in is not ansi, then programs can override
1469 it even globally without an error. */
1474 else
1478 }
1480 {
1487 }
1489 {
1490 /* Avoid warnings redeclaring built-ins which have not been
1491 explicitly declared. */
1493 {
1496 /* A new declaration doesn't match a built-in one unless it
1497 is also extern "C". */
1509 /* Deal with fileptr_type_node. FILE type is not known
1510 at the time we create the builtins. */
1512 {
1519 {
1527 newdecl_is_friend);
1529 }
1530 }
1531 /* Likewise for const struct tm*. */
1533 {
1540 {
1548 newdecl_is_friend);
1550 }
1551 }
1556 OPT_Wbuiltin_declaration_mismatch,
1557 "declaration of %q+#D conflicts with built-in "
1559 }
1564 {
1565 /* A near match; override the builtin. */
1569 OPT_Wbuiltin_declaration_mismatch,
1570 "new declaration %q#D ambiguates built-in "
1572 else
1577 }
1578 else
1579 /* Discard the old built-in function. */
1582 /* Replace the old RTL to avoid problems with inlining. */
1584 }
1585 /* Even if the types match, prefer the new declarations type for
1586 built-ins which have not been explicitly declared, for
1587 exception lists, etc... */
1589 {
1596 }
1598 /* If a function is explicitly declared "throw ()", propagate that to
1599 the corresponding builtin. */
1604 {
1609 }
1611 /* Whether or not the builtin can throw exceptions has no
1612 bearing on this declarator. */
1616 {
1617 /* If a builtin function is redeclared as `static', merge
1618 the declarations, but make the original one static. */
1622 /* Make the old declaration consistent with the new one so
1623 that all remnants of the builtin-ness of this function
1624 will be banished. */
1627 }
1628 }
1630 {
1631 /* C++ Standard, 3.3, clause 4:
1632 "[Note: a namespace name or a class template name must be unique
1633 in its declarative region (7.3.2, clause 14). ]" */
1640 {
1645 {
1646 /* We do nothing special here, because C++ does such nasty
1647 things with TYPE_DECLs. Instead, just let the TYPE_DECL
1648 get shadowed, and know that if we need to find a TYPE_DECL
1649 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
1650 slot of the identifier. */
1652 }
1659 }
1668 }
1670 {
1672 /* These are certainly not duplicate declarations; they're
1673 from different scopes. */
1677 {
1678 /* The name of a class template may not be declared to refer to
1679 any other template, class, function, object, namespace, value,
1680 or type in the same scope. */
1683 {
1688 }
1695 /* Template functions can be disambiguated by
1696 return type. */
1699 // Template functions can also be disambiguated by
1700 // constraints.
1702 {
1706 }
1710 }
1712 {
1714 {
1716 newdecl);
1720 }
1721 /* For function versions, params and types match, but they
1722 are not ambiguous. */
1725 // The functions have the same parameter types.
1728 // And the same constraints.
1730 {
1735 }
1736 else
1738 }
1739 else
1740 {
1745 }
1746 }
1756 /* It's OK to have a template specialization and a non-template
1757 with the same type, or to have specializations of two
1758 different templates with the same type. Note that if one is a
1759 specialization, and the other is an instantiation of the same
1760 template, that we do not exit at this point. That situation
1761 can occur if we instantiate a template class, and then
1762 specialize one of its methods. This situation is valid, but
1763 the declarations must be merged in the usual way. */
1770 /* One of the declarations is a template instantiation, and the
1771 other is not a template at all. That's OK. */
1774 {
1775 /* In [namespace.alias] we have:
1777 In a declarative region, a namespace-alias-definition can be
1778 used to redefine a namespace-alias declared in that declarative
1779 region to refer only to the namespace to which it already
1780 refers.
1782 Therefore, if we encounter a second alias directive for the same
1783 alias, we can just ignore the second directive. */
1788 /* [namespace.alias]
1790 A namespace-name or namespace-alias shall not be declared as
1791 the name of any other entity in the same declarative region.
1792 A namespace-name defined at global scope shall not be
1793 declared as the name of any other entity in any global scope
1794 of the program. */
1799 }
1800 else
1801 {
1804 {
1812 }
1817 {
1818 /* Prototype decl follows defn w/o prototype. */
1823 }
1826 {
1827 /* [dcl.link]
1828 If two declarations of the same function or object
1829 specify different linkage-specifications ..., the program
1830 is ill-formed.... Except for functions with C++ linkage,
1831 a function declaration without a linkage specification
1832 shall not precede the first linkage specification for
1833 that function. A function can be declared without a
1834 linkage specification after an explicit linkage
1835 specification has been seen; the linkage explicitly
1836 specified in the earlier declaration is not affected by
1837 such a function declaration.
1839 DR 563 raises the question why the restrictions on
1840 functions should not also apply to objects. Older
1841 versions of G++ silently ignore the linkage-specification
1842 for this example:
1844 namespace N {
1845 extern int i;
1846 extern "C" int i;
1847 }
1849 which is clearly wrong. Therefore, we now treat objects
1850 like functions. */
1852 {
1853 /* There is no explicit linkage-specification, so we use
1854 the linkage from the previous declaration. */
1858 }
1859 else
1860 {
1866 }
1867 }
1870 ;
1872 {
1873 /* Note: free functions, as TEMPLATE_DECLs, are handled below. */
1876 as FUNCTION_DECLs. */
1878 /* C++11 8.3.6/6.
1879 Default arguments for a member function of a class
1880 template shall be specified on the initial declaration
1881 of the member function within the class template. */
1884 else
1885 {
1893 {
1896 {
1898 "default argument given for parameter "
1902 olddecl);
1903 }
1904 else
1905 {
1910 olddecl);
1911 }
1912 }
1913 }
1914 }
1915 }
1917 /* Do not merge an implicit typedef with an explicit one. In:
1919 class A;
1920 ...
1921 typedef class A A __attribute__ ((foo));
1923 the attribute should apply only to the typedef. */
1929 /* If new decl is `static' and an `extern' was seen previously,
1930 warn about it. */
1936 /* We have committed to returning 1 at this point. */
1938 {
1939 /* Now that functions must hold information normally held
1940 by field decls, there is extra work to do so that
1941 declaration information does not get destroyed during
1942 definition. */
1956 SET_OVERLOADED_OPERATOR_CODE
1960 /* Optionally warn about more than one declaration for the same
1961 name, but don't warn about a function declaration followed by a
1962 definition. */
1965 /* Don't warn about extern decl followed by definition. */
1967 /* Don't warn about friends, let add_friend take care of it. */
1969 /* Don't warn about declaration followed by specialization. */
1972 {
1974 OPT_Wredundant_decls,
1976 newdecl))
1979 }
1983 {
1985 {
1989 }
1991 }
1992 }
1994 /* Deal with C++: must preserve virtual function table size. */
1996 {
2006 }
2008 /* Copy all the DECL_... slots specified in the new decl
2009 except for any that we copy here from the old type. */
2014 {
2020 {
2023 }
2024 }
2027 {
2028 tree old_result;
2029 tree new_result;
2041 {
2042 /* Per C++11 8.3.6/4, default arguments cannot be added in later
2043 declarations of a function template. */
2052 {
2055 else
2067 }
2068 else
2069 {
2075 }
2076 }
2078 /* If the new declaration is a definition, update the file and
2079 line information on the declaration, and also make
2080 the old declaration the same definition. */
2082 {
2088 {
2089 tree parm;
2095 }
2096 }
2099 }
2102 {
2106 /* Automatically handles default parameters. */
2108 tree newtype;
2110 /* For typedefs use the old type, as the new type's DECL_NAME points
2111 at newdecl, which will be ggc_freed. */
2113 {
2114 /* But NEWTYPE might have an attribute, honor that. */
2119 {
2123 }
2125 /* And remove the new type from the variants list. */
2127 {
2132 {
2135 }
2136 }
2137 }
2138 else
2139 /* Merge the data types specified in the two decls. */
2143 {
2145 /* For already initialized vars, TREE_READONLY could have been
2146 cleared in cp_finish_decl, because the var needs runtime
2147 initialization or destruction. Make sure not to set
2148 TREE_READONLY on it again. */
2162 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
2165 {
2166 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
2171 }
2172 }
2174 /* An explicit specialization of a function template or of a member
2175 function of a class template can be declared transaction_safe
2176 independently of whether the corresponding template entity is declared
2177 transaction_safe. */
2190 /* Lay the type out, unless already done. */
2204 /* Merge the type qualifiers. */
2212 /* Merge deprecatedness. */
2216 /* Preserve function specific target and optimization options */
2218 {
2228 }
2230 /* Merge the initialization information. */
2233 {
2237 {
2240 }
2241 }
2244 {
2256 /* Keep the old RTL. */
2258 }
2261 {
2262 /* Keep the old RTL. We cannot keep the old RTL if the old
2263 declaration was for an incomplete object and the new
2264 declaration is not since many attributes of the RTL will
2265 change. */
2267 }
2268 }
2269 /* If cannot merge, then use the new type and qualifiers,
2270 and don't preserve the old rtl. */
2271 else
2272 {
2273 /* Clean out any memory we had of the old declaration. */
2283 }
2285 /* Merge the storage class information. */
2298 {
2307 {
2314 }
2317 {
2321 }
2326 /* If the OLDDECL is an instantiation and/or specialization,
2327 then the NEWDECL must be too. But, it may not yet be marked
2328 as such if the caller has created NEWDECL, but has not yet
2329 figured out that it is a redeclaration. */
2333 /* Don't really know how much of the language-specific
2334 values we should copy from old to new. */
2341 {
2345 {
2349 /* Remember the presence of explicit specialization args. */
2352 }
2354 }
2355 /* Only functions have these fields. */
2357 {
2362 /* DECL_THUNKS is only valid for virtual functions,
2363 otherwise it is a DECL_FRIEND_CONTEXT. */
2366 }
2367 /* Only variables have this field. */
2371 }
2374 {
2375 tree parm;
2377 /* Merge parameter attributes. */
2386 }
2390 {
2391 /* If newdecl is not a specialization, then it is not a
2392 template-related function at all. And that means that we
2393 should have exited above, returning 0. */
2397 /* From [temp.expl.spec]:
2399 If a template, a member template or the member of a class
2400 template is explicitly specialized then that
2401 specialization shall be declared before the first use of
2402 that specialization that would cause an implicit
2403 instantiation to take place, in every translation unit in
2404 which such a use occurs. */
2406 olddecl);
2412 /* Don't propagate visibility from the template to the
2413 specialization here. We'll do that in determine_visibility if
2414 appropriate. */
2417 /* [temp.expl.spec/14] We don't inline explicit specialization
2418 just because the primary template says so. */
2420 /* But still keep DECL_DISREGARD_INLINE_LIMITS in sync with
2421 the always_inline attribute. */
2424 {
2427 else
2431 }
2432 }
2434 {
2435 /* Never inline re-defined extern inline functions.
2436 FIXME: this could be better handled by keeping both
2437 function as separate declarations. */
2439 }
2440 else
2441 {
2443 {
2447 }
2449 ;
2463 }
2465 /* Preserve abstractness on cloned [cd]tors. */
2468 /* Update newdecl's parms to point at olddecl. */
2474 {
2478 }
2480 {
2481 /* These need to be copied so that the names are available.
2482 Note that if the types do match, we'll preserve inline
2483 info and other bits, but if not, we won't. */
2486 }
2487 /* If redeclaring a builtin function, it stays built in
2488 if newdecl is a gnu_inline definition, or if newdecl is just
2489 a declaration. */
2492 {
2495 /* If we're keeping the built-in definition, keep the rtl,
2496 regardless of declaration matches. */
2499 {
2502 {
2503 /* If a compatible prototype of these builtin functions
2504 is seen, assume the runtime implements it with the
2505 expected semantics. */
2514 }
2515 }
2516 }
2518 /* If defining a function declared with other language
2519 linkage, use the previously declared language linkage. */
2522 {
2524 /* Don't clear out the arguments if we're just redeclaring a
2525 function. */
2528 }
2529 }
2533 /* Now preserve various other info from the definition. */
2539 /* Warn about conflicting visibility specifications. */
2543 {
2545 "%qD: visibility attribute ignored because it "
2549 }
2550 /* Choose the declaration which specified visibility. */
2552 {
2555 }
2556 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
2557 so keep this behavior. */
2559 {
2562 }
2563 /* Likewise for DECL_ALIGN, DECL_USER_ALIGN and DECL_PACKED. */
2565 {
2568 }
2573 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
2574 with that from NEWDECL below. */
2576 {
2580 }
2582 /* Merge the USED information. */
2588 {
2593 }
2599 /* Merge the DECL_FUNCTION_VERSIONED information. newdecl will be copied
2600 to olddecl and deleted. */
2603 {
2604 /* Set the flag for newdecl so that it gets copied to olddecl. */
2606 /* newdecl will be purged after copying to olddecl and is no longer
2607 a version. */
2609 }
2612 {
2626 /* Preserve symtab node mapping. */
2630 /* If newdecl is a template instantiation, it is possible that
2631 the following sequence of events has occurred:
2633 o A friend function was declared in a class template. The
2634 class template was instantiated.
2636 o The instantiation of the friend declaration was
2637 recorded on the instantiation list, and is newdecl.
2639 o Later, however, instantiate_class_template called pushdecl
2640 on the newdecl to perform name injection. But, pushdecl in
2641 turn called duplicate_decls when it discovered that another
2642 declaration of a global function with the same name already
2643 existed.
2645 o Here, in duplicate_decls, we decided to clobber newdecl.
2647 If we're going to do that, we'd better make sure that
2648 olddecl, and not newdecl, is on the list of
2649 instantiations so that if we try to do the instantiation
2650 again we won't get the clobbered declaration. */
2652 new_template_info,
2653 olddecl);
2654 }
2655 else
2656 {
2663 {
2671 {
2684 }
2692 }
2693 }
2696 {
2700 {
2701 /* Merge the section attribute.
2702 We want to issue an error if the sections conflict but that must be
2703 done later in decl_attributes since we are called before attributes
2704 are assigned. */
2709 {
2713 else
2717 }
2718 }
2722 {
2726 }
2727 }
2733 {
2736 }
2738 /* NEWDECL contains the merged attribute lists.
2739 Update OLDDECL to be the same. */
2742 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2743 so that encode_section_info has a chance to look at the new decl
2744 flags and attributes. */
2751 /* The NEWDECL will no longer be needed. Because every out-of-class
2752 declaration of a member results in a call to duplicate_decls,
2753 freeing these nodes represents in a significant savings.
2755 Before releasing the node, be sore to remove function from symbol
2756 table that might have been inserted there to record comdat group.
2757 Be sure to however do not free DECL_STRUCT_FUNCTION because this
2758 structure is shared in between newdecl and oldecl. */
2762 {
2766 }
2768 /* Remove the associated constraints for newdecl, if any, before
2769 reclaiming memory. */
2776 }
2777 \f
2778 /* Return zero if the declaration NEWDECL is valid
2779 when the declaration OLDDECL (assumed to be for the same name)
2780 has already been seen.
2781 Otherwise return an error message format string with a %s
2782 where the identifier should go. */
2786 {
2788 {
2789 /* Because C++ can put things into name space for free,
2790 constructs like "typedef struct foo { ... } foo"
2791 would look like an erroneous redeclaration. */
2794 else
2796 }
2798 {
2799 /* If this is a pure function, its olddecl will actually be
2800 the original initialization to `0' (which we force to call
2801 abort()). Don't complain about redefinition in this case. */
2806 /* If both functions come from different namespaces, this is not
2807 a redeclaration - this is a conflict with a used function. */
2813 /* We'll complain about linkage mismatches in
2814 warn_extern_redeclared_static. */
2816 /* Defining the same name twice is no good. */
2819 {
2825 }
2828 {
2833 {
2837 else
2840 }
2841 }
2843 check_abi_tag_redeclaration
2848 }
2850 {
2854 {
2859 }
2877 {
2882 {
2886 else
2889 }
2890 }
2892 /* Core issue #226 (C++0x):
2894 If a friend function template declaration specifies a
2895 default template-argument, that declaration shall be a
2896 definition and shall be the only declaration of the
2897 function template in the translation unit. */
2908 }
2914 {
2915 /* Only variables can be thread-local, and all declarations must
2916 agree on this property. */
2920 else
2923 }
2925 {
2926 /* The objects have been declared at namespace scope. If either
2927 is a member of an anonymous union, then this is an invalid
2928 redeclaration. For example:
2930 int i;
2931 union { int i; };
2933 is invalid. */
2937 /* If at least one declaration is a reference, there is no
2938 conflict. For example:
2940 int i = 3;
2941 extern int i;
2943 is valid. */
2947 /* Static data member declared outside a class definition
2948 if the variable is defined within the class with constexpr
2949 specifier is declaration rather than definition (and
2950 deprecated). */
2955 {
2957 /* For now, only warn with explicit -Wdeprecated. */
2960 "redundant redeclaration of %<constexpr%> static "
2965 }
2967 /* Reject two definitions. */
2969 }
2970 else
2971 {
2972 /* Objects declared with block scope: */
2973 /* Reject two definitions, and reject a definition
2974 together with an external reference. */
2978 }
2979 }
2980 \f
2981 /* Hash and equality functions for the named_label table. */
2983 hashval_t
2985 {
2987 }
2989 bool
2991 {
2993 }
2995 /* Create a new label, named ID. */
2997 static tree
2999 {
3001 tree decl;
3009 /* Say where one reference is to the label, for the sake of the
3010 error if it is not defined. */
3013 /* Record the fact that this identifier is bound to this label. */
3016 /* Create the label htab for the function on demand. */
3020 /* Record this label on the list of labels used in this function.
3021 We do this before calling make_label_decl so that we get the
3022 IDENTIFIER_LABEL_VALUE before the new label is declared. */
3031 }
3033 /* Look for a label named ID in the current function. If one cannot
3034 be found, create one. (We keep track of used, but undefined,
3035 labels, and complain about them at the end of a function.) */
3037 static tree
3039 {
3040 tree decl;
3042 /* You can't use labels at global scope. */
3044 {
3047 }
3049 /* See if we've already got this label. */
3056 }
3058 /* Wrapper for lookup_label_1. */
3060 tree
3062 {
3063 tree ret;
3068 }
3070 /* Declare a local label named ID. */
3072 tree
3074 {
3075 tree decl;
3076 cp_label_binding bind;
3078 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
3079 this scope we can restore the old value of IDENTIFIER_TYPE_VALUE. */
3087 }
3089 /* Returns nonzero if it is ill-formed to jump past the declaration of
3090 DECL. Returns 2 if it's also a real problem. */
3092 static int
3094 {
3095 /* [stmt.dcl]/3: A program that jumps from a point where a local variable
3096 with automatic storage duration is not in scope to a point where it is
3097 in scope is ill-formed unless the variable has scalar type, class type
3098 with a trivial default constructor and a trivial destructor, a
3099 cv-qualified version of one of these types, or an array of one of the
3100 preceding types and is declared without an initializer (8.5). */
3115 }
3117 /* A subroutine of check_previous_goto_1 and check_goto to identify a branch
3118 to the user. */
3120 static bool
3122 diagnostic_t diag_kind)
3123 {
3124 bool complained
3130 }
3132 /* Check that a single previously seen jump to a newly defined label
3133 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
3134 the jump context; NAMES are the names in scope in LEVEL at the jump
3135 context; LOCUS is the source position of the jump or 0. Returns
3136 true if all is well. */
3138 static bool
3141 {
3148 {
3154 }
3157 {
3163 {
3169 {
3171 DK_PERMERROR);
3173 }
3175 {
3179 else
3181 " enters scope of %q#D which has "
3183 }
3184 }
3189 {
3191 {
3193 DK_ERROR);
3195 }
3197 {
3200 else
3202 }
3204 }
3206 {
3208 {
3210 DK_ERROR);
3212 }
3216 }
3218 {
3220 {
3222 DK_ERROR);
3224 }
3229 }
3232 {
3234 {
3236 DK_ERROR);
3238 }
3243 }
3244 }
3247 }
3249 static void
3251 {
3255 }
3257 static bool
3259 {
3261 }
3263 /* Check that a new jump to a label DECL is OK. Called by
3264 finish_goto_stmt. */
3266 void
3268 {
3272 tree bad;
3275 /* We can't know where a computed goto is jumping.
3276 So we assume that it's OK. */
3280 /* We didn't record any information about this label when we created it,
3281 and there's not much point since it's trivial to analyze as a return. */
3289 /* If the label hasn't been defined yet, defer checking. */
3291 {
3294 /* Don't bother creating another use if the last goto had the
3295 same data, and will therefore create the same set of errors. */
3309 }
3314 {
3322 }
3325 {
3329 {
3330 /* Can't skip init of __exception_info. */
3332 {
3336 }
3340 }
3342 {
3346 else
3348 " enters scope of %q#D which has "
3350 }
3351 }
3354 {
3363 }
3366 {
3369 }
3371 {
3374 {
3378 {
3380 {
3385 }
3389 }
3390 }
3391 }
3392 }
3394 /* Check that a return is ok wrt OpenMP structured blocks.
3395 Called by finish_return_stmt. Returns true if all is well. */
3397 bool
3399 {
3403 {
3406 }
3410 }
3412 /* Define a label, specifying the location in the source file.
3413 Return the LABEL_DECL node for the label. */
3415 static tree
3417 {
3420 tree decl;
3428 /* After labels, make any new cleanups in the function go into their
3429 own new (temporary) binding contour. */
3439 {
3442 }
3443 else
3444 {
3447 /* Mark label as having been defined. */
3449 /* Say where in the source. */
3458 }
3461 }
3463 /* Wrapper for define_label_1. */
3465 tree
3467 {
3468 tree ret;
3473 }
3476 struct cp_switch
3477 {
3480 /* The SWITCH_STMT being built. */
3481 tree switch_stmt;
3482 /* A splay-tree mapping the low element of a case range to the high
3483 element, or NULL_TREE if there is no high element. Used to
3484 determine whether or not a new case label duplicates an old case
3485 label. We need a tree, rather than simply a hash table, because
3486 of the GNU case range extension. */
3487 splay_tree cases;
3488 /* Remember whether there was a case value that is outside the
3489 range of the original type of the controlling expression. */
3491 };
3493 /* A stack of the currently active switch statements. The innermost
3494 switch statement is on the top of the stack. There is no need to
3495 mark the stack for garbage collection because it is only active
3496 during the processing of the body of a function, and we never
3497 collect at that point. */
3501 /* Called right after a switch-statement condition is parsed.
3502 SWITCH_STMT is the switch statement being parsed. */
3504 void
3506 {
3514 }
3516 void
3518 {
3520 location_t switch_location;
3522 /* Emit warnings as needed. */
3524 const bool bool_cond_p
3536 }
3538 /* Convert a case constant VALUE in a switch to the type TYPE of the switch
3539 condition. Note that if TYPE and VALUE are already integral we don't
3540 really do the conversion because the language-independent
3541 warning/optimization code will work better that way. */
3543 static tree
3545 {
3552 {
3555 value = (perform_implicit_conversion_flags
3558 }
3560 }
3562 /* Note that we've seen a definition of a case label, and complain if this
3563 is a bad place for one. */
3565 tree
3567 {
3570 tree type;
3573 {
3574 tree label;
3576 /* For templates, just add the case label; we'll do semantic
3577 analysis at instantiation-time. */
3580 }
3582 /* Find the condition on which this switch statement depends. */
3599 /* After labels, make any new cleanups in the function go into their
3600 own new (temporary) binding contour. */
3607 }
3608 \f
3610 tree scope;
3611 tree name;
3612 tree template_id;
3615 };
3618 {
3621 /* Hash a TYPENAME_TYPE. */
3623 static hashval_t
3625 {
3626 hashval_t hash;
3632 }
3634 /* Compare two TYPENAME_TYPEs. */
3636 static bool
3638 {
3644 }
3645 };
3647 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
3648 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
3650 Returns the new TYPENAME_TYPE. */
3654 static tree
3657 {
3658 tree t;
3659 tree d;
3660 typename_info ti;
3662 hashval_t hash;
3677 /* See if we already have this type. */
3681 else
3682 {
3683 /* Build the TYPENAME_TYPE. */
3690 /* Build the corresponding TYPE_DECL. */
3697 /* Store it in the hash table. */
3700 /* TYPENAME_TYPEs must always be compared structurally, because
3701 they may or may not resolve down to another type depending on
3702 the currently open classes. */
3704 }
3707 }
3709 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
3710 provided to name the type. Returns an appropriate type, unless an
3711 error occurs, in which case error_mark_node is returned. If we
3712 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
3713 return that, rather than the _TYPE it corresponds to, in other
3714 cases we look through the type decl. If TF_ERROR is set, complain
3715 about errors, otherwise be quiet. */
3717 tree
3719 tsubst_flags_t complain)
3720 {
3721 tree fullname;
3722 tree t;
3731 {
3736 else
3737 /* Create a TEMPLATE_ID_EXPR for the type. */
3741 }
3748 {
3753 {
3757 }
3758 }
3760 {
3764 }
3769 {
3773 }
3775 /* When the CONTEXT is a dependent type, NAME could refer to a
3776 dependent base class of CONTEXT. But look inside it anyway
3777 if CONTEXT is a currently open scope, in case it refers to a
3778 member of the current instantiation or a non-dependent base;
3779 lookup will stop when we hit a dependent base. */
3781 /* We should only set WANT_TYPE when we're a nested typename type.
3782 Then we can give better diagnostics if we find a non-type. */
3784 else
3793 {
3795 {
3798 else
3801 }
3803 }
3805 /* Pull out the template from an injected-class-name (or multiple). */
3810 {
3812 {
3815 }
3817 }
3820 {
3825 }
3827 {
3832 }
3837 /* If we are currently parsing a template and if T is a typedef accessed
3838 through CONTEXT then we need to remember and check access of T at
3839 template instantiation time. */
3854 }
3856 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
3857 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
3858 in which case error_mark_node is returned.
3860 If PARM_LIST is non-NULL, also make sure that the template parameter
3861 list of TEMPLATE_DECL matches.
3863 If COMPLAIN zero, don't complain about any errors that occur. */
3865 tree
3867 tsubst_flags_t complain)
3868 {
3869 tree t;
3870 tree d;
3880 {
3890 {
3894 }
3898 {
3900 {
3904 }
3906 }
3909 complain))
3913 }
3915 /* Build the UNBOUND_CLASS_TEMPLATE. */
3921 /* Build the corresponding TEMPLATE_DECL. */
3930 }
3932 \f
3934 /* Push the declarations of builtin types into the namespace.
3935 RID_INDEX is the index of the builtin type in the array
3936 RID_POINTERS. NAME is the name used when looking up the builtin
3937 type. TYPE is the _TYPE node for the builtin type. */
3939 void
3942 tree type)
3943 {
3952 /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
3953 eliminated. Built-in types should not be looked up name; their
3954 names are keywords that the parser can recognize. However, there
3955 is code in c-common.c that uses identifier_global_value to look
3956 up built-in types by name. */
3958 {
3962 }
3964 {
3966 {
3969 }
3971 }
3978 }
3980 /* Push a type into the namespace so that the back ends ignore it. */
3982 static void
3984 {
3987 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
3994 }
3996 /* A string for which we should create an IDENTIFIER_NODE at
3997 startup. */
3999 struct predefined_identifier
4000 {
4001 /* The name of the identifier. */
4003 /* The place where the IDENTIFIER_NODE should be stored. */
4005 /* Nonzero if this is the name of a constructor or destructor. */
4007 };
4009 /* Create all the predefined identifiers. */
4011 static void
4013 {
4016 /* A table of identifiers to create at startup. */
4020 /* Some of these names have a trailing space so that it is
4021 impossible for them to conflict with names written by users. */
4041 };
4044 {
4048 }
4049 }
4051 /* Create the predefined scalar types of C,
4052 and some nodes representing standard constants (0, 1, (void *)0).
4053 Initialize the global binding level.
4054 Make definitions for built-in primitive functions. */
4056 void
4058 {
4059 tree void_ftype;
4060 tree void_ftype_ptr;
4062 /* Create all the identifiers we need. */
4065 /* Create the global variables. */
4070 /* Enter the global namespace. */
4073 void_type_node);
4075 debug_hooks->register_main_translation_unit
4083 /* Initially, C. */
4086 /* Create the `std' namespace. */
4106 #if 0
4108 #endif
4117 void_ftype_ptr
4120 /* C++ extensions */
4125 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
4128 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
4129 result. */
4136 {
4137 /* Make sure we get a unique function type, so we can give
4138 its pointer type a name. (This wins for gdb.) */
4145 }
4148 vtbl_type_node
4167 /* Now, C++. */
4172 {
4175 }
4181 {
4184 tree ptr_ftype_sizetype;
4185 tree new_eh_spec;
4187 ptr_ftype_sizetype
4190 {
4191 tree bad_alloc_id;
4192 tree bad_alloc_type_node;
4193 tree bad_alloc_decl;
4199 bad_alloc_decl
4204 new_eh_spec
4206 }
4207 else
4210 /* Ensure attribs.c is initialized. */
4213 /* Ensure constraint.cc is initialized. */
4217 NULL_TREE);
4220 extvisattr);
4234 {
4235 /* Also push the sized deallocation variants:
4236 void operator delete(void*, std::size_t) throw();
4237 void operator delete[](void*, std::size_t) throw(); */
4238 tree void_ftype_ptr_size
4242 extvisattr);
4246 }
4249 {
4256 /* operator new (size_t, align_val_t); */
4268 /* operator delete (void *, align_val_t); */
4277 {
4278 /* operator delete (void *, size_t, align_val_t); */
4281 NULL_TREE);
4286 }
4287 }
4299 }
4301 abort_fndecl
4305 /* Perform other language dependent initializations. */
4319 /* Show we use EH for cleanups. */
4322 }
4324 /* Generate an initializer for a function naming variable from
4325 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
4326 filled in with the type of the init. */
4328 tree
4330 {
4332 tree type;
4337 {
4341 }
4350 else
4354 }
4356 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give
4357 the decl, LOC is the location to give the decl, NAME is the
4358 initialization string and TYPE_DEP indicates whether NAME depended
4359 on the type of the function. We make use of that to detect
4360 __PRETTY_FUNCTION__ inside a template fn. This is being done lazily
4361 at the point of first use, so we mustn't push the decl now. */
4363 static tree
4365 {
4368 tree type;
4375 /* As we're using pushdecl_with_scope, we must set the context. */
4385 {
4393 LOOKUP_ONLYCONVERTING);
4394 }
4395 else
4396 {
4399 }
4402 }
4404 static tree
4406 {
4415 /* Runtime library routines are, by definition, available in an
4416 external shared object. */
4424 else
4427 /* A function in the user's namespace should have an explicit
4428 declaration before it is used. Mark the built-in function as
4429 anticipated but not actually declared. */
4433 {
4436 /* Treat __*_chk fortification functions as anticipated as well,
4437 unless they are __builtin_*. */
4442 }
4445 }
4447 tree
4449 {
4452 /* All builtins that don't begin with an '_' should additionally
4453 go in the 'std' namespace. */
4455 {
4460 }
4463 }
4465 /* Like cxx_builtin_function, but guarantee the function is added to the global
4466 scope. This is to allow function specific options to add new machine
4467 dependent builtins when the target ISA changes via attribute((target(...)))
4468 which saves space on program startup if the program does not use non-generic
4469 ISAs. */
4471 tree
4473 {
4477 /* All builtins that don't begin with an '_' should additionally
4478 go in the 'std' namespace. */
4480 {
4485 }
4488 }
4490 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
4491 function. Not called directly. */
4493 static tree
4496 {
4503 /* Runtime library routines are, by definition, available in an
4504 external shared object. */
4509 }
4511 /* Returns the _DECL for a library function with C++ linkage. */
4513 static tree
4516 {
4521 }
4523 /* Like build_library_fn, but takes a C string instead of an
4524 IDENTIFIER_NODE. */
4526 tree
4528 {
4530 }
4532 /* Like build_cp_library_fn, but takes a C string instead of an
4533 IDENTIFIER_NODE. */
4535 tree
4537 {
4539 ecf_flags);
4540 }
4542 /* Like build_library_fn, but also pushes the function so that we will
4543 be able to find it via IDENTIFIER_GLOBAL_VALUE. Also, the function
4544 may throw exceptions listed in RAISES. */
4546 tree
4548 {
4549 tree fn;
4557 }
4559 /* Like build_cp_library_fn, but also pushes the function so that it
4560 will be found by normal lookup. */
4562 static tree
4565 {
4567 operator_code,
4573 }
4575 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
4576 a FUNCTION_TYPE. */
4578 tree
4580 {
4583 }
4585 /* Like push_library_fn, but also note that this function throws
4586 and does not return. Used for __throw_foo and the like. */
4588 tree
4590 {
4593 }
4594 \f
4595 /* When we call finish_struct for an anonymous union, we create
4596 default copy constructors and such. But, an anonymous union
4597 shouldn't have such things; this function undoes the damage to the
4598 anonymous union type T.
4600 (The reason that we create the synthesized methods is that we don't
4601 distinguish `union { int i; }' from `typedef union { int i; } U'.
4602 The first is an anonymous union; the second is just an ordinary
4603 union type.) */
4605 void
4607 {
4610 /* Wipe out memory of synthesized methods. */
4618 /* Splice the implicitly generated functions out of the TYPE_METHODS
4619 list. */
4622 {
4625 else
4627 }
4629 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
4631 {
4637 else
4640 }
4642 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
4643 assignment operators (because they cannot have these methods themselves).
4644 For anonymous unions this is already checked because they are not allowed
4645 in any union, otherwise we have to check it. */
4647 {
4652 {
4655 {
4665 }
4666 }
4667 }
4668 }
4670 /* Warn for an attribute located at LOCATION that appertains to the
4671 class type CLASS_TYPE that has not been properly placed after its
4672 class-key, in it class-specifier. */
4674 void
4676 tree class_type)
4677 {
4681 "attribute ignored in declaration "
4686 }
4688 /* Make sure that a declaration with no declarator is well-formed, i.e.
4689 just declares a tagged type or anonymous union.
4691 Returns the type declared; or NULL_TREE if none. */
4693 tree
4696 {
4699 /* If a class, struct, or enum type is declared by the DECLSPECS
4700 (i.e, if a class-specifier, enum-specifier, or non-typename
4701 elaborated-type-specifier appears in the DECLSPECS),
4702 DECLARED_TYPE is set to the corresponding type. */
4709 {
4715 }
4728 {
4730 "%<auto%> can only be specified for variables "
4733 }
4734 /* Check for an anonymous union. */
4737 {
4738 /* 7/3 In a simple-declaration, the optional init-declarator-list
4739 can be omitted only when declaring a class (clause 9) or
4740 enumeration (7.2), that is, when the decl-specifier-seq contains
4741 either a class-specifier, an elaborated-type-specifier with
4742 a class-key (9.1), or an enum-specifier. In these cases and
4743 whenever a class-specifier or enum-specifier is present in the
4744 decl-specifier-seq, the identifiers in these specifiers are among
4745 the names being declared by the declaration (as class-name,
4746 enum-names, or enumerators, depending on the syntax). In such
4747 cases, and except for the declaration of an unnamed bit-field (9.6),
4748 the decl-specifier-seq shall introduce one or more names into the
4749 program, or shall redeclare a name introduced by a previous
4750 declaration. [Example:
4751 enum { }; // ill-formed
4752 typedef class { }; // ill-formed
4753 --end example] */
4755 {
4758 }
4765 }
4767 else
4768 {
4776 && (!current_class_type
4785 "a storage class can only be specified for objects "
4789 "%<const%> can only be specified for objects and "
4793 "%<volatile%> can only be specified for objects and "
4797 "%<__restrict%> can only be specified for objects and "
4801 "%<__thread%> can only be specified for objects "
4809 }
4812 {
4813 location_t loc;
4816 /* For a non-template class, use the name location. */
4818 else
4819 /* For a template class (an explicit instantiation), use the
4820 current location. */
4824 /* [dcl.attr.grammar]/4:
4826 No attribute-specifier-seq shall appertain to an explicit
4827 instantiation. */
4828 {
4831 declared_type))
4833 "no attribute can be applied to "
4835 }
4836 else
4838 }
4841 }
4843 /* Called when a declaration is seen that contains no names to declare.
4844 If its type is a reference to a structure, union or enum inherited
4845 from a containing scope, shadow that tag name for the current scope
4846 with a forward reference.
4847 If its type defines a new named structure or union
4848 or defines an enum, it is valid but we need not do anything here.
4849 Otherwise, it is an error.
4851 C++: may have to grok the declspecs to learn about static,
4852 complain for anonymous unions.
4854 Returns the TYPE declared -- or NULL_TREE if none. */
4856 tree
4858 {
4868 /* This is where the variables in an anonymous union are
4869 declared. An anonymous union declaration looks like:
4870 union { ... } ;
4871 because there is no declarator after the union, the parser
4872 sends that declaration here. */
4874 {
4878 {
4882 }
4883 }
4886 }
4887 \f
4888 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
4890 tree
4894 {
4895 tree attrs;
4896 tree type;
4897 enum decl_context context
4903 {
4908 /* A template type parameter or other dependent type. */
4911 else
4913 }
4915 }
4917 /* Process a DECLARATOR for a function-scope variable declaration,
4918 namespace-scope variable declaration, or function declaration.
4919 (Function definitions go through start_function; class member
4920 declarations appearing in the body of the class go through
4921 grokfield.) The DECL corresponding to the DECLARATOR is returned.
4922 If an error occurs, the error_mark_node is returned instead.
4924 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED is
4925 SD_INITIALIZED if an explicit initializer is present, or SD_DEFAULTED
4926 for an explicitly defaulted function, or SD_DELETED for an explicitly
4927 deleted function, but 0 (SD_UNINITIALIZED) if this is a variable
4928 implicitly initialized via a default constructor. ATTRIBUTES and
4929 PREFIX_ATTRIBUTES are GNU attributes associated with this declaration.
4931 The scope represented by the context of the returned DECL is pushed
4932 (if it is not the global namespace) and is assigned to
4933 *PUSHED_SCOPE_P. The caller is then responsible for calling
4934 pop_scope on *PUSHED_SCOPE_P if it is set. */
4936 tree
4940 tree attributes,
4941 tree prefix_attributes,
4943 {
4944 tree decl;
4945 tree context;
4952 /* An object declared as __attribute__((deprecated)) suppresses
4953 warnings of uses of other deprecated items. */
4972 /* Is it valid for this decl to have an initializer at all?
4973 If not, set INITIALIZED to zero, which will indirectly
4974 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
4977 {
4980 }
4983 {
4987 decl);
4991 }
4997 /* If this is a typedef that names the class for linkage purposes
4998 (7.1.3p8), apply any attributes directly to the type. */
5003 else
5006 /* Set attributes here so if duplicate decl, will have proper attributes. */
5009 /* Dllimported symbols cannot be defined. Static data members (which
5010 can be initialized in-class and dllimported) go through grokfield,
5011 not here, so we don't need to exclude those decls when checking for
5012 a definition. */
5014 {
5017 }
5019 /* If #pragma weak was used, mark the decl weak now. */
5031 {
5035 {
5041 {
5045 else
5046 {
5052 }
5053 }
5054 else
5055 {
5060 {
5067 }
5068 /* Static data member are tricky; an in-class initialization
5069 still doesn't provide a definition, so the in-class
5070 declaration will have DECL_EXTERNAL set, but will have an
5071 initialization. Thus, duplicate_decls won't warn
5072 about this situation, and so we check here. */
5080 }
5081 }
5082 else
5083 {
5085 this_tmpl
5086 ? current_template_parms
5092 }
5094 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
5096 /* Do not mark DECL as an explicit specialization if it was not
5097 already marked as an instantiation; a declaration should
5098 never be marked as a specialization unless we know what
5099 template is being specialized. */
5101 {
5106 else
5109 /* [temp.expl.spec] An explicit specialization of a static data
5110 member of a template is a definition if the declaration
5111 includes an initializer; otherwise, it is a declaration.
5113 We check for processing_specialization so this only applies
5114 to the new specialization syntax. */
5117 }
5120 /* Aliases are definitions. */
5123 decl);
5124 }
5128 /* Enter this declaration into the symbol table. Don't push the plain
5129 VAR_DECL for a variable template. */
5142 {
5143 /* This is a const variable with implicit 'static'. Set
5144 DECL_THIS_STATIC so we can tell it from variables that are
5145 !TREE_PUBLIC because of the anonymous namespace. */
5148 }
5152 {
5156 decl);
5159 else
5163 }
5169 }
5171 /* Process the declaration of a variable DECL. INITIALIZED is true
5172 iff DECL is explicitly initialized. (INITIALIZED is false if the
5173 variable is initialized via an implicitly-called constructor.)
5174 This function must be called for ordinary variables (including, for
5175 example, implicit instantiations of templates), but must not be
5176 called for template declarations. */
5178 void
5180 {
5181 tree type;
5196 /* If an explicit initializer is present, or if this is a definition
5197 of an aggregate, then we need a complete type at this point.
5198 (Scalars are always complete types, so there is nothing to
5199 check.) This code just sets COMPLETE_P; errors (if necessary)
5200 are issued below. */
5202 && !complete_p
5204 {
5206 /* We will not yet have set TREE_READONLY on DECL if the type
5207 was "const", but incomplete, before this point. But, now, we
5208 have a complete type, so we can try again. */
5210 }
5213 /* Is it valid for this decl to have an initializer at all? */
5214 {
5215 /* Don't allow initializations for incomplete types except for
5216 arrays which might be completed by the initialization. */
5222 {
5225 }
5227 {
5230 /* else we already gave an error in start_decl. */
5231 }
5232 }
5234 {
5237 else
5239 decl);
5240 /* Change the type so that assemble_variable will give
5241 DECL an rtl we can live with: (mem (const_int 0)). */
5243 }
5245 /* Create a new scope to hold this declaration if necessary.
5246 Whether or not a new scope is necessary cannot be determined
5247 until after the type has been completed; if the type is a
5248 specialization of a class template it is not until after
5249 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
5250 will be set correctly. */
5252 }
5254 /* Handle initialization of references. DECL, TYPE, and INIT have the
5255 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
5256 but will be set to a new CLEANUP_STMT if a temporary is created
5257 that must be destroyed subsequently.
5259 Returns an initializer expression to use to initialize DECL, or
5260 NULL if the initialization can be performed statically.
5262 Quotes on semantics can be found in ARM 8.4.3. */
5264 static tree
5266 {
5268 {
5274 }
5278 tf_warning_or_error);
5283 /* Note: default conversion is only called in very special cases. */
5286 /* check_initializer handles this for non-reference variables, but for
5287 references we need to do it here or the initializer will get the
5288 incomplete array type and confuse later calls to
5289 cp_complete_array_type. */
5294 {
5298 }
5300 /* Convert INIT to the reference type TYPE. This may involve the
5301 creation of a temporary, whose lifetime must be the same as that
5302 of the reference. If so, a DECL_EXPR for the temporary will be
5303 added just after the DECL_EXPR for DECL. That's why we don't set
5304 DECL_INITIAL for local references (instead assigning to them
5305 explicitly); we need to allow the temporary to be initialized
5306 first. */
5308 tf_warning_or_error);
5309 }
5311 /* Designated initializers in arrays are not supported in GNU C++.
5312 The parser cannot detect this error since it does not know whether
5313 a given brace-enclosed initializer is for a class type or for an
5314 array. This function checks that CE does not use a designated
5315 initializer. If it does, an error is issued. Returns true if CE
5316 is valid, i.e., does not have a designated initializer. */
5318 static bool
5321 {
5322 /* Designated initializers for array elements are not supported. */
5324 {
5325 /* The parser only allows identifiers as designated
5326 initializers. */
5328 {
5332 }
5334 {
5338 }
5346 {
5347 /* A C99 designator is OK if it matches the current index. */
5350 else
5352 }
5353 else
5358 }
5361 }
5363 /* When parsing `int a[] = {1, 2};' we don't know the size of the
5364 array until we finish parsing the initializer. If that's the
5365 situation we're in, update DECL accordingly. */
5367 static void
5369 {
5375 {
5376 /* do_default is really a C-ism to deal with tentative definitions.
5377 But let's leave it here to ease the eventual merge. */
5382 /* Check that there are no designated initializers in INIT, as
5383 those are not supported in GNU C++, and as the middle-end
5384 will crash if presented with a non-numeric designated
5385 initializer. */
5387 {
5390 HOST_WIDE_INT i;
5394 }
5397 {
5399 do_default);
5401 {
5405 }
5407 {
5409 {
5412 }
5413 /* If a `static' var's size isn't known, make it extern as
5414 well as static, so it does not get allocated. If it's not
5415 `static', then don't mark it extern; finish_incomplete_decl
5416 will give it a default size and it will get allocated. */
5419 }
5421 {
5424 }
5425 }
5430 }
5431 }
5433 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
5434 any appropriate error messages regarding the layout. */
5436 static void
5438 {
5439 tree type;
5445 /* If we haven't already laid out this declaration, do so now.
5446 Note that we must not call complete type for an external object
5447 because it's type might involve templates that we are not
5448 supposed to instantiate yet. (And it's perfectly valid to say
5449 `extern X x' for some incomplete type `X'.) */
5458 {
5459 /* An automatic variable with an incomplete type: that is an error.
5460 Don't talk about array types here, since we took care of that
5461 message in grokdeclarator. */
5465 }
5466 #if 0
5467 /* Keep this code around in case we later want to control debug info
5468 based on whether a type is "used". (jason 1999-11-11) */
5471 /* Let debugger know it should output info for this type. */
5476 #endif
5481 {
5484 else
5485 {
5489 }
5490 }
5491 }
5493 /* If a local static variable is declared in an inline function, or if
5494 we have a weak definition, we must endeavor to create only one
5495 instance of the variable at link-time. */
5497 void
5499 {
5500 /* Static data in a function with comdat linkage also has comdat
5501 linkage. */
5503 /* Don't mess with __FUNCTION__. */
5508 {
5510 {
5511 /* With weak symbols, we simply make the variable COMDAT;
5512 that will cause copies in multiple translations units to
5513 be merged. */
5515 }
5516 else
5517 {
5520 {
5521 /* Without weak symbols, we can use COMMON to merge
5522 uninitialized variables. */
5525 }
5526 else
5527 {
5528 /* While for initialized variables, we must use internal
5529 linkage -- which means that multiple copies will not
5530 be merged. */
5536 "%q#D are wrong (you%'ll wind up with "
5538 else
5540 "static data %q#D are wrong (you%'ll wind "
5546 }
5547 }
5548 }
5549 }
5551 /* Issue an error message if DECL is an uninitialized const variable. */
5553 static void
5555 {
5558 /* ``Unless explicitly declared extern, a const object does not have
5559 external linkage and must be initialized. ($8.4; $12.1)'' ARM
5560 7.1.6 */
5565 {
5573 else
5574 {
5577 decl);
5579 }
5582 {
5583 tree defaulted_ctor;
5590 "constructor is not user-provided because it is "
5593 "and the implicitly-defined constructor does not "
5595 }
5596 }
5597 }
5598 \f
5599 /* Structure holding the current initializer being processed by reshape_init.
5600 CUR is a pointer to the current element being processed, END is a pointer
5601 after the last element present in the initializer. */
5602 struct reshape_iter
5603 {
5606 };
5610 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
5611 returned is the next FIELD_DECL (possibly FIELD itself) that can be
5612 initialized. If there are no more such fields, the return value
5613 will be NULL. */
5615 tree
5617 {
5626 }
5628 /* Return true for [dcl.init.list] direct-list-initialization from
5629 single element of enumeration with a fixed underlying type. */
5631 bool
5633 {
5642 }
5644 /* Subroutine of reshape_init_array and reshape_init_vector, which does
5645 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
5646 INTEGER_CST representing the size of the array minus one (the maximum index),
5647 or NULL_TREE if the array was declared without specifying the size. D is
5648 the iterator within the constructor. */
5650 static tree
5652 tsubst_flags_t complain)
5653 {
5654 tree new_init;
5659 /* The initializer for an array is always a CONSTRUCTOR. */
5663 {
5664 /* Minus 1 is used for zero sized arrays. */
5670 /* sizetype is sign extended, not zero extended. */
5671 else
5673 }
5675 /* Loop until there are no more initializers. */
5679 {
5680 tree elt_init;
5685 complain);
5693 /* This can happen with an invalid initializer (c++/54501). */
5696 }
5699 }
5701 /* Subroutine of reshape_init_r, processes the initializers for arrays.
5702 Parameters are the same of reshape_init_r. */
5704 static tree
5706 {
5715 }
5717 /* Subroutine of reshape_init_r, processes the initializers for vectors.
5718 Parameters are the same of reshape_init_r. */
5720 static tree
5722 {
5728 {
5731 {
5736 }
5739 }
5741 /* For a vector, we initialize it as an array of the appropriate size. */
5746 }
5748 /* Subroutine of reshape_init_r, processes the initializers for classes
5749 or union. Parameters are the same of reshape_init_r. */
5751 static tree
5753 tsubst_flags_t complain)
5754 {
5755 tree field;
5756 tree new_init;
5760 /* The initializer for a class is always a CONSTRUCTOR. */
5765 {
5766 /* [dcl.init.aggr]
5768 An initializer for an aggregate member that is an
5769 empty class shall have the form of an empty
5770 initializer-list {}. */
5772 {
5776 }
5778 }
5780 /* Loop through the initializable fields, gathering initializers. */
5782 {
5783 tree field_init;
5786 /* Handle designated initializers, as an extension. */
5788 {
5793 /* We already reshaped this. */
5797 else
5798 {
5803 }
5806 {
5811 }
5812 }
5814 /* If we processed all the member of the class, we are done. */
5824 {
5825 /* This can happen with an invalid initializer for a flexible
5826 array member (c++/54441). */
5830 }
5834 /* [dcl.init.aggr]
5836 When a union is initialized with a brace-enclosed
5837 initializer, the braces shall only contain an
5838 initializer for the first member of the union. */
5843 }
5846 }
5848 /* Subroutine of reshape_init_r. We're in a context where C99 initializer
5849 designators are not valid; either complain or return true to indicate
5850 that reshape_init_r should return error_mark_node. */
5852 static bool
5854 {
5856 {
5860 else
5862 }
5864 }
5866 /* Subroutine of reshape_init, which processes a single initializer (part of
5867 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
5868 iterator within the CONSTRUCTOR which points to the initializer to process.
5869 FIRST_INITIALIZER_P is true if this is the first initializer of the
5870 outermost CONSTRUCTOR node. */
5872 static tree
5874 tsubst_flags_t complain)
5875 {
5886 {
5887 /* A complex type can be initialized from one or two initializers,
5888 but braces are not elided. */
5891 {
5893 {
5896 else
5898 }
5899 }
5901 {
5909 }
5911 }
5913 /* A non-aggregate type is always initialized with a single
5914 initializer. */
5916 {
5917 /* It is invalid to initialize a non-aggregate type with a
5918 brace-enclosed initializer before C++0x.
5919 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
5920 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
5921 a CONSTRUCTOR (with a record type). */
5923 /* Don't complain about a capture-init. */
5926 {
5928 {
5930 /* Isn't value-initialization. */
5932 {
5935 type);
5937 }
5938 }
5939 else
5941 }
5945 }
5947 /* "If T is a class type and the initializer list has a single element of
5948 type cv U, where U is T or a class derived from T, the object is
5949 initialized from that element." Even if T is an aggregate. */
5951 && first_initializer_p
5954 {
5957 }
5959 /* [dcl.init.aggr]
5961 All implicit type conversions (clause _conv_) are considered when
5962 initializing the aggregate member with an initializer from an
5963 initializer-list. If the initializer can initialize a member,
5964 the member is initialized. Otherwise, if the member is itself a
5965 non-empty subaggregate, brace elision is assumed and the
5966 initializer is considered for the initialization of the first
5967 member of the subaggregate. */
5969 /* But don't try this for the first initializer, since that would be
5970 looking through the outermost braces; A a2 = { a1 }; is not a
5971 valid aggregate initialization. */
5972 && !first_initializer_p
5975 complain)))
5976 {
5979 }
5981 /* [dcl.init.string]
5983 A char array (whether plain char, signed char, or unsigned char)
5984 can be initialized by a string-literal (optionally enclosed in
5985 braces); a wchar_t array can be initialized by a wide
5986 string-literal (optionally enclosed in braces). */
5989 {
5992 /* Strip one level of braces if and only if they enclose a single
5993 element (as allowed by [dcl.init.string]). */
5997 {
5999 }
6001 /* If it's a string literal, then it's the initializer for the array
6002 as a whole. Otherwise, continue with normal initialization for
6003 array types (one value per array element). */
6005 {
6010 }
6011 }
6013 /* The following cases are about aggregates. If we are not within a full
6014 initializer already, and there is not a CONSTRUCTOR, it means that there
6015 is a missing set of braces (that is, we are processing the case for
6016 which reshape_init exists). */
6018 {
6020 {
6022 /* There is no need to reshape pointer-to-member function
6023 initializers, as they are always constructed correctly
6024 by the front end. */
6025 ;
6027 /* For a nested compound literal, there is no need to reshape since
6028 brace elision is not allowed. Even if we decided to allow it,
6029 we should add a call to reshape_init in finish_compound_literal,
6030 before calling digest_init, so changing this code would still
6031 not be necessary. */
6033 else
6034 {
6038 }
6039 }
6044 type);
6045 }
6047 /* Dispatch to specialized routines. */
6054 else
6056 }
6058 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
6059 brace-enclosed aggregate initializer.
6061 INIT is the CONSTRUCTOR containing the list of initializers describing
6062 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
6063 It may not presently match the shape of the TYPE; for example:
6065 struct S { int a; int b; };
6066 struct S a[] = { 1, 2, 3, 4 };
6068 Here INIT will hold a vector of four elements, rather than a
6069 vector of two elements, each itself a vector of two elements. This
6070 routine transforms INIT from the former form into the latter. The
6071 revised CONSTRUCTOR node is returned. */
6073 tree
6075 {
6077 reshape_iter d;
6078 tree new_init;
6084 /* An empty constructor does not need reshaping, and it is always a valid
6085 initializer. */
6089 /* Handle [dcl.init.list] direct-list-initialization from
6090 single element of enumeration with a fixed underlying type. */
6092 {
6096 else
6098 }
6100 /* Recurse on this CONSTRUCTOR. */
6108 /* Make sure all the element of the constructor were used. Otherwise,
6109 issue an error about exceeding initializers. */
6111 {
6114 else
6116 }
6123 }
6125 /* Verify array initializer. Returns true if errors have been reported. */
6127 bool
6129 {
6132 /* The array type itself need not be complete, because the
6133 initializer may tell us how many elements are in the array.
6134 But, the elements of the array must be complete. */
6136 {
6140 else
6143 }
6144 /* A compound literal can't have variable size. */
6148 {
6151 }
6153 }
6155 /* Subroutine of check_initializer; args are passed down from that function.
6156 Set stmts_are_full_exprs_p to 1 across a call to build_aggr_init. */
6158 static tree
6161 {
6164 }
6166 /* Verify INIT (the initializer for DECL), and record the
6167 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
6168 grok_reference_init.
6170 If the return value is non-NULL, it is an expression that must be
6171 evaluated dynamically to initialize DECL. */
6173 static tree
6175 {
6178 tree core_type;
6180 /* Things that are going to be initialized need to have complete
6181 type. */
6185 {
6186 /* A variable with DECL_HAS_VALUE_EXPR_P set is just a placeholder,
6187 it doesn't have storage to be initialized. */
6190 }
6193 /* We will have already complained. */
6197 {
6200 }
6202 {
6207 }
6208 else
6209 /* There is no way to make a variable-sized class type in GNU C++. */
6213 {
6216 {
6218 {
6221 }
6223 {
6225 "scalar object %qD requires one element in "
6229 }
6230 }
6231 }
6234 {
6241 }
6243 ;
6246 {
6248 {
6251 }
6254 /* Do not reshape constructors of vectors (they don't need to be
6255 reshaped. */
6257 {
6259 {
6261 tf_warning_or_error);
6263 }
6265 {
6266 /* Don't reshape if the class has constructors. */
6269 "in C++98 %qD must be initialized by "
6271 decl);
6272 }
6274 {
6277 }
6278 else
6279 {
6282 }
6283 }
6287 {
6290 /* We get here with code like `int a (2);' */
6292 tf_warning_or_error);
6293 }
6295 /* If DECL has an array type without a specific bound, deduce the
6296 array size from the initializer. */
6310 {
6313 /* A constructor call is a non-trivial initializer even if
6314 it isn't explicitly written. */
6318 /* If this is a constexpr initializer, expand_default_init will
6319 have returned an INIT_EXPR rather than a CALL_EXPR. In that
6320 case, pull the initializer back out and pass it down into
6321 store_init_value. */
6326 {
6329 /* Don't call digest_init; it's unnecessary and will complain
6330 about aggregate initialization of non-aggregate classes. */
6332 }
6334 {
6335 /* Declared constexpr, but no suitable initializer; massage
6336 init appropriately so we can pass it into store_init_value
6337 for the error. */
6340 {
6344 }
6346 }
6347 else
6349 }
6352 {
6353 /* In aggregate initialization of a variable, each element
6354 initialization is a full-expression because there is no
6355 enclosing expression. */
6370 }
6371 }
6372 else
6373 {
6381 }
6387 {
6388 /* We might have set these in cp_finish_decl. */
6391 }
6395 {
6403 else
6407 {
6411 }
6413 }
6416 }
6418 /* If DECL is not a local variable, give it RTL. */
6420 static void
6422 {
6426 /* Set the DECL_ASSEMBLER_NAME for the object. */
6428 {
6429 /* The `register' keyword, when used together with an
6430 asm-specification, indicates that the variable should be
6431 placed in a particular register. */
6433 {
6436 }
6437 else
6438 {
6443 }
6444 }
6446 /* Handle non-variables up front. */
6448 {
6451 }
6453 /* If we see a class member here, it should be a static data
6454 member. */
6456 {
6458 /* An in-class declaration of a static data member should be
6459 external; it is only a declaration, and not a definition. */
6464 }
6466 /* We don't create any RTL for local variables. */
6470 /* We defer emission of local statics until the corresponding
6471 DECL_EXPR is expanded. But with constexpr its function might never
6472 be expanded, so go ahead and tell cgraph about the variable now. */
6477 /* Defer template instantiations. */
6482 /* If we're not deferring, go ahead and assemble the variable. */
6485 }
6487 /* walk_tree helper for wrap_temporary_cleanups, below. */
6489 static tree
6491 {
6492 /* Stop at types or full-expression boundaries. */
6495 {
6498 }
6501 {
6506 /* Tell honor_protect_cleanup_actions to handle this as a separate
6507 cleanup. */
6511 }
6514 }
6516 /* We're initializing a local variable which has a cleanup GUARD. If there
6517 are any temporaries used in the initializer INIT of this variable, we
6518 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
6519 variable will be cleaned up properly if one of them throws.
6521 Unfortunately, there's no way to express this properly in terms of
6522 nesting, as the regions for the temporaries overlap the region for the
6523 variable itself; if there are two temporaries, the variable needs to be
6524 the first thing destroyed if either of them throws. However, we only
6525 want to run the variable's cleanup if it actually got constructed. So
6526 we need to guard the temporary cleanups with the variable's cleanup if
6527 they are run on the normal path, but not if they are run on the
6528 exceptional path. We implement this by telling
6529 honor_protect_cleanup_actions to strip the variable cleanup from the
6530 exceptional path. */
6532 static void
6534 {
6536 }
6538 /* Generate code to initialize DECL (a local variable). */
6540 static void
6542 {
6544 tree cleanup;
6552 {
6553 /* If we used it already as memory, it must stay in memory. */
6557 }
6562 /* Compute and store the initial value. */
6567 /* Generate a cleanup, if necessary. */
6570 /* Perform the initialization. */
6572 {
6576 {
6577 /* Stick simple initializers in DECL_INITIAL so that
6578 -Wno-init-self works (c++/34772). */
6583 {
6587 OPT_Winit_self,
6589 }
6590 }
6591 else
6592 {
6595 /* If we're only initializing a single object, guard the
6596 destructors of any temporaries used in its initializer with
6597 its destructor. This isn't right for arrays because each
6598 element initialization is a full-expression. */
6607 saved_stmts_are_full_exprs_p;
6608 }
6609 }
6611 /* Set this to 0 so we can tell whether an aggregate which was
6612 initialized was ever used. Don't do this if it has a
6613 destructor, so we don't complain about the 'resource
6614 allocation is initialization' idiom. Now set
6615 attribute((unused)) on types so decls of that type will be
6616 marked used. (see TREE_USED, above.) */
6618 && ! already_used
6627 }
6629 /* DECL is a VAR_DECL for a compiler-generated variable with static
6630 storage duration (like a virtual table) whose initializer is a
6631 compile-time constant. Initialize the variable and provide it to the
6632 back end. */
6634 void
6636 {
6637 tree init;
6647 }
6649 /* INIT is the initializer for a variable, as represented by the
6650 parser. Returns true iff INIT is type-dependent. */
6652 static bool
6654 {
6656 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
6659 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
6660 {
6670 }
6671 else
6672 /* It must be a simple expression, e.g., int i = 3; */
6676 }
6678 /* INIT is the initializer for a variable, as represented by the
6679 parser. Returns true iff INIT is value-dependent. */
6681 static bool
6683 {
6685 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
6688 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
6689 {
6699 }
6700 else
6701 /* It must be a simple expression, e.g., int i = 3; */
6705 }
6707 // Returns true if a DECL is VAR_DECL with the concept specifier.
6710 {
6712 // Not all variables have DECL_LANG_SPECIFIC.
6715 }
6717 /* A helper function to be called via walk_tree. If any label exists
6718 under *TP, it is (going to be) forced. Set has_forced_label_in_static. */
6720 static tree
6722 {
6728 }
6730 /* Finish processing of a declaration;
6731 install its line number and initial value.
6732 If the length of an array type is not known before,
6733 it must be determined now, from the initial value, or it is an error.
6735 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
6736 true, then INIT is an integral constant expression.
6738 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
6739 if the (init) syntax was used. */
6741 void
6744 {
6745 tree type;
6750 tree auto_node;
6755 {
6759 }
6762 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
6769 /* Warn about register storage specifiers except when in GNU global
6770 or local register variable extension. */
6772 {
6775 "ISO C++1z does not allow %<register%> storage "
6777 else
6780 }
6782 /* If a name was specified, get the string. */
6797 {
6798 tree d_init;
6800 {
6804 {
6805 /* init is null because we're deferring instantiating the
6806 initializer until we need it. Well, we need it now. */
6809 }
6812 }
6817 tf_warning_or_error);
6827 {
6832 }
6834 }
6845 {
6846 tree clone;
6848 {
6849 /* FIXME check this is 1st decl. */
6854 {
6858 }
6860 }
6862 {
6865 else
6867 }
6868 }
6871 {
6873 /* If DECL is a reference, then we want to know whether init is a
6874 reference constant; init_const_expr_p as passed tells us whether
6875 it's an rvalue constant. */
6879 {
6880 /* Set these flags now for templates. We'll update the flags in
6881 store_init_value for instantiations. */
6884 /* FIXME setting TREE_CONSTANT on refs breaks the back end. */
6887 }
6888 }
6891 {
6894 /* Add this declaration to the statement-tree. */
6901 {
6904 }
6906 /* Generally, initializers in templates are expanded when the
6907 template is instantiated. But, if DECL is a variable constant
6908 then it can be used in future constant expressions, so its value
6909 must be available. */
6914 && init_const_expr_p
6919 {
6920 /* This variable seems to be a non-dependent constant, so process
6921 its initializer. If check_initializer returns non-null the
6922 initialization wasn't constant after all. */
6923 tree init_code;
6929 }
6933 {
6934 /* Deduce array size even if the initializer is dependent. */
6936 /* And complain about multiple initializers. */
6940 tf_warning_or_error);
6941 }
6946 }
6948 /* Just store non-static data member initializers for later. */
6952 /* Take care of TYPE_DECLs up front. */
6954 {
6957 {
6961 }
6963 /* If we have installed this as the canonical typedef for this
6964 type, and that type has not been defined yet, delay emitting
6965 the debug information for it, as we will emit it later. */
6971 at_eof);
6973 }
6975 /* A reference will be modified here, as it is initialized. */
6979 {
6982 }
6985 {
6986 /* If this is a local variable that will need a mangled name,
6987 register it now. We must do this before processing the
6988 initializer for the variable, since the initialization might
6989 require a guard variable, and since the mangled name of the
6990 guard variable will depend on the mangled name of this
6991 variable. */
6995 {
6997 /* Normally has_forced_label_in_static is set during GIMPLE
6998 lowering, but [cd]tors are never actually compiled directly.
6999 We need to set this early so we can deal with the label
7000 address extension. */
7004 {
7007 }
7008 /* And make sure it's in the symbol table for
7009 c_parse_final_cleanups to find. */
7011 }
7013 /* Convert the initializer to the type of DECL, if we have not
7014 already initialized DECL. */
7016 /* If !DECL_EXTERNAL then DECL is being defined. In the
7017 case of a static data member initialized inside the
7018 class-specifier, there can be an initializer even if DECL
7019 is *not* defined. */
7021 {
7025 /* Handle:
7027 [dcl.init]
7029 The memory occupied by any object of static storage
7030 duration is zero-initialized at program startup before
7031 any other initialization takes place.
7033 We cannot create an appropriate initializer until after
7034 the type of DECL is finalized. If DECL_INITIAL is set,
7035 then the DECL is statically initialized, and any
7036 necessary zero-initialization has already been performed. */
7041 /* Remember that the initialization for this variable has
7042 taken place. */
7044 /* This declaration is the definition of this variable,
7045 unless we are initializing a static data member within
7046 the class specifier. */
7049 }
7050 /* If the variable has an array type, lay out the type, even if
7051 there is no initializer. It is valid to index through the
7052 array, and we must get TYPE_ALIGN set correctly on the array
7053 type. */
7060 /* So decl is a global variable or a static member of a
7061 non local class. Record the types it uses
7062 so that we can decide later to emit debug info for them. */
7064 }
7066 /* Add this declaration to the statement-tree. This needs to happen
7067 after the call to check_initializer so that the DECL_EXPR for a
7068 reference temp is added before the DECL_EXPR for the reference itself. */
7070 {
7071 /* If we're building a variable sized type, and we might be
7072 reachable other than via the top of the current binding
7073 level, then create a new BIND_EXPR so that we deallocate
7074 the object at the right time. */
7079 {
7080 tree bind;
7085 }
7087 }
7089 /* Let the middle end know about variables and functions -- but not
7090 static data members in uninstantiated class templates. */
7092 {
7094 {
7097 }
7099 /* This needs to happen after the linkage is set. */
7103 {
7104 /* If a TREE_READONLY variable needs initialization
7105 at runtime, it is no longer readonly and we need to
7106 avoid MEM_READONLY_P being set on RTL created for it. */
7108 {
7112 }
7116 /* Likewise if it needs destruction. */
7119 }
7123 /* Check for abstractness of the type. Notice that there is no
7124 need to strip array types here since the check for those types
7125 is already done within create_array_type_for_decl. */
7129 /* No initialization required. */
7130 ;
7132 {
7134 {
7136 {
7137 /* An out-of-class default definition is defined at
7138 the point where it is explicitly defaulted. */
7143 }
7144 else
7146 }
7147 /* else no initialization required. */
7148 }
7152 {
7155 }
7156 /* A variable definition. */
7158 /* Initialize the local variable. */
7161 /* If a variable is defined, and then a subsequent
7162 definition with external linkage is encountered, we will
7163 get here twice for the same variable. We want to avoid
7164 calling expand_static_init more than once. For variables
7165 that are not static data members, we can call
7166 expand_static_init only when we actually process the
7167 initializer. It is not legal to redeclare a static data
7168 member, so this issue does not arise in that case. */
7171 }
7173 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
7174 reference, insert it in the statement-tree now. */
7176 {
7181 }
7187 }
7189 /* For class TYPE return itself or some its bases that contain
7190 any direct non-static data members. Return error_mark_node if an
7191 error has been diagnosed. */
7193 static tree
7195 {
7203 {
7207 else
7212 }
7214 {
7221 }
7222 else
7232 {
7237 {
7239 {
7244 }
7248 /* OK, found the same base along another path. We'll complain
7251 {
7253 "classes %qT and %qT have non-static data "
7256 }
7257 else
7259 }
7260 }
7262 }
7264 /* Return std::tuple_size<TYPE>::value. */
7266 static tree
7268 {
7284 else
7286 }
7288 /* Return std::tuple_element<I,TYPE>::type. */
7290 static tree
7292 {
7300 tf_warning_or_error);
7303 }
7305 /* Return e.get<i>() or get<i>(e). */
7307 static tree
7309 {
7317 /* [The id-expression] e is an lvalue if the type of the entity e is an
7318 lvalue reference and an xvalue otherwise. */
7326 {
7331 }
7332 else
7333 {
7339 }
7340 }
7342 /* It's impossible to recover the decltype of a tuple decomposition variable
7343 based on the actual type of the variable, so store it in a hash table. */
7345 static void
7347 {
7351 }
7353 tree
7355 {
7357 }
7359 /* Finish a decomposition declaration. DECL is the underlying declaration
7360 "e", FIRST is the head of a chain of decls for the individual identifiers
7361 chained through DECL_CHAIN in reverse order and COUNT is the number of
7362 those decls. */
7364 void
7366 {
7368 {
7369 error_out:
7371 {
7374 {
7377 }
7379 }
7383 }
7387 /* This happens for range for when not in templates.
7388 Still add the DECL_VALUE_EXPRs for later processing. */
7389 || (!processing_template_decl
7391 {
7393 {
7395 {
7401 }
7403 {
7406 }
7408 }
7410 }
7416 {
7420 }
7426 {
7427 /* If e is a constant reference, use the referent directly. */
7432 }
7437 {
7438 tree nelts;
7443 {
7446 }
7449 {
7450 cnt_mismatch:
7454 else
7458 }
7461 {
7467 NULL_TREE);
7470 }
7471 }
7472 /* 2 GNU extensions. */
7474 {
7480 {
7486 t);
7489 }
7490 }
7492 {
7498 {
7506 NULL_TREE);
7509 }
7510 }
7512 {
7514 {
7518 }
7523 {
7534 {
7538 }
7539 /* Save the decltype away before reference collapse. */
7545 {
7546 /* In this case the names are variables, not just proxies. */
7549 }
7552 }
7553 }
7555 {
7558 }
7560 {
7563 }
7564 else
7565 {
7570 {
7574 }
7578 else
7579 eltscnt++;
7584 {
7588 }
7593 else
7594 {
7602 i++;
7603 }
7604 }
7607 }
7609 /* Returns a declaration for a VAR_DECL as if:
7611 extern "C" TYPE NAME;
7613 had been seen. Used to create compiler-generated global
7614 variables. */
7616 static tree
7618 {
7619 tree decl;
7626 /* If the user has explicitly declared this variable (perhaps
7627 because the code we are compiling is part of a low-level runtime
7628 library), then it is possible that our declaration will be merged
7629 with theirs by pushdecl. */
7635 }
7637 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
7638 if "__cxa_atexit" is not being used) corresponding to the function
7639 to be called when the program exits. */
7641 static tree
7643 {
7644 tree fn_type;
7647 {
7648 tree arg_type;
7651 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
7653 else
7654 /* The parameter to "atexit" is "void (*)(void)". */
7660 }
7663 }
7665 /* Returns a pointer to the `atexit' function. Note that if
7666 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
7667 `__cxa_atexit' function specified in the IA64 C++ ABI. */
7669 static tree
7671 {
7672 tree atexit_fndecl;
7673 tree fn_type;
7674 tree fn_ptr_type;
7682 {
7683 /* The declaration for `__cxa_atexit' is:
7685 int __cxa_atexit (void (*)(void *), void *, void *)
7687 We build up the argument types and then the function type
7688 itself. */
7692 /* First, build the pointer-to-function type for the first
7693 argument. */
7695 /* Then, build the rest of the argument types. */
7698 {
7701 }
7702 else
7703 {
7706 }
7707 /* And the final __cxa_atexit type. */
7710 NULL_TREE);
7713 else
7715 }
7716 else
7717 {
7718 /* The declaration for `atexit' is:
7720 int atexit (void (*)());
7722 We build up the argument types and then the function type
7723 itself. */
7725 /* Build the final atexit type. */
7729 }
7731 /* Now, build the function declaration. */
7739 }
7741 /* Like get_atexit_node, but for thread-local cleanups. */
7743 static tree
7745 {
7746 /* The declaration for `__cxa_thread_atexit' is:
7748 int __cxa_thread_atexit (void (*)(void *), void *, void *) */
7752 NULL_TREE);
7754 /* Now, build the function declaration. */
7758 }
7760 /* Returns the __dso_handle VAR_DECL. */
7762 static tree
7764 {
7768 /* Declare the variable. */
7770 ptr_type_node);
7772 #ifdef HAVE_GAS_HIDDEN
7774 {
7777 }
7778 #endif
7781 }
7783 /* Begin a new function with internal linkage whose job will be simply
7784 to destroy some particular variable. */
7788 static tree
7790 {
7792 tree fntype;
7793 tree fndecl;
7799 /* No need to mangle this. */
7802 /* Build the name of the function. */
7804 /* Build the function declaration. */
7807 /* It's a function with internal linkage, generated by the
7808 compiler. */
7811 /* Make the function `inline' so that it is only emitted if it is
7812 actually needed. It is unlikely that it will be inlined, since
7813 it is only called via a function pointer, but we avoid unnecessary
7814 emissions this way. */
7817 /* Build the parameter. */
7819 {
7820 tree parmdecl;
7827 }
7835 }
7837 /* Finish the cleanup function begun by start_cleanup_fn. */
7839 static void
7841 {
7845 }
7847 /* Generate code to handle the destruction of DECL, an object with
7848 static storage duration. */
7850 tree
7852 {
7853 tree cleanup;
7854 tree addr;
7855 tree compound_stmt;
7856 tree fcall;
7857 tree type;
7860 tree atex_node;
7866 /* If we're using "__cxa_atexit" (or "__cxa_thread_atexit" or
7867 "__aeabi_atexit"), and DECL is a class object, we can just pass the
7868 destructor to "__cxa_atexit"; we don't have to build a temporary
7869 function to do the cleanup. */
7870 dso_parm = (flag_use_cxa_atexit
7875 {
7878 /* Find the destructor. */
7882 /* Make sure it is accessible. */
7884 tf_warning_or_error);
7885 }
7886 else
7887 {
7888 /* Call build_cleanup before we enter the anonymous function so
7889 that any access checks will be done relative to the current
7890 scope, rather than the scope of the anonymous function. */
7893 /* Now start the function. */
7896 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
7897 to the original function, rather than the anonymous one. That
7898 will make the back end think that nested functions are in use,
7899 which causes confusion. */
7904 /* Create the body of the anonymous function. */
7909 }
7911 /* Call atexit with the cleanup function. */
7917 else
7921 {
7922 /* We must convert CLEANUP to the type that "__cxa_atexit"
7923 expects. */
7925 /* "__cxa_atexit" will pass the address of DECL to the
7926 cleanup function. */
7929 /* The declared type of the parameter to "__cxa_atexit" is
7930 "void *". For plain "T*", we could just let the
7931 machinery in cp_build_function_call convert it -- but if the
7932 type is "cv-qualified T *", then we need to convert it
7933 before passing it in, to avoid spurious errors. */
7935 }
7936 else
7937 /* Since the cleanup functions we build ignore the address
7938 they're given, there's no reason to pass the actual address
7939 in, and, in general, it's cheaper to pass NULL than any
7940 other value. */
7945 tf_warning_or_error);
7947 /* Just pass NULL to the dso handle parm if we don't actually
7948 have a DSO handle on this target. */
7950 else
7954 {
7957 {
7960 }
7961 else
7962 {
7965 }
7966 }
7967 else
7968 {
7971 }
7974 }
7976 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
7977 is its initializer. Generate code to handle the construction
7978 and destruction of DECL. */
7980 static void
7982 {
7986 /* Some variables require no dynamic initialization. */
7988 {
7989 /* Make sure the destructor is callable. */
7993 }
7997 {
8001 else
8006 {
8008 "C++11 %<thread_local%> allows dynamic initialization "
8011 }
8013 }
8016 {
8017 /* Emit code to perform this initialization but once. */
8022 /* We don't need thread-safety code for thread-local vars. */
8026 /* Emit code to perform this initialization but once. This code
8027 looks like:
8029 static <type> guard;
8030 if (!__atomic_load (guard.first_byte)) {
8031 if (__cxa_guard_acquire (&guard)) {
8032 bool flag = false;
8033 try {
8034 // Do initialization.
8035 flag = true; __cxa_guard_release (&guard);
8036 // Register variable for destruction at end of program.
8037 } catch {
8038 if (!flag) __cxa_guard_abort (&guard);
8039 }
8040 }
8042 Note that the `flag' variable is only set to 1 *after* the
8043 initialization is complete. This ensures that an exception,
8044 thrown during the construction, will cause the variable to
8045 reinitialized when we pass through this code again, as per:
8047 [stmt.dcl]
8049 If the initialization exits by throwing an exception, the
8050 initialization is not complete, so it will be tried again
8051 the next time control enters the declaration.
8053 This process should be thread-safe, too; multiple threads
8054 should not be able to initialize the variable more than
8055 once. */
8057 /* Create the guard variable. */
8060 /* Begin the conditional initialization. */
8067 {
8080 acquire_fn = push_library_fn
8083 NULL_TREE),
8088 NULL_TREE);
8098 inner_if_stmt);
8106 void_node,
8110 /* Do the initialization itself. */
8112 init = add_stmt_to_compound
8114 init = add_stmt_to_compound
8116 }
8117 else
8120 /* Use atexit to register a function for destroying this static
8121 variable. */
8127 {
8131 }
8136 }
8139 else
8141 }
8143 \f
8144 /* Make TYPE a complete type based on INITIAL_VALUE.
8145 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8146 2 if there was no information (in which case assume 0 if DO_DEFAULT),
8147 3 if the initializer list is empty (in pedantic mode). */
8149 int
8151 {
8155 /* Don't get confused by a CONSTRUCTOR for some other type. */
8162 {
8164 tree value;
8166 /* An array of character type can be initialized from a
8167 brace-enclosed string constant.
8169 FIXME: this code is duplicated from reshape_init. Probably
8170 we should just call reshape_init here? */
8174 {
8181 }
8183 /* If any of the elements are parameter packs, we can't actually
8184 complete this type now because the array size is dependent. */
8186 {
8189 {
8192 }
8193 }
8194 }
8198 /* We can create the array before the element type is complete, which
8199 means that we didn't have these two bits set in the original type
8200 either. In completing the type, we are expected to propagate these
8201 bits. See also complete_type which does the same thing for arrays
8202 of fixed size. */
8205 {
8210 }
8213 }
8215 /* As above, but either give an error or reject zero-size arrays, depending
8216 on COMPLAIN. */
8218 int
8221 {
8224 /* In SFINAE context we can't be lenient about zero-size arrays. */
8231 {
8237 {
8240 }
8244 }
8246 }
8247 \f
8248 /* Return zero if something is declared to be a member of type
8249 CTYPE when in the context of CUR_TYPE. STRING is the error
8250 message to print in that case. Otherwise, quietly return 1. */
8252 static int
8254 {
8256 {
8259 else
8262 }
8264 }
8265 \f
8266 /* Subroutine of `grokdeclarator'. */
8268 /* Generate errors possibly applicable for a given set of specifiers.
8269 This is for ARM $7.1.2. */
8271 static void
8279 {
8281 {
8318 }
8322 && !flag_noexcept_type
8328 }
8330 /* DECL is a member function or static data member and is presently
8331 being defined. Check that the definition is taking place in a
8332 valid namespace. */
8334 static void
8336 {
8337 /* These checks only apply to member functions and static data
8338 members. */
8340 /* We check for problems with specializations in pt.c in
8341 check_specialization_namespace, where we can issue better
8342 diagnostics. */
8345 /* We check this in check_explicit_instantiation_namespace. */
8348 /* [class.mfct]
8350 A member function definition that appears outside of the
8351 class definition shall appear in a namespace scope enclosing
8352 the class definition.
8354 [class.static.data]
8356 The definition for a static data member shall appear in a
8357 namespace scope enclosing the member's class definition. */
8361 }
8363 /* Build a PARM_DECL for the "this" parameter. TYPE is the
8364 METHOD_TYPE for a non-static member function; QUALS are the
8365 cv-qualifiers that apply to the function. */
8367 tree
8369 {
8370 tree this_type;
8371 tree qual_type;
8372 tree parm;
8373 cp_cv_quals this_quals;
8376 {
8377 this_type
8380 }
8381 else
8383 /* The `this' parameter is implicitly `const'; it cannot be
8384 assigned to. */
8390 }
8392 /* DECL is a static member function. Complain if it was declared
8393 with function-cv-quals. */
8395 static void
8397 {
8400 decl);
8401 }
8403 // Check that FN takes no arguments and returns bool.
8404 static void
8406 {
8407 // A constraint is nullary.
8411 // The declared return type of the concept shall be bool, and
8412 // it shall not be deduced from it definition.
8418 }
8420 /* Helper function. Replace the temporary this parameter injected
8421 during cp_finish_omp_declare_simd with the real this parameter. */
8423 static tree
8425 {
8434 }
8436 /* CTYPE is class type, or null if non-class.
8437 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8438 or METHOD_TYPE.
8439 DECLARATOR is the function's name.
8440 PARMS is a chain of PARM_DECLs for the function.
8441 VIRTUALP is truthvalue of whether the function is virtual or not.
8442 FLAGS are to be passed through to `grokclassfn'.
8443 QUALS are qualifiers indicating whether the function is `const'
8444 or `volatile'.
8445 RAISES is a list of exceptions that this function can raise.
8446 CHECK is 1 if we must find this method in CTYPE, 0 if we should
8447 not look, and -1 if we should not call `grokclassfn' at all.
8449 SFK is the kind of special function (if any) for the new function.
8451 Returns `NULL_TREE' if something goes wrong, after issuing
8452 applicable error messages. */
8454 static tree
8456 tree type,
8457 tree declarator,
8458 tree parms,
8459 tree orig_declarator,
8460 tree decl_reqs,
8463 cp_cv_quals quals,
8464 cp_ref_qualifier rqual,
8465 tree raises,
8471 special_function_kind sfk,
8474 tree in_namespace,
8476 location_t location)
8477 {
8478 tree decl;
8480 tree t;
8482 // Was the concept specifier present?
8485 // Concept declarations must have a corresponding definition.
8487 {
8490 }
8499 /* Set the constraints on the declaration. */
8501 {
8506 /* Adjust the required expression into a constraint. */
8512 }
8514 /* If we have an explicit location, use it, otherwise use whatever
8515 build_lang_decl used (probably input_location). */
8520 {
8521 tree parm;
8526 /* Allocate space to hold the vptr bit if needed. */
8528 }
8532 /* Propagate volatile out from type to decl. */
8536 /* Setup decl according to sfk. */
8538 {
8549 }
8553 {
8555 error
8557 orig_declarator);
8558 else
8559 {
8564 {
8565 /* Something like `template <class T> friend void f<T>()'. */
8568 orig_declarator);
8570 }
8573 /* A friend declaration of the form friend void f<>(). Record
8574 the information in the TEMPLATE_ID_EXPR. */
8583 {
8586 decl);
8588 }
8591 {
8594 decl);
8596 }
8597 }
8598 }
8600 /* If this decl has namespace scope, set that up. */
8606 /* `main' and builtins have implicit 'C' linkage. */
8619 /* Should probably propagate const out from type to decl I bet (mrs). */
8621 {
8624 }
8630 {
8634 }
8637 {
8648 }
8650 /* Members of anonymous types and local classes have no linkage; make
8651 them internal. If a typedef is made later, this will be changed. */
8657 {
8658 /* [basic.link]: A name with no linkage (notably, the name of a class
8659 or enumeration declared in a local scope) shall not be used to
8660 declare an entity with linkage.
8662 DR 757 relaxes this restriction for C++0x. */
8664 }
8668 {
8671 }
8673 /* If the declaration was declared inline, mark it as such. */
8675 {
8679 }
8683 // If the concept declaration specifier was found, check
8684 // that the declaration satisfies the necessary requirements.
8686 {
8689 }
8693 {
8696 TYPE_UNQUALIFIED,
8697 REF_QUAL_NONE);
8700 {
8704 decl);
8706 }
8709 {
8713 decl);
8715 }
8716 }
8719 {
8721 {
8725 }
8728 {
8733 }
8737 }
8742 {
8746 /* [over.literal]/6: Literal operators shall not have C linkage. */
8748 {
8751 }
8754 {
8757 {
8760 }
8764 {
8768 }
8770 {
8774 }
8775 }
8776 else
8777 {
8780 }
8781 }
8784 /* Make the init_value nonzero so pushdecl knows this is not
8785 tentative. error_mark_node is replaced later with the BLOCK. */
8792 {
8793 /* Adjust "omp declare simd" attributes. */
8796 {
8797 tree attr;
8800 {
8805 {
8807 cl = c_omp_declare_simd_clauses_to_numbers
8811 else
8813 }
8814 }
8815 }
8816 }
8818 /* Caller will do the rest of this. */
8825 /* 12.4/3 */
8833 template_count,
8844 {
8847 }
8849 /* Check main's type after attributes have been applied. */
8851 {
8853 integer_type_node))
8854 {
8856 tree newtype;
8860 }
8863 }
8866 {
8868 (processing_template_decl
8870 ? current_template_parms
8877 {
8878 tree ok;
8879 tree pushed_scope;
8882 /* Because grokfndecl is always supposed to return a
8883 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
8884 here. We depend on our callers to figure out that its
8885 really a template that's being returned. */
8890 {
8891 /* Remove the `this' parm added by grokclassfn. */
8894 }
8896 {
8899 }
8901 {
8906 }
8908 /* Since we've smashed OLD_DECL to its
8909 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
8913 /* Attempt to merge the declarations. This can fail, in
8914 the case of some invalid specialization declarations. */
8920 {
8924 }
8928 }
8929 }
8941 }
8943 /* decl is a FUNCTION_DECL.
8944 specifiers are the parsed virt-specifiers.
8946 Set flags to reflect the virt-specifiers.
8948 Returns decl. */
8950 static tree
8952 {
8960 }
8962 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
8963 the linkage that DECL will receive in the object file. */
8965 static void
8967 {
8968 /* A static data member always has static storage duration and
8969 external linkage. Note that static data members are forbidden in
8970 local classes -- the only situation in which a class has
8971 non-external linkage. */
8974 /* For non-template classes, static data members are always put
8975 out in exactly those files where they are defined, just as
8976 with ordinary namespace-scope variables. */
8979 }
8981 /* Create a VAR_DECL named NAME with the indicated TYPE.
8983 If SCOPE is non-NULL, it is the class type or namespace containing
8984 the variable. If SCOPE is NULL, the variable should is created in
8985 the innermost enclosing scope. */
8987 static tree
8989 tree name,
8990 tree orig_declarator,
8997 tree scope)
8998 {
8999 tree decl;
9000 tree explicit_scope;
9007 /* Compute the scope in which to place the variable, but remember
9008 whether or not that scope was explicitly specified by the user. */
9011 {
9012 /* An explicit "extern" specifier indicates a namespace-scope
9013 variable. */
9018 }
9022 template, we need DECL_LANG_SPECIFIC. */
9024 /* Similarly for namespace-scope variables with language linkage
9025 other than C++. */
9028 /* Similarly for static data members. */
9030 /* Similarly for explicit specializations. */
9031 || (orig_declarator
9034 else
9039 else
9043 {
9046 }
9049 {
9051 /* This function is only called with out-of-class definitions. */
9054 }
9055 /* At top level, either `static' or no s.c. makes a definition
9056 (perhaps tentative), and absence of `static' makes it public. */
9058 {
9061 || ! constp
9062 || volatilep
9065 }
9066 /* Not at top level, only `static' makes a static definition. */
9067 else
9068 {
9071 }
9074 {
9076 {
9080 }
9083 }
9085 /* If the type of the decl has no linkage, make sure that we'll
9086 notice that in mark_used. */
9095 {
9096 /* [basic.link]: A name with no linkage (notably, the name of a class
9097 or enumeration declared in a local scope) shall not be used to
9098 declare an entity with linkage.
9100 DR 757 relaxes this restriction for C++0x. */
9103 }
9104 else
9112 /* Check that the variable can be safely declared as a concept.
9113 Note that this also forbids explicit specializations. */
9115 {
9117 {
9120 }
9121 else
9126 }
9129 {
9133 }
9135 // Handle explicit specializations and instantiations of variable templates.
9141 }
9143 /* Create and return a canonical pointer to member function type, for
9144 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
9146 tree
9148 {
9150 tree t;
9155 /* Make sure that we always have the unqualified pointer-to-member
9156 type first. */
9158 {
9161 }
9163 /* If a canonical type already exists for this type, use it. We use
9164 this method instead of type_hash_canon, because it only does a
9165 simple equality check on the list of field members. */
9172 /* Let the front end know this is a pointer to member function. */
9179 delta_type_node);
9185 /* Zap out the name so that the back end will give us the debugging
9186 information for this anonymous RECORD_TYPE. */
9189 /* Cache this pointer-to-member type so that we can find it again
9190 later. */
9199 }
9201 /* Create and return a pointer to data member type. */
9203 tree
9205 {
9207 {
9212 }
9213 else
9214 {
9217 }
9218 }
9220 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9221 Check to see that the definition is valid. Issue appropriate error
9222 messages. Return 1 if the definition is particularly bad, or 0
9223 otherwise. */
9225 static int
9227 {
9228 /* Avoid redundant diagnostics on out-of-class definitions. */
9231 /* Can't check yet if we don't know the type. */
9234 /* If DECL is declared constexpr, we'll do the appropriate checks
9235 in check_initializer. Similarly for inline static data members. */
9241 {
9244 "in-class initialization of static data member %q#D of "
9248 "%<constexpr%> needed for in-class initialization of "
9250 else
9252 "in-class initialization of static data member %q#D of "
9255 }
9257 /* Motion 10 at San Diego: If a static const integral data member is
9258 initialized with an integral constant expression, the initializer
9259 may appear either in the declaration (within the class), or in
9260 the definition, but not both. If it appears in the class, the
9261 member is a member constant. The file-scope definition is always
9262 required. */
9264 {
9266 "invalid in-class initialization of static data member "
9268 type);
9270 }
9273 "ISO C++ forbids in-class initialization of non-const "
9275 decl);
9278 "ISO C++ forbids initialization of member constant "
9282 }
9284 /* *expr_p is part of the TYPE_SIZE of a variably-sized array. If any
9285 SAVE_EXPRs in *expr_p wrap expressions with side-effects, break those
9286 expressions out into temporary variables so that walk_tree doesn't
9287 step into them (c++/15764). */
9289 static tree
9291 {
9295 {
9301 }
9305 }
9307 /* Entry point for the above. */
9309 static void
9311 {
9313 /* Break out any function calls into temporary variables. */
9315 }
9317 /* Reduce a SIZEOF_EXPR to its value. */
9319 tree
9321 {
9322 tree r;
9329 else
9335 }
9337 /* Given the SIZE (i.e., number of elements) in an array, compute
9338 an appropriate index type for the array. If non-NULL, NAME is
9339 the name of the entity being declared. */
9341 tree
9343 {
9344 tree itype;
9351 {
9358 /* In C++98, we mark a non-constant array bound with a magic
9360 else
9361 {
9366 {
9369 {
9375 else
9378 }
9382 }
9389 }
9394 /* The array bound must be an integer type. */
9396 {
9401 else
9405 }
9406 }
9408 /* A type is dependent if it is...an array type constructed from any
9409 dependent type or whose size is specified by a constant expression
9410 that is value-dependent. */
9411 /* We can only call value_dependent_expression_p on integral constant
9412 expressions; treat non-constant expressions as dependent, too. */
9416 {
9417 /* We cannot do any checking for a SIZE that isn't known to be
9418 constant. Just build the index type and mark that it requires
9419 structural equality checks. */
9426 }
9429 {
9434 /* Use the folded result for VLAs, too; it will have resolved
9435 SIZEOF_EXPR. */
9437 }
9439 /* Normally, the array-bound will be a constant. */
9441 {
9442 /* Check to see if the array bound overflowed. Make that an
9443 error, no matter how generous we're being. */
9446 /* An array must have a positive number of elements. */
9448 {
9453 else
9456 }
9457 /* As an extension we allow zero-sized arrays. */
9459 {
9461 /* We must fail if performing argument deduction (as
9462 indicated by the state of complain), so that
9463 another substitution can be found. */
9469 else
9471 }
9472 }
9474 /* We don't allow VLAs at non-function scopes, or during
9475 tentative template substitution. */
9478 {
9481 /* `(int) &fn' is not a valid array bound. */
9484 name);
9485 else
9488 }
9490 {
9493 else
9495 }
9497 {
9501 else
9504 }
9507 /* A variable sized array. */
9509 else
9510 {
9511 HOST_WIDE_INT saved_processing_template_decl;
9513 /* Compute the index of the largest element in the array. It is
9514 one less than the number of elements in the array. We save
9515 and restore PROCESSING_TEMPLATE_DECL so that computations in
9516 cp_build_binary_op will be appropriately folded. */
9520 MINUS_EXPR,
9523 complain),
9524 complain);
9529 {
9530 /* A variable sized array. */
9537 {
9538 /* We have to add 1 -- in the ubsan routine we generate
9539 LE_EXPR rather than LT_EXPR. */
9544 }
9545 }
9546 /* Make sure that there was no overflow when creating to a signed
9547 index type. (For example, on a 32-bit machine, an array with
9548 size 2^32 - 1 is too big.) */
9551 {
9556 }
9557 }
9559 /* Create and return the appropriate index type. */
9562 /* If the index type were dependent, we would have returned early, so
9563 remember that it isn't. */
9567 }
9569 /* Returns the scope (if any) in which the entity declared by
9570 DECLARATOR will be located. If the entity was declared with an
9571 unqualified name, NULL_TREE is returned. */
9573 tree
9575 {
9579 /* If the declarator-id is a SCOPE_REF, the scope in which the
9580 declaration occurs is the first operand. */
9585 /* Otherwise, the declarator is not a qualified name; the entity will
9586 be declared in the current scope. */
9588 }
9590 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9591 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
9592 with this type. */
9594 static tree
9596 {
9599 /* If things have already gone awry, bail now. */
9603 /* 8.3.4/1: If the type of the identifier of D contains the auto
9604 type-specifier, the program is ill-formed. */
9606 {
9609 }
9611 /* If there are some types which cannot be array elements,
9612 issue an error-message and return. */
9614 {
9618 else
9625 else
9632 else
9639 else
9645 }
9647 /* [dcl.array]
9649 The constant expressions that specify the bounds of the arrays
9650 can be omitted only for the first member of the sequence. */
9652 {
9656 name);
9657 else
9662 }
9664 /* Figure out the index type for the array. */
9668 /* [dcl.array]
9669 T is called the array element type; this type shall not be [...] an
9670 abstract class type. */
9674 }
9676 /* Returns the smallest location != UNKNOWN_LOCATION among the
9677 three stored in LOCATIONS[ds_const], LOCATIONS[ds_volatile],
9678 and LOCATIONS[ds_restrict]. */
9680 static location_t
9682 {
9697 }
9699 /* Check that it's OK to declare a function with the indicated TYPE
9700 and TYPE_QUALS. SFK indicates the kind of special function (if any)
9701 that this function is. OPTYPE is the type given in a conversion
9702 operator declaration, or the class type for a constructor/destructor.
9703 Returns the actual return type of the function; that may be different
9704 than TYPE if an error occurs, or for certain special functions. */
9706 static tree
9708 tree type,
9709 tree optype,
9712 {
9714 {
9724 else
9735 /* We can't use the proper return type here because we run into
9736 problems with ambiguous bases and covariant returns. */
9739 else
9748 "qualifiers are not allowed on declaration of "
9756 }
9759 }
9761 /* A variable or data member (whose unqualified name is IDENTIFIER)
9762 has been declared with the indicated TYPE. If the TYPE is not
9763 acceptable, issue an error message and return a type to use for
9764 error-recovery purposes. */
9766 tree
9768 {
9770 {
9774 {
9777 }
9778 else
9781 }
9784 }
9786 /* Handle declaring DECL as an inline variable. */
9788 static void
9790 {
9793 {
9797 }
9800 "inline variables are only available "
9803 {
9806 }
9807 }
9809 /* Given declspecs and a declarator (abstract or otherwise), determine
9810 the name and type of the object declared and construct a DECL node
9811 for it.
9813 DECLSPECS points to the representation of declaration-specifier
9814 sequence that precedes declarator.
9816 DECL_CONTEXT says which syntactic context this declaration is in:
9817 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9818 FUNCDEF for a function definition. Like NORMAL but a few different
9819 error messages in each case. Return value may be zero meaning
9820 this definition is too screwy to try to parse.
9821 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
9822 handle member functions (which have FIELD context).
9823 Return value may be zero meaning this definition is too screwy to
9824 try to parse.
9825 PARM for a parameter declaration (either within a function prototype
9826 or before a function body). Make a PARM_DECL, or return void_type_node.
9827 TPARM for a template parameter declaration.
9828 CATCHPARM for a parameter declaration before a catch clause.
9829 TYPENAME if for a typename (in a cast or sizeof).
9830 Don't make a DECL node; just return the ..._TYPE node.
9831 FIELD for a struct or union field; make a FIELD_DECL.
9832 BITFIELD for a field with specified width.
9834 INITIALIZED is as for start_decl.
9836 ATTRLIST is a pointer to the list of attributes, which may be NULL
9837 if there are none; *ATTRLIST may be modified if attributes from inside
9838 the declarator should be applied to the declaration.
9840 When this function is called, scoping variables (such as
9841 CURRENT_CLASS_TYPE) should reflect the scope in which the
9842 declaration occurs, not the scope in which the new declaration will
9843 be placed. For example, on:
9845 void S::f() { ... }
9847 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
9848 should not be `S'.
9850 Returns a DECL (if a declarator is present), a TYPE (if there is no
9851 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
9852 error occurs. */
9854 tree
9860 {
9872 /* True if this declarator is a function definition. */
9876 #if 0
9877 /* See the code below that used this. */
9879 #endif
9881 /* Keep track of what sort of function is being processed
9882 so that we can warn about default return values, or explicit
9883 return values which do not match prescribed defaults. */
9889 /* cv-qualifiers that apply to the declarator, for a declaration of
9890 a member function. */
9892 /* virt-specifiers that apply to the declarator, for a declaration of
9893 a member function. */
9895 /* ref-qualifier that applies to the declarator, for a declaration of
9896 a member function. */
9898 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
9905 /* The unqualified name of the declarator; either an
9906 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
9907 tree unqualified_id;
9908 /* The class type, if any, in which this entity is located,
9909 or NULL_TREE if none. Note that this value may be different from
9910 the current class type; for example if an attempt is made to declare
9911 "A::f" inside "B", this value will be "A". */
9913 /* The NAMESPACE_DECL for the namespace in which this entity is
9914 located. If an unqualified name is used to declare the entity,
9915 this value will be NULL_TREE, even if the entity is located at
9916 namespace scope. */
9918 cp_storage_class storage_class;
9939 // Was concept_p specified? Note that ds_concept
9940 // implies ds_constexpr!
9971 /* Look inside a declarator for the name being declared
9972 and get it as a string, for an error message. */
9974 id_declarator;
9976 {
9981 {
9985 {
9989 }
9993 {
9999 {
10001 {
10002 /* [dcl.meaning]
10004 A declarator-id shall not be qualified except
10005 for ...
10007 None of the cases are permitted in block
10008 scope. */
10011 decl);
10015 else
10019 }
10021 {
10024 {
10027 }
10029 && current_class_type
10031 current_class_type))
10032 {
10036 }
10037 }
10040 }
10042 {
10044 {
10045 tree type;
10048 {
10051 }
10054 {
10057 }
10064 }
10068 {
10073 {
10076 else
10077 {
10080 }
10081 }
10082 }
10083 /* Fall through. */
10090 {
10092 dname);
10094 }
10097 else
10098 {
10105 else
10107 }
10112 }
10114 }
10131 }
10134 }
10136 /* [dcl.fct.edf]
10138 The declarator in a function-definition shall have the form
10139 D1 ( parameter-declaration-clause) ... */
10141 {
10144 }
10149 {
10152 }
10158 {
10161 }
10164 {
10166 {
10169 }
10171 {
10174 }
10175 }
10177 /* Anything declared one level down from the top level
10178 must be one of the parameters of a function
10179 (because the body is at least two levels down). */
10181 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
10182 by not allowing C++ class definitions to specify their parameters
10183 with xdecls (must be spec.d in the parmlist).
10185 Since we now wait to push a class scope until we are sure that
10186 we are in a legitimate method context, we must set oldcname
10187 explicitly (since current_class_name is not yet alive).
10189 We also want to avoid calling this a PARM if it is in a namespace. */
10192 {
10198 }
10204 {
10207 }
10210 {
10213 }
10215 /* If there were multiple types specified in the decl-specifier-seq,
10216 issue an error message. */
10218 {
10221 }
10224 {
10227 }
10229 /* Extract the basic type from the decl-specifier-seq. */
10232 {
10235 }
10236 /* If the entire declaration is itself tagged as deprecated then
10237 suppress reports of deprecated items. */
10242 {
10249 }
10250 /* No type at all: default to `int', and set DEFAULTED_INT
10251 because it was not a user-defined typedef. */
10253 {
10255 {
10256 /* These imply 'int'. */
10259 }
10260 /* If we just have "complex", it is equivalent to "complex double". */
10263 {
10266 "ISO C++ does not support plain %<complex%> meaning "
10268 }
10269 }
10270 /* Gather flags. */
10274 #if 0
10275 /* See the code below that used this. */
10278 #endif
10286 {
10288 ctor_return_type,
10289 type_quals,
10292 }
10294 {
10299 /* We handle `main' specially here, because 'main () { }' is so
10300 common. With no options, it is allowed. With -Wreturn-type,
10301 it is a warning. It is only an error with -pedantic-errors. */
10302 is_main = (funcdef_flag
10318 else
10323 /* FIXME we should be able to propagate the error_mark_node as is
10324 for other contexts too. */
10326 else
10328 }
10333 {
10335 {
10339 }
10344 }
10346 /* Now process the modifiers that were specified
10347 and check for invalid combinations. */
10349 /* Long double is a special combination. */
10351 {
10355 }
10357 /* Check all other uses of type modifiers. */
10360 {
10382 {
10387 }
10388 else
10389 {
10392 {
10395 name);
10398 }
10399 }
10401 /* Discard the type modifiers if they are invalid. */
10403 {
10409 }
10410 }
10412 /* Decide whether an integer type is signed or not.
10413 Optionally treat bitfields as signed by default. */
10415 /* [class.bit]
10417 It is implementation-defined whether a plain (neither
10418 explicitly signed or unsigned) char, short, int, or long
10419 bit-field is signed or unsigned.
10421 Naturally, we extend this to long long as well. Note that
10422 this does not include wchar_t. */
10424 && !signed_p
10425 /* A typedef for plain `int' without `signed' can be
10426 controlled just like plain `int', but a typedef for
10427 `signed int' cannot be so controlled. */
10428 && !(typedef_decl
10432 {
10445 else
10447 }
10460 {
10463 /* If a modifier is specified, the resulting complex is the complex
10464 form of TYPE. E.g, "complex short" is "complex short int". */
10473 else
10475 }
10477 /* If we're using the injected-class-name to form a compound type or a
10478 declaration, replace it with the underlying class so we don't get
10479 redundant typedefs in the debug output. But if we are returning the
10480 type unchanged, leave it alone so that it's available to
10481 maybe_get_template_decl_from_type_decl. */
10489 type = cp_build_qualified_type_real
10493 /* We might have ignored or rejected some of the qualifiers. */
10500 {
10504 }
10516 {
10518 {
10523 }
10527 }
10530 /* Issue errors about use of storage classes for parameters. */
10532 {
10534 {
10537 }
10539 {
10542 }
10548 /* Function parameters cannot be concept. */
10551 /* Function parameters cannot be constexpr. If we saw one, moan
10552 and pretend it wasn't there. */
10554 {
10557 }
10558 }
10560 /* Give error if `virtual' is used outside of class declaration. */
10563 {
10567 }
10570 {
10585 declspecs->gnu_thread_keyword_p
10591 {
10616 }
10619 {
10621 {
10625 "type must be cv-qualified %<auto%> or reference to "
10627 }
10630 }
10640 }
10642 /* Static anonymous unions are dealt with here. */
10648 /* Warn about storage classes that are invalid for certain
10649 kinds of declarations (parameters, typenames, etc.). */
10651 && ((storage_class
10655 {
10658 }
10663 {
10667 ;
10669 ;
10671 /* C++ allows static class elements. */
10673 /* C++ also allows inlines and signed and unsigned elements,
10674 but in those cases we don't come in here. */
10675 ;
10676 else
10677 {
10680 else
10681 {
10684 else
10686 }
10692 }
10693 }
10698 {
10701 }
10705 {
10710 /* When thread_local is applied to a variable of block scope the
10711 storage-class-specifier static is implied if it does not appear
10712 explicitly. */
10715 }
10718 {
10722 }
10726 else
10727 {
10730 {
10743 }
10744 }
10747 {
10748 /* Apply the c++11 attributes to the type preceding them. */
10752 }
10754 /* Determine the type of the entity declared by recurring on the
10755 declarator. */
10757 {
10759 tree attrs;
10766 {
10778 attr_flags);
10779 }
10787 {
10795 /* [dcl.array]/1:
10797 The optional attribute-specifier-seq appertains to the
10798 array. */
10804 {
10805 tree arg_types;
10808 /* Declaring a function type.
10809 Make sure we have a valid type for the function to return. */
10812 {
10814 {
10817 }
10818 /* We now know that the TYPE_QUALS don't apply to the
10819 decl, but to its return type. */
10821 }
10823 /* Error about some types functions can't return. */
10826 {
10829 }
10831 {
10834 }
10840 /* Pick up type qualifiers which should be applied to `this'. */
10842 /* Pick up virt-specifiers. */
10844 /* And ref-qualifier, too */
10846 /* And tx-qualifier. */
10848 /* Pick up the exception specifications. */
10850 /* If the exception-specification is ill-formed, let's pretend
10851 there wasn't one. */
10859 /* Say it's a definition only for the CALL_EXPR
10860 closest to the identifier. */
10863 /* Handle a late-specified return type. */
10866 {
10868 {
10870 {
10875 {
10877 "%<auto%> type specifier without trailing "
10880 "only available with -std=c++14 or "
10882 }
10884 {
10888 }
10889 }
10891 {
10896 }
10898 {
10900 {
10905 else
10910 }
10916 else
10920 }
10921 }
10924 {
10926 /* Not using maybe_warn_cpp0x because this should
10927 always be an error. */
10930 else
10934 }
10935 }
10945 && funcdecl_p
10951 {
10952 /* We are within a class's scope. If our declarator name
10953 is the same as the class name, and we are defining
10954 a function, then it is a constructor/destructor, and
10955 therefore returns a void type. */
10957 /* ISO C++ 12.4/2. A destructor may not be declared
10958 const or volatile. A destructor may not be static.
10959 A destructor may not be declared with ref-qualifier.
10961 ISO C++ 12.1. A constructor may not be declared
10962 const or volatile. A constructor may not be
10963 virtual. A constructor may not be static.
10964 A constructor may not be declared with ref-qualifier. */
10970 {
10975 }
10978 {
10984 }
10988 current_class_type,
10989 flags))
10993 {
10994 /* It's a constructor. */
10998 {
11002 }
11006 }
11009 }
11011 {
11013 {
11014 /* Cannot be both friend and virtual. */
11017 }
11023 name);
11024 }
11026 {
11028 {
11031 }
11034 }
11043 {
11047 }
11053 {
11055 /* transaction_safe applies to the type, but
11056 transaction_safe_dynamic applies to the function. */
11059 else
11061 }
11063 /* [dcl.fct]/2:
11065 The optional attribute-specifier-seq appertains to
11066 the function type. */
11071 }
11077 /* Filter out pointers-to-references and references-to-references.
11078 We can get these if a TYPE_DECL is used. */
11081 {
11083 {
11086 }
11088 /* In C++0x, we allow reference to reference declarations
11089 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
11090 and template type arguments [14.3.1/4 temp.arg.type]. The
11091 check for direct reference to reference declarations, which
11092 are still forbidden, occurs below. Reasoning behind the change
11093 can be found in DR106, DR540, and the rvalue reference
11094 proposals. */
11096 {
11099 }
11100 }
11102 {
11107 }
11109 /* We now know that the TYPE_QUALS don't apply to the decl,
11110 but to the target of the pointer. */
11113 /* This code used to handle METHOD_TYPE, but I don't think it's
11114 possible to get it here anymore. */
11118 {
11122 memfn_quals,
11123 rqual);
11129 }
11137 type);
11139 /* When the pointed-to type involves components of variable size,
11140 care must be taken to ensure that the size evaluation code is
11141 emitted early enough to dominate all the possible later uses
11142 and late enough for the variables on which it depends to have
11143 been assigned.
11145 This is expected to happen automatically when the pointed-to
11146 type has a name/declaration of it's own, but special attention
11147 is required if the type is anonymous.
11149 We handle the NORMAL and FIELD contexts here by inserting a
11150 dummy statement that just evaluates the size at a safe point
11151 and ensures it is not deferred until e.g. within a deeper
11152 conditional context (c++/43555).
11154 We expect nothing to be needed here for PARM or TYPENAME.
11155 Evaluating the size at this point for TYPENAME would
11156 actually be incorrect, as we might be in the middle of an
11157 expression with side effects on the pointed-to type size
11158 "arguments" prior to the pointer declaration point and the
11159 size evaluation could end up prior to the side effects. */
11165 {
11169 }
11172 {
11173 /* In C++0x, the type we are creating a reference to might be
11174 a typedef which is itself a reference type. In that case,
11175 we follow the reference collapsing rules in
11176 [7.1.3/8 dcl.typedef] to create the final reference type:
11178 "If a typedef TD names a type that is a reference to a type
11179 T, an attempt to create the type 'lvalue reference to cv TD'
11180 creates the type 'lvalue reference to T,' while an attempt
11181 to create the type "rvalue reference to cv TD' creates the
11182 type TD."
11183 */
11187 {
11190 else
11192 }
11193 else
11194 type = cp_build_reference_type
11197 /* In C++0x, we need this check for direct reference to
11198 reference declarations, which are forbidden by
11199 [8.3.2/5 dcl.ref]. Reference to reference declarations
11200 are only allowed indirectly through typedefs and template
11201 type arguments. Example:
11203 void foo(int & &); // invalid ref-to-ref decl
11205 typedef int & int_ref;
11206 void foo(int_ref &); // valid ref-to-ref decl
11207 */
11211 }
11215 {
11219 /* We will already have complained. */
11221 else
11223 type);
11224 }
11225 else
11228 /* Process a list of type modifier keywords (such as
11229 const or volatile) that were given inside the `*' or `&'. */
11232 {
11233 type
11237 }
11239 /* Apply C++11 attributes to the pointer, and not to the
11240 type pointed to. This is unlike what is done for GNU
11241 attributes above. It is to comply with [dcl.ptr]/1:
11243 [the optional attribute-specifier-seq (7.6.1) appertains
11244 to the pointer and not to the object pointed to]. */
11257 }
11258 }
11260 /* A `constexpr' specifier used in an object declaration declares
11261 the object as `const'. */
11263 {
11264 /* DR1688 says that a `constexpr' specifier in combination with
11265 `volatile' is valid. */
11268 {
11271 }
11272 }
11278 {
11280 unqualified_id);
11282 }
11284 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
11285 qualified with a class-name, turn it into a METHOD_TYPE, unless
11286 we know that the function is static. We take advantage of this
11287 opportunity to do other processing that pertains to entities
11288 explicitly declared to be class members. Note that if DECLARATOR
11289 is non-NULL, we know it is a cdk_id declarator; otherwise, we
11290 would not have exited the loop above. */
11295 {
11301 {
11303 {
11307 }
11308 else
11312 }
11314 can skip the following checks. */
11317 qualifying type must certainly be complete. */
11318 funcdef_flag
11319 /* A friend declaration of "T::f" is OK, even if
11320 "T" is a template parameter. But, if this
11321 function is not a friend, the qualifying type
11322 must be a class. */
11324 /* For a declaration, the type need not be
11325 complete, if either it is dependent (since there
11326 is no meaningful definition of complete in that
11327 case) or the qualifying class is currently being
11328 defined. */
11331 /* Check that the qualifying type is complete. */
11335 {
11338 {
11346 }
11347 }
11349 {
11353 }
11354 }
11359 /* Now TYPE has the actual type. */
11362 {
11365 else
11367 }
11372 /* [dcl.meaning]/1: The optional attribute-specifier-seq following
11373 a declarator-id appertains to the entity that is declared. */
11376 /* Handle parameter packs. */
11378 {
11380 /* Turn the type into a pack expansion.*/
11382 else
11384 }
11387 && !processing_template_decl
11389 {
11392 else
11395 }
11398 {
11399 /* [dcl.fct.spec] (C++11) The explicit specifier shall be used only
11400 in the declaration of a constructor or conversion function within
11401 a class definition. */
11408 else
11410 "only declarations of constructors and conversion operators "
11413 }
11416 {
11418 {
11421 }
11423 {
11426 }
11429 {
11432 }
11434 {
11437 }
11439 {
11442 }
11444 {
11448 }
11449 }
11451 /* If this is declaring a typedef name, return a TYPE_DECL. */
11453 {
11454 tree decl;
11456 /* This declaration:
11458 typedef void f(int) const;
11460 declares a function type which is not a member of any
11461 particular class, but which is cv-qualified; for
11462 example "f S::*" declares a pointer to a const-qualified
11463 member function of S. We record the cv-qualification in the
11464 function type. */
11466 {
11469 /* We have now dealt with these qualifiers. */
11472 }
11475 {
11478 }
11485 else
11491 }
11494 {
11498 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
11500 /* The TYPE_DECL is "abstract" because there will be
11501 clones of this constructor/destructor, and there will
11502 be copies of this TYPE_DECL generated in those
11503 clones. The decloning optimization (for space) may
11504 revert this subsequently if it determines that
11505 the clones should share a common implementation. */
11507 }
11512 unqualified_id);
11514 /* If the user declares "typedef struct {...} foo" then the
11515 struct will have an anonymous name. Fill that name in now.
11516 Nothing can refer to it, so nothing needs know about the name
11517 change. */
11519 && unqualified_id
11526 {
11527 tree t;
11529 /* Replace the anonymous name with the real name everywhere. */
11531 {
11533 /* We do not rename the debug info representing the
11534 unnamed tagged type because the standard says in
11535 [dcl.typedef] that the naming applies only for
11536 linkage purposes. */
11537 /*debug_hooks->set_name (t, decl);*/
11539 }
11544 /* If this is a typedef within a template class, the nested
11545 type is a (non-primary) template. The name for the
11546 template needs updating as well. */
11551 /* Adjust linkage now that we aren't unnamed anymore. */
11554 /* FIXME remangle member functions; member functions of a
11555 type with external linkage have external linkage. */
11556 }
11567 /* Acknowledge that this was written:
11568 `using analias = atype;'. */
11572 }
11574 /* Detect the case of an array type of unspecified size
11575 which came, as such, direct from a typedef name.
11576 We must copy the type, so that the array's domain can be
11577 individually set by the object's initializer. */
11584 /* Detect where we're using a typedef of function type to declare a
11585 function. PARMS will not be set, so we must create it now. */
11588 {
11590 tree args;
11595 {
11600 }
11605 {
11606 /* The qualifiers on the function type become the qualifiers on
11607 the non-static member function. */
11611 }
11612 }
11614 /* If this is a type name (such as, in a cast or sizeof),
11615 compute the type and return it now. */
11618 {
11619 /* Note that here we don't care about type_quals. */
11621 /* Special case: "friend class foo" looks like a TYPENAME context. */
11623 {
11625 {
11628 }
11631 {
11632 /* Don't allow friend declaration without a class-key. */
11639 else
11642 type);
11643 }
11645 /* Only try to do this stuff if we didn't already give up. */
11647 {
11648 /* A friendly class? */
11652 else
11654 type);
11657 }
11658 }
11660 {
11667 /* Core issue #547: need to allow this in template type args.
11668 Allow it in general in C++11 for alias-declarations. */
11672 else
11674 }
11680 }
11684 && ! bitfield
11686 {
11689 }
11691 /* Only functions may be declared using an operator-function-id. */
11696 {
11699 }
11706 type);
11708 /* We don't check parameter types here because we can emit a better
11709 error message later. */
11711 {
11715 }
11717 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11718 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
11721 {
11727 {
11730 else
11733 }
11735 /* A parameter declared as an array of T is really a pointer to T.
11736 One declared as a function is really a pointer to a function.
11737 One declared as a member is really a pointer to member. */
11740 {
11741 /* Transfer const-ness of array into that of type pointed to. */
11745 }
11748 }
11752 {
11758 }
11760 {
11764 {
11771 }
11773 {
11776 {
11782 else
11786 }
11788 /* The C99 flexible array extension. */
11791 {
11795 {
11798 }
11799 else
11800 {
11801 /* Flexible array member has a null domain. */
11803 }
11804 }
11807 {
11808 /* Happens when declaring arrays of sizes which
11809 are error_mark_node, for example. */
11811 }
11813 {
11814 /* Something like struct S { int N::j; }; */
11817 }
11820 {
11822 tree function_context;
11825 {
11826 /* This should never happen in pure C++ (the check
11827 could be an assert). It could happen in
11828 Objective-C++ if someone writes invalid code that
11829 uses a function declaration for an instance
11830 variable or property (instance variables and
11831 properties are parsed as FIELD_DECLs, but they are
11832 part of an Objective-C class, not a C++ class).
11833 That code is invalid and is caught by this
11834 check. */
11836 {
11838 unqualified_id);
11840 }
11842 /* ``A union may [ ... ] not [ have ] virtual functions.''
11843 ARM 9.5 */
11845 {
11847 unqualified_id);
11849 }
11852 {
11854 {
11857 unqualified_id);
11859 }
11860 }
11861 }
11863 /* Check that the name used for a destructor makes sense. */
11865 {
11869 {
11874 }
11877 {
11881 }
11883 {
11886 }
11888 {
11891 }
11892 }
11894 {
11899 }
11902 {
11905 }
11907 {
11910 }
11913 {
11916 {
11922 }
11923 }
11925 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
11937 parms,
11938 unqualified_id,
11939 reqs,
11949 #if 0
11950 /* This clobbers the attrs stored in `decl' from `attrlist'. */
11951 /* The decl and setting of decl_attr is also turned off. */
11953 #endif
11955 /* [class.conv.ctor]
11957 A constructor declared without the function-specifier
11958 explicit that can be called with a single parameter
11959 specifies a conversion from the type of its first
11960 parameter to the type of its class. Such a constructor
11961 is called a converting constructor. */
11964 }
11969 {
11972 {
11974 {
11978 }
11979 else
11984 }
11985 }
11986 else
11987 {
11989 {
11993 }
11995 }
11998 {
11999 /* Friends are treated specially. */
12003 {
12005 {
12006 decl = check_explicit_specialization
12011 }
12015 funcdef_flag);
12017 }
12018 else
12020 }
12022 /* Structure field. It may not be a function, except for C++. */
12025 {
12027 {
12028 /* C++ allows static class members. All other work
12029 for this is done by grokfield. */
12036 {
12042 }
12045 unqualified_id);
12047 {
12051 }
12058 /* Even if there is an in-class initialization, DECL
12059 is considered undefined until an out-of-class
12060 definition is provided, unless this is an inline
12061 variable. */
12063 }
12064 else
12065 {
12068 unqualified_id);
12070 {
12072 unqualified_id);
12074 }
12082 {
12085 }
12088 {
12089 /* An attempt is being made to initialize a non-static
12090 member. This is new in C++11. */
12093 /* If this has been parsed with static storage class, but
12094 errors forced staticp to be cleared, ensure NSDMI is
12095 not present. */
12098 }
12099 }
12105 }
12106 }
12109 {
12110 tree original_name;
12118 else
12126 {
12129 name);
12130 else
12132 name);
12133 }
12137 /* Function declaration not at top level.
12138 Storage classes other than `extern' are not allowed
12139 and `extern' makes no difference. */
12144 {
12147 "%<static%> specifier invalid for function %qs "
12149 else
12151 "%<inline%> specifier invalid for function %qs "
12153 }
12156 {
12158 {
12161 }
12164 {
12169 }
12170 }
12172 /* Record whether the function is public. */
12182 publicp,
12185 sfk,
12186 funcdef_flag,
12193 {
12196 /* Don't allow a static member function in a class, and forbid
12197 declaring main to be static. */
12199 {
12203 }
12205 {
12206 /* 7.1.1: There can be no static function declarations within a
12207 block. */
12210 }
12213 {
12216 }
12217 }
12218 }
12219 else
12220 {
12221 /* It's a variable. */
12223 /* An uninitialized decl with `extern' is a reference. */
12225 declspecs,
12226 initialized,
12227 type_quals,
12228 inlinep,
12229 concept_p,
12230 template_count,
12240 {
12243 {
12248 }
12250 {
12253 }
12255 {
12257 "cannot explicitly declare member %q#D to have "
12260 }
12261 }
12263 {
12265 decl);
12267 }
12272 {
12278 }
12279 }
12283 {
12286 {
12291 }
12292 else
12295 }
12298 {
12300 {
12301 /* It's common practice (and completely valid) to have a const
12302 be initialized and declared extern. */
12305 }
12306 else
12307 {
12310 }
12311 }
12313 /* Record `register' declaration for warnings on &
12314 and in case doing stupid register allocation. */
12317 {
12319 /* Warn about register storage specifiers on PARM_DECLs. */
12321 {
12324 "ISO C++1z does not allow %<register%> storage "
12326 else
12329 }
12330 }
12336 /* Set constexpr flag on vars (functions got it in grokfndecl). */
12340 /* Record constancy and volatility on the DECL itself . There's
12341 no need to do this when processing a template; we'll do this
12342 for the instantiated declaration based on the type of DECL. */
12347 }
12348 }
12349 \f
12350 /* Subroutine of start_function. Ensure that each of the parameter
12351 types (as listed in PARMS) is complete, as is required for a
12352 function definition. */
12354 static void
12356 {
12358 {
12363 {
12366 }
12367 else
12368 /* grokparms or complete_type_or_else will have already issued
12369 an error. */
12371 }
12372 }
12374 /* Returns nonzero if T is a local variable. */
12376 int
12378 {
12380 /* A VAR_DECL with a context that is a _TYPE is a static data
12381 member. */
12383 /* Any other non-local variable must be at namespace scope. */
12389 }
12391 /* Like local_variable_p, but suitable for use as a tree-walking
12392 function. */
12394 static tree
12397 {
12405 }
12407 /* Check that ARG, which is a default-argument expression for a
12408 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
12409 something goes wrong. DECL may also be a _TYPE node, rather than a
12410 DECL, if there is no DECL available. */
12412 tree
12414 {
12415 tree var;
12416 tree decl_type;
12419 /* We get a DEFAULT_ARG when looking at an in-class declaration
12420 with a default argument. Ignore the argument for now; we'll
12421 deal with it after the class is complete. */
12425 {
12428 }
12429 else
12436 /* Something already went wrong. There's no need to check
12437 further. */
12440 /* [dcl.fct.default]
12442 A default argument expression is implicitly converted to the
12443 parameter type. */
12446 LOOKUP_IMPLICIT);
12449 /* Avoid redundant -Wzero-as-null-pointer-constant warnings at
12450 the call sites. */
12455 /* [dcl.fct.default]
12457 Local variables shall not be used in default argument
12458 expressions.
12460 The keyword `this' shall not be used in a default argument of a
12461 member function. */
12464 {
12466 {
12470 else
12472 }
12474 }
12476 /* All is well. */
12478 }
12480 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
12482 static tree
12484 {
12489 {
12492 else
12494 }
12496 /* Do warn about using typedefs to a deprecated class. */
12508 return type_is_deprecated
12512 }
12514 /* Decode the list of parameter types for a function type.
12515 Given the list of things declared inside the parens,
12516 return a list of types.
12518 If this parameter does not end with an ellipsis, we append
12519 void_list_node.
12521 *PARMS is set to the chain of PARM_DECLs created. */
12523 tree
12525 {
12528 tree parm;
12532 {
12545 {
12547 && !init
12550 /* DR 577: A parameter list consisting of a single
12551 unnamed parameter of non-dependent type 'void'. */
12555 "invalid use of cv-qualified type %qT in "
12557 else
12559 "invalid use of type %<void%> in parameter "
12561 /* It's not a good idea to actually create parameters of
12562 type `void'; other parts of the compiler assume that a
12563 void type terminates the parameter list. */
12566 }
12569 {
12571 {
12575 }
12577 /* Top-level qualifiers on the parameters are
12578 ignored for function types. */
12581 {
12585 }
12589 {
12590 /* [dcl.fct]/6, parameter types cannot contain pointers
12591 (references) to arrays of unknown bound. */
12596 {
12604 }
12612 }
12618 }
12623 }
12631 }
12633 \f
12634 /* D is a constructor or overloaded `operator='.
12636 Let T be the class in which D is declared. Then, this function
12637 returns:
12639 -1 if D's is an ill-formed constructor or copy assignment operator
12640 whose first parameter is of type `T'.
12641 0 if D is not a copy constructor or copy assignment
12642 operator.
12643 1 if D is a copy constructor or copy assignment operator whose
12644 first parameter is a reference to non-const qualified T.
12645 2 if D is a copy constructor or copy assignment operator whose
12646 first parameter is a reference to const qualified T.
12648 This function can be used as a predicate. Positive values indicate
12649 a copy constructor and nonzero values indicate a copy assignment
12650 operator. */
12652 int
12654 {
12655 tree args;
12656 tree arg_type;
12664 /* Instantiations of template member functions are never copy
12665 functions. Note that member functions of templated classes are
12666 represented as template functions internally, and we must
12667 accept those as copy functions. */
12679 {
12680 /* Pass by value copy assignment operator. */
12682 }
12686 {
12689 }
12690 else
12696 /* There are more non-optional args. */
12700 }
12702 /* D is a constructor or overloaded `operator='.
12704 Let T be the class in which D is declared. Then, this function
12705 returns true when D is a move constructor or move assignment
12706 operator, false otherwise. */
12708 bool
12710 {
12714 /* There are no move constructors if we are in C++98 mode. */
12720 /* Instantiations of template member functions are never move
12721 functions. Note that member functions of templated classes are
12722 represented as template functions internally, and we must
12723 accept those as move functions. */
12727 }
12729 /* D is a constructor or overloaded `operator='.
12731 Then, this function returns true when D has the same signature as a move
12732 constructor or move assignment operator (because either it is such a
12733 ctor/op= or it is a template specialization with the same signature),
12734 false otherwise. */
12736 bool
12738 {
12739 tree args;
12740 tree arg_type;
12760 /* There are more non-optional args. */
12764 }
12766 /* Remember any special properties of member function DECL. */
12768 void
12770 {
12771 tree class_type;
12778 {
12785 {
12786 /* [class.copy]
12788 A non-template constructor for class X is a copy
12789 constructor if its first parameter is of type X&, const
12790 X&, volatile X& or const volatile X&, and either there
12791 are no other parameters or else all other parameters have
12792 default arguments. */
12798 }
12809 }
12811 {
12812 /* [class.copy]
12814 A non-template assignment operator for class X is a copy
12815 assignment operator if its parameter is of type X, X&, const
12816 X&, volatile X& or const volatile X&. */
12821 {
12827 }
12830 }
12831 /* Destructors are handled in check_methods. */
12832 }
12834 /* Check a constructor DECL has the correct form. Complains
12835 if the class has a constructor of the form X(X). */
12837 int
12839 {
12843 {
12844 /* [class.copy]
12846 A declaration of a constructor for a class X is ill-formed if
12847 its first parameter is of type (optionally cv-qualified) X
12848 and either there are no other parameters or else all other
12849 parameters have default arguments.
12851 We *don't* complain about member template instantiations that
12852 have this form, though; they can occur as we try to decide
12853 what constructor to use during overload resolution. Since
12854 overload resolution will never prefer such a constructor to
12855 the non-template copy constructor (which is either explicitly
12856 or implicitly defined), there's no need to worry about their
12857 existence. Theoretically, they should never even be
12858 instantiated, but that's hard to forestall. */
12862 }
12865 }
12867 /* An operator with this code is unary, but can also be binary. */
12869 static int
12871 {
12878 }
12880 /* An operator with this name can only be unary. */
12882 static int
12884 {
12889 }
12891 /* DECL is a declaration for an overloaded operator. If COMPLAIN is true,
12892 errors are issued for invalid declarations. */
12894 bool
12896 {
12898 tree argtype;
12904 tree class_type;
12906 /* Count the number of arguments and check for ellipsis. */
12919 else
12920 do
12921 {
12922 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
12923 if (ansi_opname (CODE) == name) \
12924 { \
12925 operator_code = (CODE); \
12926 break; \
12927 } \
12928 else if (ansi_assopname (CODE) == name) \
12929 { \
12930 operator_code = (CODE); \
12931 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
12932 break; \
12933 }
12936 #undef DEF_OPERATOR
12939 }
12946 {
12965 }
12967 /* [basic.std.dynamic.allocation]/1:
12969 A program is ill-formed if an allocation function is declared
12970 in a namespace scope other than global scope or declared static
12971 in global scope.
12973 The same also holds true for deallocation functions. */
12976 {
12978 {
12980 {
12983 }
12985 {
12988 }
12989 }
12990 }
12993 {
12996 }
12999 else
13000 {
13001 /* An operator function must either be a non-static member function
13002 or have at least one parameter of a class, a reference to a class,
13003 an enumeration, or a reference to an enumeration. 13.4.0.6 */
13005 {
13011 {
13014 }
13015 else
13016 {
13017 tree p;
13020 {
13024 }
13027 {
13032 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
13033 because these checks are performed even on
13034 template functions. */
13038 }
13041 {
13046 }
13047 }
13048 }
13050 /* There are no restrictions on the arguments to an overloaded
13051 "operator ()". */
13055 /* Warn about conversion operators that will never be used. */
13058 && warn_conversion
13059 /* Warn only declaring the function; there is no need to
13060 warn again about out-of-class definitions. */
13062 {
13071 ref
13077 {
13080 ref
13085 /* Don't force t to be complete here. */
13090 ref
13095 }
13097 }
13100 {
13101 /* 13.4.0.3 */
13104 }
13106 {
13109 }
13111 {
13113 /* We pick the one-argument operator codes by default, so
13114 we don't have to change anything. */
13115 ;
13117 {
13118 /* If we thought this was a unary operator, we now know
13119 it to be a binary operator. */
13121 {
13148 }
13154 && ! processing_template_decl
13156 {
13159 decl);
13160 else
13164 }
13165 }
13166 else
13167 {
13170 else
13173 }
13175 /* More Effective C++ rule 6. */
13181 {
13189 {
13192 arg))
13195 }
13196 else
13197 {
13200 }
13201 }
13202 }
13204 {
13206 {
13209 else
13212 }
13213 }
13215 {
13217 {
13220 else
13223 }
13225 /* More Effective C++ rule 7. */
13231 decl);
13232 }
13234 /* Effective C++ rule 23. */
13246 /* [over.oper]/8 */
13250 {
13254 {
13256 decl);
13257 }
13258 else
13259 {
13262 }
13263 }
13264 }
13266 }
13267 \f
13268 /* Return a string giving the keyword associate with CODE. */
13272 {
13274 {
13287 }
13288 }
13290 /* Name lookup in an elaborated-type-specifier (after the keyword
13291 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
13292 elaborated-type-specifier is invalid, issue a diagnostic and return
13293 error_mark_node; otherwise, return the *_TYPE to which it referred.
13294 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
13296 tree
13298 tree decl,
13300 {
13301 tree type;
13303 /* In the case of:
13305 struct S { struct S *p; };
13307 name lookup will find the TYPE_DECL for the implicit "S::S"
13308 typedef. Adjust for that here. */
13314 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
13315 is false for this case as well. */
13317 {
13321 }
13322 /* Accept template template parameters. */
13326 ;
13327 /* [dcl.type.elab]
13329 If the identifier resolves to a typedef-name or the
13330 simple-template-id resolves to an alias template
13331 specialization, the elaborated-type-specifier is ill-formed.
13333 In other words, the only legitimate declaration to use in the
13334 elaborated type specifier is the implicit typedef created when
13335 the type is declared. */
13339 {
13343 else
13348 }
13353 {
13357 }
13360 {
13364 }
13368 {
13369 /* If a class template appears as elaborated type specifier
13370 without a template header such as:
13372 template <class T> class C {};
13373 void f(class C); // No template header here
13375 then the required template argument is missing. */
13380 }
13383 }
13385 /* Lookup NAME in elaborate type specifier in scope according to
13386 SCOPE and issue diagnostics if necessary.
13387 Return *_TYPE node upon success, NULL_TREE when the NAME is not
13388 found, and ERROR_MARK_NODE for type error. */
13390 static tree
13393 {
13394 tree t;
13395 tree decl;
13397 {
13398 /* First try ordinary name lookup, ignoring hidden class name
13399 injected via friend declaration. */
13402 /* If that fails, the name will be placed in the smallest
13403 non-class, non-function-prototype scope according to 3.3.1/5.
13404 We may already have a hidden name declared as friend in this
13405 scope. So lookup again but not ignoring hidden names.
13406 If we find one, that name will be made visible rather than
13407 creating a new tag. */
13410 }
13411 else
13416 /* If scope is ts_current we're defining a class, so ignore a
13417 template template parameter. */
13423 {
13424 /* Look for invalid nested type:
13425 class C {
13426 class C {};
13427 }; */
13429 {
13432 decl);
13434 }
13436 /* Two cases we need to consider when deciding if a class
13437 template is allowed as an elaborated type specifier:
13438 1. It is a self reference to its own class.
13439 2. It comes with a template header.
13441 For example:
13443 template <class T> class C {
13444 class C *c1; // DECL_SELF_REFERENCE_P is true
13445 class D;
13446 };
13447 template <class U> class C; // template_header_p is true
13448 template <class T> class C<T>::D {
13449 class C *c2; // DECL_SELF_REFERENCE_P is true
13450 }; */
13453 decl,
13454 template_header_p
13459 {
13468 }
13471 }
13473 {
13477 }
13478 else
13480 }
13482 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
13483 Define the tag as a forward-reference if it is not defined.
13485 If a declaration is given, process it here, and report an error if
13486 multiple declarations are not identical.
13488 SCOPE is TS_CURRENT when this is also a definition. Only look in
13489 the current frame for the name (since C++ allows new names in any
13490 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
13491 declaration. Only look beginning from the current scope outward up
13492 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
13494 TEMPLATE_HEADER_P is true when this declaration is preceded by
13495 a set of template parameters. */
13497 static tree
13500 {
13502 tree t;
13504 tag_scope scope;
13509 {
13522 }
13526 else
13529 /* In case of anonymous name, xref_tag is only called to
13530 make type node and push name. Name lookup is not required. */
13533 else
13543 {
13547 /* Since SCOPE is not TS_CURRENT, we are not looking at a
13548 definition of this tag. Since, in addition, we are currently
13549 processing a (member) template declaration of a template
13550 class, we must be very careful; consider:
13552 template <class X>
13553 struct S1
13555 template <class U>
13556 struct S2
13557 { template <class V>
13558 friend struct S1; };
13560 Here, the S2::S1 declaration should not be confused with the
13561 outer declaration. In particular, the inner version should
13562 have a template parameter of level 2, not level 1. This
13563 would be particularly important if the member declaration
13564 were instead:
13566 template <class V = U> friend struct S1;
13568 say, when we should tsubst into `U' when instantiating
13569 S2. On the other hand, when presented with:
13571 template <class T>
13572 struct S1 {
13573 template <class U>
13574 struct S2 {};
13575 template <class U>
13576 friend struct S2;
13577 };
13579 we must find the inner binding eventually. We
13580 accomplish this by making sure that the new type we
13581 create to represent this declaration has the right
13582 TYPE_CONTEXT. */
13585 }
13588 {
13589 /* If no such tag is yet defined, create a forward-reference node
13590 and record it as the "definition".
13591 When a real declaration of this type is found,
13592 the forward-reference will be altered into a real type. */
13594 {
13597 }
13598 else
13599 {
13603 /* Remember that we're declaring a lambda to avoid bogus errors
13604 in push_template_decl. */
13607 }
13608 }
13609 else
13610 {
13612 {
13613 /* Check that we aren't trying to overload a class with different
13614 constraints. */
13617 {
13620 }
13623 }
13627 {
13631 }
13633 /* Make injected friend class visible. */
13636 {
13641 {
13644 }
13645 }
13646 }
13649 }
13651 /* Wrapper for xref_tag_1. */
13653 tree
13656 {
13657 tree ret;
13663 }
13666 tree
13668 {
13673 else
13680 }
13682 /* Create the binfo hierarchy for REF with (possibly NULL) base list
13683 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
13684 access_* node, and the TREE_VALUE is the type of the base-class.
13685 Non-NULL TREE_TYPE indicates virtual inheritance. */
13687 void
13689 {
13696 tree default_access;
13702 /* The base of a derived class is private by default, all others are
13703 public. */
13708 /* First, make sure that any templates in base-classes are
13709 instantiated. This ensures that if we call ourselves recursively
13710 we do not get confused about which classes are marked and which
13711 are not. */
13714 {
13717 /* The dependent_type_p call below should really be dependent_scope_p
13718 so that we give a hard error about using an incomplete type as a
13719 base, but we allow it with a pedwarn for backward
13720 compatibility. */
13726 /* An incomplete type. Remove it from the list. */
13728 else
13729 {
13730 max_bases++;
13732 max_dvbases++;
13736 }
13737 }
13742 /* The binfo slot should be empty, unless this is an (ill-formed)
13743 redefinition. */
13754 /* Apply base-class info set up to the variants of this type. */
13758 {
13760 /* A C++98 POD cannot have base classes. */
13765 }
13772 {
13778 }
13781 {
13789 /* Before C++17, an aggregate cannot have base classes. In C++17, an
13790 aggregate can't have virtual, private, or protected base classes. */
13801 {
13803 basetype);
13805 }
13809 {
13811 /* The original basetype could have been a typedef'd type. */
13814 /* Inherit flags from the base. */
13825 }
13827 /* We must do this test after we've seen through a typedef
13828 type. */
13830 {
13833 else
13836 }
13839 /* Regenerate the pack expansion for the bases. */
13853 dropped_base:
13854 /* Update max_vbases to reflect the reality that we are dropping
13855 this base: if it reaches zero we want to undo the vec_alloc
13856 above to avoid inconsistencies during error-recovery: eg, in
13857 build_special_member_call, CLASSTYPE_VBASECLASSES non null
13858 and vtt null (c++/27952). */
13860 max_vbases--;
13862 max_vbases
13864 }
13871 /* If we didn't get max_vbases vbases, we must have shared at
13872 least one of them, and are therefore diamond shaped. */
13875 /* Unmark all the types. */
13880 /* Now see if we have a repeated base type. */
13882 {
13885 {
13887 {
13890 }
13892 }
13897 else
13899 }
13900 }
13902 \f
13903 /* Copies the enum-related properties from type SRC to type DST.
13904 Used with the underlying type of an enum and the enum itself. */
13905 static void
13907 {
13908 tree t;
13910 {
13920 else
13924 }
13925 }
13927 /* Begin compiling the definition of an enumeration type.
13928 NAME is its name,
13930 if ENUMTYPE is not NULL_TREE then the type has alredy been found.
13932 UNDERLYING_TYPE is the type that will be used as the storage for
13933 the enumeration type. This should be NULL_TREE if no storage type
13934 was specified.
13936 ATTRIBUTES are any attributes specified after the enum-key.
13938 SCOPED_ENUM_P is true if this is a scoped enumeration type.
13940 if IS_NEW is not NULL, gets TRUE iff a new type is created.
13942 Returns the type object, as yet incomplete.
13943 Also records info about it so that build_enumerator
13944 may be used to declare the individual values as they are read. */
13946 tree
13949 {
13955 /* [C++0x dcl.enum]p5:
13957 If not explicitly specified, the underlying type of a scoped
13958 enumeration type is int. */
13965 /* If this is the real definition for a previous forward reference,
13966 fill in the contents in the same object that used to be the
13967 forward reference. */
13973 /* In case of a template_decl, the only check that should be deferred
13974 to instantiation time is the comparison of underlying types. */
13976 {
13978 {
13984 }
13986 {
13992 }
13998 {
14004 }
14005 }
14009 {
14010 /* In case of error, make a dummy enum to allow parsing to
14011 continue. */
14013 {
14016 }
14018 /* enumtype may be an ENUMERAL_TYPE if this is a redefinition
14019 of an opaque enum, or an opaque enum of an already defined
14020 enumeration (C++0x only).
14021 In any other case, it'll be NULL_TREE. */
14023 {
14026 }
14029 /* Do not push the decl more than once, unless we need to
14030 compare underlying types at instantiation time */
14033 || (underlying_type
14037 {
14040 }
14041 else
14048 /* The enum is considered opaque until the opening '{' of the
14049 enumerator list. */
14052 }
14059 {
14061 /* We already checked that it matches, don't change it to a different
14064 {
14067 }
14070 else
14073 }
14075 /* If into a template class, the returned enum is always the first
14076 declaration (opaque or not) seen. This way all the references to
14077 this type will be to the same declaration. The following ones are used
14078 only to check for definition errors. */
14081 else
14083 }
14085 /* After processing and defining all the values of an enumeration type,
14086 install their decls in the enumeration type.
14087 ENUMTYPE is the type object. */
14089 void
14091 {
14092 tree values;
14093 tree underlying_type;
14094 tree decl;
14095 tree value;
14097 tree t;
14099 bool fixed_underlying_type_p
14102 /* We built up the VALUES in reverse order. */
14105 /* For an enum defined in a template, just set the type of the values;
14106 all further processing is postponed until the template is
14107 instantiated. We need to set the type so that tsubst of a CONST_DECL
14108 works. */
14110 {
14112 values;
14116 }
14118 /* Determine the minimum and maximum values of the enumerators. */
14120 {
14124 values;
14126 {
14129 /* [dcl.enum]: Following the closing brace of an enum-specifier,
14130 each enumerator has the type of its enumeration. Prior to the
14131 closing brace, the type of each enumerator is the type of its
14132 initializing value. */
14135 /* Update the minimum and maximum values, if appropriate. */
14139 /* Figure out what the minimum and maximum values of the
14140 enumerators are. */
14147 }
14148 }
14149 else
14150 /* [dcl.enum]
14152 If the enumerator-list is empty, the underlying type is as if
14153 the enumeration had a single enumerator with value 0. */
14157 {
14158 /* Compute the number of bits require to represent all values of the
14159 enumeration. We must do this before the type of MINNODE and
14160 MAXNODE are transformed, since tree_int_cst_min_precision relies
14161 on the TREE_TYPE of the value it is passed. */
14169 /* Determine the underlying type of the enumeration.
14171 [dcl.enum]
14173 The underlying type of an enumeration is an integral type that
14174 can represent all the enumerator values defined in the
14175 enumeration. It is implementation-defined which integral type is
14176 used as the underlying type for an enumeration except that the
14177 underlying type shall not be larger than int unless the value of
14178 an enumerator cannot fit in an int or unsigned int.
14180 We use "int" or an "unsigned int" as the underlying type, even if
14181 a smaller integral type would work, unless the user has
14182 explicitly requested that we use the smallest possible type. The
14183 user can request that for all enumerations with a command line
14184 flag, or for just one enumeration with an attribute. */
14186 use_short_enum = flag_short_enums
14189 /* If the precision of the type was specified with an attribute and it
14190 was too small, give an error. Otherwise, use it. */
14192 {
14195 else
14196 {
14199 }
14200 }
14204 itk++)
14205 {
14211 }
14213 {
14214 /* DR 377
14216 IF no integral type can represent all the enumerator values, the
14217 enumeration is ill-formed. */
14222 }
14224 /* [dcl.enum]
14226 The value of sizeof() applied to an enumeration type, an object
14227 of an enumeration type, or an enumerator, is the value of sizeof()
14228 applied to the underlying type. */
14231 /* Compute the minimum and maximum values for the type.
14233 [dcl.enum]
14235 For an enumeration where emin is the smallest enumerator and emax
14236 is the largest, the values of the enumeration are the values of the
14237 underlying type in the range bmin to bmax, where bmin and bmax are,
14238 respectively, the smallest and largest values of the smallest bit-
14239 field that can store emin and emax. */
14241 /* The middle-end currently assumes that types with TYPE_PRECISION
14242 narrower than their underlying type are suitably zero or sign
14243 extended to fill their mode. Similarly, it assumes that the front
14244 end assures that a value of a particular type must be within
14245 TYPE_MIN_VALUE and TYPE_MAX_VALUE.
14247 We used to set these fields based on bmin and bmax, but that led
14248 to invalid assumptions like optimizing away bounds checking. So
14249 now we just set the TYPE_PRECISION, TYPE_MIN_VALUE, and
14250 TYPE_MAX_VALUE to the values for the mode above and only restrict
14251 the ENUM_UNDERLYING_TYPE for the benefit of diagnostics. */
14255 set_min_and_max_values_for_integral_type
14258 /* If -fstrict-enums, still constrain TYPE_MIN/MAX_VALUE. */
14261 }
14262 else
14265 /* Convert each of the enumerators to the type of the underlying
14266 type of the enumeration. */
14268 {
14269 location_t saved_location;
14275 /* If the enumeration type has a fixed underlying type, we
14276 already checked all of the enumerator values. */
14278 else
14281 tf_warning_or_error);
14284 /* Do not clobber shared ints. */
14289 }
14291 /* Fix up all variant types of this enum type. */
14298 {
14300 current_class_type);
14302 }
14304 /* Finish debugging output for this type. */
14307 /* Each enumerator now has the type of its enumeration. Clear the cache
14308 so that this change in types doesn't confuse us later on. */
14310 }
14312 /* Finishes the enum type. This is called only the first time an
14313 enumeration is seen, be it opaque or odinary.
14314 ENUMTYPE is the type object. */
14316 void
14318 {
14320 {
14324 }
14326 /* If this is a forward declaration, there should not be any variants,
14327 though we can get a variant in the middle of an enum-specifier with
14328 wacky code like 'enum E { e = sizeof(const E*) };' */
14332 }
14334 /* Build and install a CONST_DECL for an enumeration constant of the
14335 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
14336 Apply ATTRIBUTES if available. LOC is the location of NAME.
14337 Assignment of sequential values by default is handled here. */
14339 void
14341 location_t loc)
14342 {
14343 tree decl;
14344 tree context;
14345 tree type;
14347 /* scalar_constant_value will pull out this expression, so make sure
14348 it's folded as appropriate. */
14352 /* If the VALUE was erroneous, pretend it wasn't there; that will
14353 result in the enum being assigned the next value in sequence. */
14357 /* Remove no-op casts from the value. */
14362 {
14363 /* Validate and default VALUE. */
14365 {
14367 {
14372 }
14375 value = perform_implicit_conversion_flags
14383 {
14386 {
14390 }
14391 else
14392 {
14396 {
14400 }
14401 }
14402 }
14403 }
14405 /* Default based on previous value. */
14407 {
14409 {
14410 tree prev_value;
14413 /* C++03 7.2/4: If no initializer is specified for the first
14414 enumerator, the type is an unspecified integral
14415 type. Otherwise the type is the same as the type of the
14416 initializing value of the preceding enumerator unless the
14417 incremented value is not representable in that type, in
14418 which case the type is an unspecified integral type
14419 sufficient to contain the incremented value. */
14423 else
14424 {
14430 {
14433 {
14436 {
14442 }
14448 }
14451 else
14453 }
14456 {
14459 }
14460 }
14461 }
14462 else
14464 }
14466 /* Remove no-op casts from the value. */
14469 /* If the underlying type of the enum is fixed, check whether
14470 the enumerator values fits in the underlying type. If it
14471 does not fit, the program is ill-formed [C++0x dcl.enum]. */
14473 && value
14475 {
14480 /* Convert the value to the appropriate type. */
14482 }
14483 }
14485 /* C++ associates enums with global, function, or class declarations. */
14488 /* Build the actual enumeration constant. Note that the enumeration
14489 constants have the underlying type of the enum (if it is fixed)
14490 or the type of their initializer (if the underlying type of the
14491 enum is not fixed):
14493 [ C++0x dcl.enum ]
14495 If the underlying type is fixed, the type of each enumerator
14496 prior to the closing brace is the underlying type; if the
14497 initializing value of an enumerator cannot be represented by
14498 the underlying type, the program is ill-formed. If the
14499 underlying type is not fixed, the type of each enumerator is
14500 the type of its initializing value.
14502 If the underlying type is not fixed, it will be computed by
14503 finish_enum and we will reset the type of this enumerator. Of
14504 course, if we're processing a template, there may be no value. */
14518 {
14519 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
14520 on the TYPE_FIELDS list for `S'. (That's so that you can say
14521 things like `S::i' later.) */
14523 /* The enumerator may be getting declared outside of its enclosing
14524 class, like so:
14526 class S { public: enum E : int; }; enum S::E : int { i = 7; };
14528 For which case we need to make sure that the access of `S::i'
14529 matches the access of `S::E'. */
14535 else
14541 }
14542 else
14545 /* Add this enumeration constant to the list for this type. */
14547 }
14549 /* Look for an enumerator with the given NAME within the enumeration
14550 type ENUMTYPE. This routine is used primarily for qualified name
14551 lookup into an enumerator in C++0x, e.g.,
14553 enum class Color { Red, Green, Blue };
14555 Color color = Color::Red;
14557 Returns the value corresponding to the enumerator, or
14558 NULL_TREE if no such enumerator was found. */
14559 tree
14561 {
14562 tree e;
14567 }
14569 \f
14570 /* We're defining DECL. Make sure that its type is OK. */
14572 static void
14574 {
14578 /* In a function definition, arg types must be complete. */
14585 {
14590 /* Make it return void instead. */
14593 void_type_node,
14595 else
14597 fntype
14600 fntype = (cp_build_type_attribute_variant
14603 }
14604 else
14606 }
14608 /* True iff FN is an implicitly-defined default constructor. */
14610 static bool
14612 {
14616 }
14618 /* Clobber the contents of *this to let the back end know that the object
14619 storage is dead when we enter the constructor or leave the destructor. */
14621 static tree
14623 {
14624 /* Clobbering an empty base is pointless, and harmful if its one byte
14625 TYPE_SIZE overlays real data. */
14629 /* If we have virtual bases, clobber the whole object, but only if we're in
14630 charge. If we don't have virtual bases, clobber the as-base type so we
14631 don't mess with tail padding. */
14643 {
14646 }
14653 }
14655 /* Create the FUNCTION_DECL for a function definition.
14656 DECLSPECS and DECLARATOR are the parts of the declaration;
14657 they describe the function's name and the type it returns,
14658 but twisted together in a fashion that parallels the syntax of C.
14660 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
14661 DECLARATOR is really the DECL for the function we are about to
14662 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
14663 indicating that the function is an inline defined in-class.
14665 This function creates a binding context for the function body
14666 as well as setting up the FUNCTION_DECL in current_function_decl.
14668 For C++, we must first check whether that datum makes any sense.
14669 For example, "class A local_a(1,2);" means that variable local_a
14670 is an aggregate of type A, which should have a constructor
14671 applied to it with the argument list [1, 2].
14673 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
14674 or may be a BLOCK if the function has been defined previously
14675 in this translation unit. On exit, DECL_INITIAL (decl1) will be
14676 error_mark_node if the function has never been defined, or
14677 a BLOCK if the function has been defined somewhere. */
14679 bool
14681 {
14683 tree fntype;
14684 tree restype;
14687 tree current_function_parms;
14692 /* Sanity check. */
14700 /* ISO C++ 11.4/5. A friend function defined in a class is in
14701 the (lexical) scope of the class in which it is defined. */
14703 {
14706 /* CTYPE could be null here if we're dealing with a template;
14707 for example, `inline friend float foo()' inside a template
14708 will have no CTYPE set. */
14711 else
14713 }
14720 /* Handle gnu_inline attribute. */
14722 {
14727 }
14730 /* This is a constructor, we must ensure that any default args
14731 introduced by this definition are propagated to the clones
14732 now. The clones are used directly in overload resolution. */
14735 /* Sometimes we don't notice that a function is a static member, and
14736 build a METHOD_TYPE for it. Fix that up now. */
14740 /* Set up current_class_type, and enter the scope of the class, if
14741 appropriate. */
14747 /* Now that we have entered the scope of the class, we must restore
14748 the bindings for any template parameters surrounding DECL1, if it
14749 is an inline member template. (Order is important; consider the
14750 case where a template parameter has the same name as a field of
14751 the class.) It is not until after this point that
14752 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
14756 /* Effective C++ rule 15. */
14762 /* Make the init_value nonzero so pushdecl knows this is not tentative.
14763 error_mark_node is replaced below (in poplevel) with the BLOCK. */
14767 /* This function exists in static storage.
14768 (This does not mean `static' in the C sense!) */
14771 /* We must call push_template_decl after current_class_type is set
14772 up. (If we are processing inline definitions after exiting a
14773 class scope, current_class_type will be NULL_TREE until set above
14774 by push_nested_class.) */
14776 {
14779 {
14783 }
14785 }
14787 /* We are now in the scope of the function being defined. */
14790 /* Save the parm names or decls from this function's declarator
14791 where store_parm_decls will find them. */
14794 /* Make sure the parameter and return types are reasonable. When
14795 you declare a function, these types can be incomplete, but they
14796 must be complete when you define the function. */
14799 /* Build the return declaration for the function. */
14803 {
14804 tree resdecl;
14812 }
14814 /* Let the user know we're compiling this function. */
14817 /* Record the decl so that the function name is defined.
14818 If we already have a decl for this name, and it is a FUNCTION_DECL,
14819 use the old decl. */
14821 {
14822 /* A specialization is not used to guide overload resolution. */
14826 {
14830 /* If something went wrong when registering the declaration,
14831 use DECL1; we have to have a FUNCTION_DECL to use when
14832 parsing the body of the function. */
14833 ;
14834 else
14835 {
14836 /* Otherwise, OLDDECL is either a previous declaration
14837 of the same function or DECL1 itself. */
14844 {
14845 tree context;
14847 /* Check whether DECL1 is in an anonymous
14848 namespace. */
14850 context;
14852 {
14856 }
14860 OPT_Wmissing_declarations,
14862 }
14865 }
14866 }
14867 else
14868 {
14869 /* We need to set the DECL_CONTEXT. */
14872 }
14876 /* If #pragma weak applies, mark the decl appropriately now.
14877 The pragma only applies to global functions. Because
14878 determining whether or not the #pragma applies involves
14879 computing the mangled name for the declaration, we cannot
14880 apply the pragma until after we have merged this declaration
14881 with any previous declarations; if the original declaration
14882 has a linkage specification, that specification applies to
14883 the definition as well, and may affect the mangled name. */
14886 }
14888 /* Reset this in case the call to pushdecl changed it. */
14893 /* This function may already have been parsed, in which case just
14894 return; our caller will skip over the body without parsing. */
14898 /* Initialize RTL machinery. We cannot do this until
14899 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
14900 even when processing a template; this is how we get
14901 CFUN set up, and our per-function variables initialized.
14902 FIXME factor out the non-RTL stuff. */
14906 /* Initialize the language data structures. Whenever we start
14907 a new function, we destroy temporaries in the usual way. */
14913 {
14916 }
14918 /* Start the statement-tree, start the tree now. */
14921 /* If we are (erroneously) defining a function that we have already
14922 defined before, wipe out what we knew before. */
14927 {
14928 /* We know that this was set up by `grokclassfn'. We do not
14929 wait until `store_parm_decls', since evil parse errors may
14930 never get us to that point. Here we keep the consistency
14931 between `current_class_type' and `current_class_ptr'. */
14937 cp_function_chain->x_current_class_ref
14939 /* Set this second to avoid shortcut in cp_build_indirect_ref. */
14942 /* Constructors and destructors need to know whether they're "in
14943 charge" of initializing virtual base classes. */
14946 {
14949 }
14951 {
14954 }
14955 }
14958 /* Implicitly-defined methods (like the
14959 destructor for a class in which no destructor
14960 is explicitly declared) must not be defined
14961 until their definition is needed. So, we
14962 ignore interface specifications for
14963 compiler-generated functions. */
14969 {
14976 /* This is a function in a local class in an extern inline
14977 or template function. */
14979 }
14980 /* If this function belongs to an interface, it is public.
14981 If it belongs to someone else's interface, it is also external.
14982 This only affects inlines and template instantiations. */
14984 {
14987 {
14991 && ! flag_implement_inlines
14994 /* For WIN32 we also want to put these in linkonce sections. */
14996 }
14997 else
15000 /* If this function is in an interface implemented in this file,
15001 make sure that the back end knows to emit this function
15002 here. */
15005 }
15008 {
15009 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
15010 interface, we will have both finfo->interface_unknown and
15011 finfo->interface_only set. In that case, we don't want to
15012 use the normal heuristics because someone will supply a
15013 #pragma implementation elsewhere, and deducing it here would
15014 produce a conflict. */
15019 }
15020 else
15021 {
15022 /* This is a definition, not a reference.
15023 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
15031 else
15033 }
15035 /* Determine the ELF visibility attribute for the function. We must not
15036 do this before calling "pushdecl", as we must allow "duplicate_decls"
15037 to merge any attributes appropriately. We also need to wait until
15038 linkage is set. */
15062 /* Clobbering an empty base is harmful if it overlays real data. */
15064 /* We can't clobber safely for an implicitly-defined default constructor
15065 because part of the initialization might happen before we enter the
15066 constructor, via AGGR_INIT_ZERO_FIRST (c++/68006). */
15078 }
15081 /* Like start_preparsed_function, except that instead of a
15082 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
15084 Returns true on success. If the DECLARATOR is not suitable
15085 for a function, we return false, which tells the parser to
15086 skip the entire function. */
15088 bool
15091 tree attrs)
15092 {
15093 tree decl1;
15099 /* If the declarator is not suitable for a function definition,
15100 cause a syntax error. */
15102 {
15105 }
15108 /* main must return int. grokfndecl should have corrected it
15109 (and issued a diagnostic) if the user got it wrong. */
15111 integer_type_node));
15114 }
15115 \f
15116 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
15117 FN. */
15119 static bool
15121 {
15123 && !processing_template_decl
15125 /* We insert the EH_SPEC_BLOCK only in the original
15126 function; then, it is copied automatically to the
15127 clones. */
15129 /* Implicitly-generated constructors and destructors have
15130 exception specifications. However, those specifications
15131 are the union of the possible exceptions specified by the
15132 constructors/destructors for bases and members, so no
15133 unallowed exception will ever reach this function. By
15134 not creating the EH_SPEC_BLOCK we save a little memory,
15135 and we avoid spurious warnings about unreachable
15136 code. */
15138 }
15140 /* Store the parameter declarations into the current function declaration.
15141 This is called after parsing the parameter declarations, before
15142 digesting the body of the function.
15144 Also install to binding contour return value identifier, if any. */
15146 static void
15148 {
15150 tree parm;
15152 /* This is a chain of any other decls that came in among the parm
15153 declarations. If a parm is declared with enum {foo, bar} x;
15154 then CONST_DECLs for foo and bar are put here. */
15158 {
15159 /* This case is when the function was defined with an ANSI prototype.
15160 The parms already have decls, so we need not do anything here
15161 except record them as in effect
15162 and complain if any redundant old-style parm decls were written. */
15165 tree next;
15167 /* Must clear this because it might contain TYPE_DECLs declared
15168 at class level. */
15171 /* If we're doing semantic analysis, then we'll call pushdecl
15172 for each of these. We must do them in reverse order so that
15173 they end in the correct forward order. */
15177 {
15181 else
15182 {
15183 /* If we find an enum constant or a type tag,
15184 put it aside for the moment. */
15187 }
15188 }
15190 /* Get the decls in their original chain order and record in the
15191 function. This is all and only the PARM_DECLs that were
15192 pushed into scope by the loop above. */
15194 }
15195 else
15198 /* Now store the final chain of decls for the arguments
15199 as the decl-chain of the current lexical scope.
15200 Put the enumerators in as well, at the front so that
15201 DECL_ARGUMENTS is not modified. */
15206 }
15208 \f
15209 /* We have finished doing semantic analysis on DECL, but have not yet
15210 generated RTL for its body. Save away our current state, so that
15211 when we want to generate RTL later we know what to do. */
15213 static void
15215 {
15218 /* Save the language-specific per-function data so that we can
15219 get it back when we really expand this function. */
15222 /* Make a copy. */
15227 /* Clear out the bits we don't need. */
15232 }
15235 /* Set the return value of the constructor (if present). */
15237 static void
15239 {
15240 tree val;
15241 tree exprstmt;
15244 {
15245 /* Any return from a constructor will end up here. */
15251 /* Return the address of the object. */
15254 }
15255 }
15257 /* Do all the processing for the beginning of a destructor; set up the
15258 vtable pointers and cleanups for bases and members. */
15260 static void
15262 {
15263 tree compound_stmt;
15265 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
15266 issued an error message. We still want to try to process the
15267 body of the function, but initialize_vtbl_ptrs will crash if
15268 TYPE_BINFO is NULL. */
15270 {
15272 /* Make all virtual function table pointers in non-virtual base
15273 classes point to CURRENT_CLASS_TYPE's virtual function
15274 tables. */
15279 /* Clobbering an empty base is harmful if it overlays real data. */
15283 /* And insert cleanups for our bases and members so that they
15284 will be properly destroyed if we throw. */
15286 }
15287 }
15289 /* At the end of every destructor we generate code to delete the object if
15290 necessary. Do that now. */
15292 static void
15294 {
15295 tree exprstmt;
15297 /* Any return from a destructor will end up here; that way all base
15298 and member cleanups will be run when the function returns. */
15302 {
15303 tree val;
15308 /* Return the address of the object. */
15311 }
15312 }
15314 /* Do the necessary processing for the beginning of a function body, which
15315 in this case includes member-initializers, but not the catch clauses of
15316 a function-try-block. Currently, this means opening a binding level
15317 for the member-initializers (in a ctor), member cleanups (in a dtor),
15318 and capture proxies (in a lambda operator()). */
15320 tree
15322 {
15323 tree stmt;
15330 else
15331 /* Always keep the BLOCK node associated with the outermost pair of
15332 curly braces of a function. These are needed for correct
15333 operation of dwarfout.c. */
15344 }
15346 /* Do the processing for the end of a function body. Currently, this means
15347 closing out the cleanups for fully-constructed bases and members, and in
15348 the case of the destructor, deleting the object if desired. Again, this
15349 is only meaningful for [cd]tors, since they are the only functions where
15350 there is a significant distinction between the main body and any
15351 function catch clauses. Handling, say, main() return semantics here
15352 would be wrong, as flowing off the end of a function catch clause for
15353 main() would also need to return 0. */
15355 void
15357 {
15361 /* Close the block. */
15370 }
15372 /* Given a function, returns the BLOCK corresponding to the outermost level
15373 of curly braces, skipping the artificial block created for constructor
15374 initializers. */
15376 tree
15378 {
15388 }
15390 /* If FNDECL is a class's key method, add the class to the list of
15391 keyed classes that should be emitted. */
15393 static void
15395 {
15399 {
15403 }
15404 }
15406 /* Subroutine of finish_function.
15407 Save the body of constexpr functions for possible
15408 future compile time evaluation. */
15410 static void
15412 {
15418 }
15420 /* Finish up a function declaration and compile that function
15421 all the way to assembler language output. The free the storage
15422 for the function definition.
15424 FLAGS is a bitwise or of the following values:
15425 2 - INCLASS_INLINE
15426 We just finished processing the body of an in-class inline
15427 function definition. (This processing will have taken place
15428 after the class definition is complete.) */
15430 tree
15432 {
15437 /* When we get some parse errors, we can end up without a
15438 current_function_decl, so cope. */
15449 /* TREE_READONLY (fndecl) = 1;
15450 This caused &foo to be of type ptr-to-const-function
15451 which then got a warning when stored in a ptr-to-function variable. */
15454 /* The current function is being defined, so its DECL_INITIAL should
15455 be set, and unless there's a multiple definition, it should be
15456 error_mark_node. */
15459 /* For a cloned function, we've already got all the code we need;
15460 there's no need to add any extra bits. */
15462 {
15463 /* Make it so that `main' always returns 0 by default. */
15470 current_eh_spec_block);
15471 }
15473 /* If we're saving up tree structure, tie off the function now. */
15481 /* If this function can't throw any exceptions, remember that. */
15484 && !flag_non_call_exceptions
15488 /* This must come after expand_function_end because cleanups might
15489 have declarations (from inline functions) that need to go into
15490 this function's blocks. */
15492 /* If the current binding level isn't the outermost binding level
15493 for this function, either there is a bug, or we have experienced
15494 syntax errors and the statement tree is malformed. */
15496 {
15497 /* Make sure we have already experienced errors. */
15500 /* Throw away the broken statement tree and extra binding
15501 levels. */
15505 {
15508 else
15510 }
15511 }
15514 /* Statements should always be full-expressions at the outermost set
15515 of curly braces for a function. */
15518 /* If there are no return statements in a function with auto return type,
15519 the return type is void. But if the declared type is something like
15520 auto*, this is an error. */
15523 {
15526 {
15528 current_function_auto_return_pattern);
15531 }
15534 }
15536 // If this is a concept, check that the definition is reasonable.
15540 /* Lambda closure members are implicitly constexpr if possible. */
15543 && (processing_template_decl
15548 /* Save constexpr function body before it gets munged by
15549 the NRV transformation. */
15552 /* Invoke the pre-genericize plugin before we start munging things. */
15556 /* Perform delayed folding before NRV transformation. */
15560 /* Set up the named return value optimization, if we can. Candidate
15561 variables are selected in check_return_expr. */
15563 {
15565 tree outer;
15568 /* This is only worth doing for fns that return in memory--and
15569 simpler, since we don't have to worry about promoted modes. */
15571 /* Only allow this for variables declared in the outer scope of
15572 the function so we know that their lifetime always ends with a
15573 return; see g++.dg/opt/nrv6.C. We could be more flexible if
15574 we were to do this optimization in tree-ssa. */
15580 }
15582 /* Remember that we were in class scope. */
15586 /* Must mark the RESULT_DECL as being in this function. */
15589 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
15590 to the FUNCTION_DECL node itself. */
15593 /* Save away current state, if appropriate. */
15597 /* Complain if there's just no return statement. */
15602 /* Don't complain if we abort or throw. */
15603 && !current_function_returns_abnormally
15604 /* Don't complain if there's an infinite loop. */
15605 && !current_function_infinite_loop
15606 /* Don't complain if we are declared noreturn. */
15610 /* Structor return values (if any) are set by the compiler. */
15614 {
15618 }
15620 /* Store the end of the function, so that we get good line number
15621 info for the epilogue. */
15624 /* Complain about parameters that are only set, but never otherwise used. */
15626 && !processing_template_decl
15629 {
15630 tree decl;
15633 decl;
15647 OPT_Wunused_but_set_parameter,
15650 }
15652 /* Complain about locally defined typedefs that are not used in this
15653 function. */
15656 /* Possibly warn about unused parameters. */
15658 && !processing_template_decl
15662 /* Genericize before inlining. */
15664 {
15667 /* Clear out the bits we don't need. */
15677 }
15678 /* Clear out the bits we don't need. */
15681 /* We're leaving the context of this function, so zap cfun. It's still in
15682 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
15686 /* If this is an in-class inline definition, we may have to pop the
15687 bindings for the template parameters that we added in
15688 maybe_begin_member_template_processing when start_function was
15689 called. */
15693 /* Leave the scope of the class. */
15699 /* Clean up. */
15704 }
15705 \f
15706 /* Create the FUNCTION_DECL for a function definition.
15707 DECLSPECS and DECLARATOR are the parts of the declaration;
15708 they describe the return type and the name of the function,
15709 but twisted together in a fashion that parallels the syntax of C.
15711 This function creates a binding context for the function body
15712 as well as setting up the FUNCTION_DECL in current_function_decl.
15714 Returns a FUNCTION_DECL on success.
15716 If the DECLARATOR is not suitable for a function (it defines a datum
15717 instead), we return 0, which tells yyparse to report a parse error.
15719 May return void_type_node indicating that this method is actually
15720 a friend. See grokfield for more details.
15722 Came here with a `.pushlevel' .
15724 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
15725 CHANGES TO CODE IN `grokfield'. */
15727 tree
15730 {
15738 {
15741 }
15746 /* Pass friends other than inline friend functions back. */
15751 {
15756 }
15765 /* We process method specializations in finish_struct_1. */
15767 {
15771 }
15774 {
15776 {
15779 }
15780 }
15786 }
15787 \f
15789 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
15790 we can lay it out later, when and if its type becomes complete.
15792 Also handle constexpr variables where the initializer involves
15793 an unlowered PTRMEM_CST because the class isn't complete yet. */
15795 void
15797 {
15800 /* Keep track of variables with incomplete types. */
15803 {
15811 /* RTTI TD entries are created while defining the type_info. */
15814 {
15817 }
15821 {
15822 /* When the outermost open class is complete we can resolve any
15823 pointers-to-members. */
15827 }
15828 }
15829 }
15831 /* Called when a class type (given by TYPE) is defined. If there are
15832 any existing VAR_DECLs whose type has been completed by this
15833 declaration, update them now. */
15835 void
15837 {
15842 {
15844 {
15851 {
15852 /* Complete the type of the variable. The VAR_DECL itself
15853 will be laid out in expand_expr. */
15856 }
15858 /* Remove this entry from the list. */
15860 }
15861 else
15862 ix++;
15863 }
15865 /* Check for pending declarations which may have abstract type. */
15867 }
15869 /* If DECL is of a type which needs a cleanup, build and return an
15870 expression to perform that cleanup here. Return NULL_TREE if no
15871 cleanup need be done. DECL can also be a _REF when called from
15872 split_nonconstant_init_1. */
15874 tree
15876 {
15877 tree type;
15878 tree attr;
15879 tree cleanup;
15881 /* Assume no cleanup is required. */
15887 /* Handle "__attribute__((cleanup))". We run the cleanup function
15888 before the destructor since the destructor is what actually
15889 terminates the lifetime of the object. */
15892 else
15895 {
15896 tree id;
15897 tree fn;
15898 tree arg;
15900 /* Get the name specified by the user for the cleanup function. */
15902 /* Look up the name to find the cleanup function to call. It is
15903 important to use lookup_name here because that is what is
15904 used in c-common.c:handle_cleanup_attribute when performing
15905 initial checks on the attribute. Note that those checks
15906 include ensuring that the function found is not an overloaded
15907 function, or an object with an overloaded call operator,
15908 etc.; we can rely on the fact that the function found is an
15909 ordinary FUNCTION_DECL. */
15917 }
15918 /* Handle ordinary C++ destructors. */
15921 {
15923 tree addr;
15924 tree call;
15928 else
15939 else
15941 }
15943 /* build_delete sets the location of the destructor call to the
15944 current location, even though the destructor is going to be
15945 called later, at the end of the current scope. This can lead to
15946 a "jumpy" behavior for users of debuggers when they step around
15947 the end of the block. So let's unset the location of the
15948 destructor call instead. */
15954 /* Treat objects with destructors as used; the destructor may do
15955 something substantive. */
15960 }
15962 \f
15963 /* Return the FUNCTION_TYPE that corresponds to MEMFNTYPE, which can be a
15964 FUNCTION_DECL, METHOD_TYPE, FUNCTION_TYPE, pointer or reference to
15965 METHOD_TYPE or FUNCTION_TYPE, or pointer to member function. */
15967 tree
15969 {
15970 tree fntype;
15971 tree args;
15985 fntype = (cp_build_type_attribute_variant
15987 fntype = (build_exception_variant
15992 }
15994 /* DECL was originally constructed as a non-static member function,
15995 but turned out to be static. Update it accordingly. */
15997 void
15999 {
16012 }
16014 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
16015 one of the language-independent trees. */
16017 enum cp_tree_node_structure_enum
16019 {
16021 {
16038 }
16039 }
16041 /* Build the void_list_node (void_type_node having been created). */
16042 tree
16044 {
16047 }
16049 bool
16051 {
16052 /* A missing noreturn is ok for the `main' function. */
16054 }
16056 /* Return the decl used to identify the COMDAT group into which DECL should
16057 be placed. */
16059 tree
16061 {
16062 /* Virtual tables, construction virtual tables, and virtual table
16063 tables all go in a single COMDAT group, named after the primary
16064 virtual table. */
16067 /* For all other DECLs, the COMDAT group is the mangled name of the
16068 declaration itself. */
16069 else
16070 {
16072 {
16073 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
16074 into the same section as the target function. In that case
16075 we must return target's name. */
16081 else
16083 }
16084 }
16087 }
16089 /* Returns the return type for FN as written by the user, which may include
16090 a placeholder for a deduced return type. */
16092 tree
16094 {
16097 {
16104 }
16106 }
16108 /* Returns true iff DECL was declared with an auto return type and it has
16109 not yet been deduced to a real type. */
16111 bool
16113 {
16117 }
16119 /* Complain if DECL has an undeduced return type. */
16121 void
16123 {
16126 }