1 /* Perform the semantic phase of parsing, i.e., the process of
2 building tree structure, checking semantic consistency, and
3 building RTL. These routines are used both during actual parsing
4 and during the instantiation of template functions.
6 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
7 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
8 Written by Mark Mitchell (mmitchell@usa.net) based on code found
9 formerly in parse.y and pt.c.
11 This file is part of GCC.
13 GCC is free software; you can redistribute it and/or modify it
14 under the terms of the GNU General Public License as published by
15 the Free Software Foundation; either version 3, or (at your option)
18 GCC is distributed in the hope that it will be useful, but
19 WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 General Public License for more details.
23 You should have received a copy of the GNU General Public License
24 along with GCC; see the file COPYING3. If not see
25 <http://www.gnu.org/licenses/>. */
29 #include "coretypes.h"
33 #include "c-family/c-common.h"
34 #include "c-family/c-objc.h"
35 #include "tree-inline.h"
36 #include "tree-mudflap.h"
41 #include "diagnostic.h"
43 #include "tree-iterator.h"
49 /* There routines provide a modular interface to perform many parsing
50 operations. They may therefore be used during actual parsing, or
51 during template instantiation, which may be regarded as a
52 degenerate form of parsing. */
54 static tree
maybe_convert_cond (tree
);
55 static tree
finalize_nrv_r (tree
*, int *, void *);
56 static tree
capture_decltype (tree
);
57 static tree
thisify_lambda_field (tree
);
60 /* Deferred Access Checking Overview
61 ---------------------------------
63 Most C++ expressions and declarations require access checking
64 to be performed during parsing. However, in several cases,
65 this has to be treated differently.
67 For member declarations, access checking has to be deferred
68 until more information about the declaration is known. For
80 When we are parsing the function return type `A::X', we don't
81 really know if this is allowed until we parse the function name.
83 Furthermore, some contexts require that access checking is
84 never performed at all. These include class heads, and template
87 Typical use of access checking functions is described here:
89 1. When we enter a context that requires certain access checking
90 mode, the function `push_deferring_access_checks' is called with
91 DEFERRING argument specifying the desired mode. Access checking
92 may be performed immediately (dk_no_deferred), deferred
93 (dk_deferred), or not performed (dk_no_check).
95 2. When a declaration such as a type, or a variable, is encountered,
96 the function `perform_or_defer_access_check' is called. It
97 maintains a VEC of all deferred checks.
99 3. The global `current_class_type' or `current_function_decl' is then
100 setup by the parser. `enforce_access' relies on these information
103 4. Upon exiting the context mentioned in step 1,
104 `perform_deferred_access_checks' is called to check all declaration
105 stored in the VEC. `pop_deferring_access_checks' is then
106 called to restore the previous access checking mode.
108 In case of parsing error, we simply call `pop_deferring_access_checks'
109 without `perform_deferred_access_checks'. */
111 typedef struct GTY(()) deferred_access
{
112 /* A VEC representing name-lookups for which we have deferred
113 checking access controls. We cannot check the accessibility of
114 names used in a decl-specifier-seq until we know what is being
115 declared because code like:
122 A::B* A::f() { return 0; }
124 is valid, even though `A::B' is not generally accessible. */
125 VEC (deferred_access_check
,gc
)* GTY(()) deferred_access_checks
;
127 /* The current mode of access checks. */
128 enum deferring_kind deferring_access_checks_kind
;
131 DEF_VEC_O (deferred_access
);
132 DEF_VEC_ALLOC_O (deferred_access
,gc
);
134 /* Data for deferred access checking. */
135 static GTY(()) VEC(deferred_access
,gc
) *deferred_access_stack
;
136 static GTY(()) unsigned deferred_access_no_check
;
138 /* Save the current deferred access states and start deferred
139 access checking iff DEFER_P is true. */
142 push_deferring_access_checks (deferring_kind deferring
)
144 /* For context like template instantiation, access checking
145 disabling applies to all nested context. */
146 if (deferred_access_no_check
|| deferring
== dk_no_check
)
147 deferred_access_no_check
++;
150 deferred_access
*ptr
;
152 ptr
= VEC_safe_push (deferred_access
, gc
, deferred_access_stack
, NULL
);
153 ptr
->deferred_access_checks
= NULL
;
154 ptr
->deferring_access_checks_kind
= deferring
;
158 /* Resume deferring access checks again after we stopped doing
162 resume_deferring_access_checks (void)
164 if (!deferred_access_no_check
)
165 VEC_last (deferred_access
, deferred_access_stack
)
166 ->deferring_access_checks_kind
= dk_deferred
;
169 /* Stop deferring access checks. */
172 stop_deferring_access_checks (void)
174 if (!deferred_access_no_check
)
175 VEC_last (deferred_access
, deferred_access_stack
)
176 ->deferring_access_checks_kind
= dk_no_deferred
;
179 /* Discard the current deferred access checks and restore the
183 pop_deferring_access_checks (void)
185 if (deferred_access_no_check
)
186 deferred_access_no_check
--;
188 VEC_pop (deferred_access
, deferred_access_stack
);
191 /* Returns a TREE_LIST representing the deferred checks.
192 The TREE_PURPOSE of each node is the type through which the
193 access occurred; the TREE_VALUE is the declaration named.
196 VEC (deferred_access_check
,gc
)*
197 get_deferred_access_checks (void)
199 if (deferred_access_no_check
)
202 return (VEC_last (deferred_access
, deferred_access_stack
)
203 ->deferred_access_checks
);
206 /* Take current deferred checks and combine with the
207 previous states if we also defer checks previously.
208 Otherwise perform checks now. */
211 pop_to_parent_deferring_access_checks (void)
213 if (deferred_access_no_check
)
214 deferred_access_no_check
--;
217 VEC (deferred_access_check
,gc
) *checks
;
218 deferred_access
*ptr
;
220 checks
= (VEC_last (deferred_access
, deferred_access_stack
)
221 ->deferred_access_checks
);
223 VEC_pop (deferred_access
, deferred_access_stack
);
224 ptr
= VEC_last (deferred_access
, deferred_access_stack
);
225 if (ptr
->deferring_access_checks_kind
== dk_no_deferred
)
228 perform_access_checks (checks
);
232 /* Merge with parent. */
234 deferred_access_check
*chk
, *probe
;
236 FOR_EACH_VEC_ELT (deferred_access_check
, checks
, i
, chk
)
238 FOR_EACH_VEC_ELT (deferred_access_check
,
239 ptr
->deferred_access_checks
, j
, probe
)
241 if (probe
->binfo
== chk
->binfo
&&
242 probe
->decl
== chk
->decl
&&
243 probe
->diag_decl
== chk
->diag_decl
)
246 /* Insert into parent's checks. */
247 VEC_safe_push (deferred_access_check
, gc
,
248 ptr
->deferred_access_checks
, chk
);
255 /* Perform the access checks in CHECKS. The TREE_PURPOSE of each node
256 is the BINFO indicating the qualifying scope used to access the
257 DECL node stored in the TREE_VALUE of the node. */
260 perform_access_checks (VEC (deferred_access_check
,gc
)* checks
)
263 deferred_access_check
*chk
;
268 FOR_EACH_VEC_ELT (deferred_access_check
, checks
, i
, chk
)
269 enforce_access (chk
->binfo
, chk
->decl
, chk
->diag_decl
);
272 /* Perform the deferred access checks.
274 After performing the checks, we still have to keep the list
275 `deferred_access_stack->deferred_access_checks' since we may want
276 to check access for them again later in a different context.
283 A::X A::a, x; // No error for `A::a', error for `x'
285 We have to perform deferred access of `A::X', first with `A::a',
289 perform_deferred_access_checks (void)
291 perform_access_checks (get_deferred_access_checks ());
294 /* Defer checking the accessibility of DECL, when looked up in
295 BINFO. DIAG_DECL is the declaration to use to print diagnostics. */
298 perform_or_defer_access_check (tree binfo
, tree decl
, tree diag_decl
)
301 deferred_access
*ptr
;
302 deferred_access_check
*chk
;
303 deferred_access_check
*new_access
;
306 /* Exit if we are in a context that no access checking is performed.
308 if (deferred_access_no_check
)
311 gcc_assert (TREE_CODE (binfo
) == TREE_BINFO
);
313 ptr
= VEC_last (deferred_access
, deferred_access_stack
);
315 /* If we are not supposed to defer access checks, just check now. */
316 if (ptr
->deferring_access_checks_kind
== dk_no_deferred
)
318 enforce_access (binfo
, decl
, diag_decl
);
322 /* See if we are already going to perform this check. */
323 FOR_EACH_VEC_ELT (deferred_access_check
,
324 ptr
->deferred_access_checks
, i
, chk
)
326 if (chk
->decl
== decl
&& chk
->binfo
== binfo
&&
327 chk
->diag_decl
== diag_decl
)
332 /* If not, record the check. */
334 VEC_safe_push (deferred_access_check
, gc
,
335 ptr
->deferred_access_checks
, 0);
336 new_access
->binfo
= binfo
;
337 new_access
->decl
= decl
;
338 new_access
->diag_decl
= diag_decl
;
341 /* Used by build_over_call in LOOKUP_SPECULATIVE mode: return whether DECL
342 is accessible in BINFO, and possibly complain if not. If we're not
343 checking access, everything is accessible. */
346 speculative_access_check (tree binfo
, tree decl
, tree diag_decl
,
349 if (deferred_access_no_check
)
352 /* If we're checking for implicit delete, we don't want access
354 if (!accessible_p (binfo
, decl
, true))
356 /* Unless we're under maybe_explain_implicit_delete. */
358 enforce_access (binfo
, decl
, diag_decl
);
365 /* Returns nonzero if the current statement is a full expression,
366 i.e. temporaries created during that statement should be destroyed
367 at the end of the statement. */
370 stmts_are_full_exprs_p (void)
372 return current_stmt_tree ()->stmts_are_full_exprs_p
;
375 /* T is a statement. Add it to the statement-tree. This is the C++
376 version. The C/ObjC frontends have a slightly different version of
382 enum tree_code code
= TREE_CODE (t
);
384 if (EXPR_P (t
) && code
!= LABEL_EXPR
)
386 if (!EXPR_HAS_LOCATION (t
))
387 SET_EXPR_LOCATION (t
, input_location
);
389 /* When we expand a statement-tree, we must know whether or not the
390 statements are full-expressions. We record that fact here. */
391 STMT_IS_FULL_EXPR_P (t
) = stmts_are_full_exprs_p ();
394 /* Add T to the statement-tree. Non-side-effect statements need to be
395 recorded during statement expressions. */
396 gcc_checking_assert (!VEC_empty (tree
, stmt_list_stack
));
397 append_to_statement_list_force (t
, &cur_stmt_list
);
402 /* Returns the stmt_tree to which statements are currently being added. */
405 current_stmt_tree (void)
408 ? &cfun
->language
->base
.x_stmt_tree
409 : &scope_chain
->x_stmt_tree
);
412 /* If statements are full expressions, wrap STMT in a CLEANUP_POINT_EXPR. */
415 maybe_cleanup_point_expr (tree expr
)
417 if (!processing_template_decl
&& stmts_are_full_exprs_p ())
418 expr
= fold_build_cleanup_point_expr (TREE_TYPE (expr
), expr
);
422 /* Like maybe_cleanup_point_expr except have the type of the new expression be
423 void so we don't need to create a temporary variable to hold the inner
424 expression. The reason why we do this is because the original type might be
425 an aggregate and we cannot create a temporary variable for that type. */
428 maybe_cleanup_point_expr_void (tree expr
)
430 if (!processing_template_decl
&& stmts_are_full_exprs_p ())
431 expr
= fold_build_cleanup_point_expr (void_type_node
, expr
);
437 /* Create a declaration statement for the declaration given by the DECL. */
440 add_decl_expr (tree decl
)
442 tree r
= build_stmt (input_location
, DECL_EXPR
, decl
);
443 if (DECL_INITIAL (decl
)
444 || (DECL_SIZE (decl
) && TREE_SIDE_EFFECTS (DECL_SIZE (decl
))))
445 r
= maybe_cleanup_point_expr_void (r
);
449 /* Finish a scope. */
452 do_poplevel (tree stmt_list
)
456 if (stmts_are_full_exprs_p ())
457 block
= poplevel (kept_level_p (), 1, 0);
459 stmt_list
= pop_stmt_list (stmt_list
);
461 if (!processing_template_decl
)
463 stmt_list
= c_build_bind_expr (input_location
, block
, stmt_list
);
464 /* ??? See c_end_compound_stmt re statement expressions. */
470 /* Begin a new scope. */
473 do_pushlevel (scope_kind sk
)
475 tree ret
= push_stmt_list ();
476 if (stmts_are_full_exprs_p ())
477 begin_scope (sk
, NULL
);
481 /* Queue a cleanup. CLEANUP is an expression/statement to be executed
482 when the current scope is exited. EH_ONLY is true when this is not
483 meant to apply to normal control flow transfer. */
486 push_cleanup (tree decl
, tree cleanup
, bool eh_only
)
488 tree stmt
= build_stmt (input_location
, CLEANUP_STMT
, NULL
, cleanup
, decl
);
489 CLEANUP_EH_ONLY (stmt
) = eh_only
;
491 CLEANUP_BODY (stmt
) = push_stmt_list ();
494 /* Begin a conditional that might contain a declaration. When generating
495 normal code, we want the declaration to appear before the statement
496 containing the conditional. When generating template code, we want the
497 conditional to be rendered as the raw DECL_EXPR. */
500 begin_cond (tree
*cond_p
)
502 if (processing_template_decl
)
503 *cond_p
= push_stmt_list ();
506 /* Finish such a conditional. */
509 finish_cond (tree
*cond_p
, tree expr
)
511 if (processing_template_decl
)
513 tree cond
= pop_stmt_list (*cond_p
);
514 if (TREE_CODE (cond
) == DECL_EXPR
)
517 if (check_for_bare_parameter_packs (expr
))
518 *cond_p
= error_mark_node
;
523 /* If *COND_P specifies a conditional with a declaration, transform the
526 for (; A x = 42;) { }
528 while (true) { A x = 42; if (!x) break; }
529 for (;;) { A x = 42; if (!x) break; }
530 The statement list for BODY will be empty if the conditional did
531 not declare anything. */
534 simplify_loop_decl_cond (tree
*cond_p
, tree body
)
538 if (!TREE_SIDE_EFFECTS (body
))
542 *cond_p
= boolean_true_node
;
544 if_stmt
= begin_if_stmt ();
545 cond
= cp_build_unary_op (TRUTH_NOT_EXPR
, cond
, 0, tf_warning_or_error
);
546 finish_if_stmt_cond (cond
, if_stmt
);
547 finish_break_stmt ();
548 finish_then_clause (if_stmt
);
549 finish_if_stmt (if_stmt
);
552 /* Finish a goto-statement. */
555 finish_goto_stmt (tree destination
)
557 if (TREE_CODE (destination
) == IDENTIFIER_NODE
)
558 destination
= lookup_label (destination
);
560 /* We warn about unused labels with -Wunused. That means we have to
561 mark the used labels as used. */
562 if (TREE_CODE (destination
) == LABEL_DECL
)
563 TREE_USED (destination
) = 1;
566 destination
= mark_rvalue_use (destination
);
567 if (!processing_template_decl
)
569 destination
= cp_convert (ptr_type_node
, destination
);
570 if (error_operand_p (destination
))
575 check_goto (destination
);
577 return add_stmt (build_stmt (input_location
, GOTO_EXPR
, destination
));
580 /* COND is the condition-expression for an if, while, etc.,
581 statement. Convert it to a boolean value, if appropriate.
582 In addition, verify sequence points if -Wsequence-point is enabled. */
585 maybe_convert_cond (tree cond
)
587 /* Empty conditions remain empty. */
591 /* Wait until we instantiate templates before doing conversion. */
592 if (processing_template_decl
)
595 if (warn_sequence_point
)
596 verify_sequence_points (cond
);
598 /* Do the conversion. */
599 cond
= convert_from_reference (cond
);
601 if (TREE_CODE (cond
) == MODIFY_EXPR
602 && !TREE_NO_WARNING (cond
)
605 warning (OPT_Wparentheses
,
606 "suggest parentheses around assignment used as truth value");
607 TREE_NO_WARNING (cond
) = 1;
610 return condition_conversion (cond
);
613 /* Finish an expression-statement, whose EXPRESSION is as indicated. */
616 finish_expr_stmt (tree expr
)
620 if (expr
!= NULL_TREE
)
622 if (!processing_template_decl
)
624 if (warn_sequence_point
)
625 verify_sequence_points (expr
);
626 expr
= convert_to_void (expr
, ICV_STATEMENT
, tf_warning_or_error
);
628 else if (!type_dependent_expression_p (expr
))
629 convert_to_void (build_non_dependent_expr (expr
), ICV_STATEMENT
,
630 tf_warning_or_error
);
632 if (check_for_bare_parameter_packs (expr
))
633 expr
= error_mark_node
;
635 /* Simplification of inner statement expressions, compound exprs,
636 etc can result in us already having an EXPR_STMT. */
637 if (TREE_CODE (expr
) != CLEANUP_POINT_EXPR
)
639 if (TREE_CODE (expr
) != EXPR_STMT
)
640 expr
= build_stmt (input_location
, EXPR_STMT
, expr
);
641 expr
= maybe_cleanup_point_expr_void (expr
);
653 /* Begin an if-statement. Returns a newly created IF_STMT if
660 scope
= do_pushlevel (sk_cond
);
661 r
= build_stmt (input_location
, IF_STMT
, NULL_TREE
,
662 NULL_TREE
, NULL_TREE
, scope
);
663 begin_cond (&IF_COND (r
));
667 /* Process the COND of an if-statement, which may be given by
671 finish_if_stmt_cond (tree cond
, tree if_stmt
)
673 finish_cond (&IF_COND (if_stmt
), maybe_convert_cond (cond
));
675 THEN_CLAUSE (if_stmt
) = push_stmt_list ();
678 /* Finish the then-clause of an if-statement, which may be given by
682 finish_then_clause (tree if_stmt
)
684 THEN_CLAUSE (if_stmt
) = pop_stmt_list (THEN_CLAUSE (if_stmt
));
688 /* Begin the else-clause of an if-statement. */
691 begin_else_clause (tree if_stmt
)
693 ELSE_CLAUSE (if_stmt
) = push_stmt_list ();
696 /* Finish the else-clause of an if-statement, which may be given by
700 finish_else_clause (tree if_stmt
)
702 ELSE_CLAUSE (if_stmt
) = pop_stmt_list (ELSE_CLAUSE (if_stmt
));
705 /* Finish an if-statement. */
708 finish_if_stmt (tree if_stmt
)
710 tree scope
= IF_SCOPE (if_stmt
);
711 IF_SCOPE (if_stmt
) = NULL
;
712 add_stmt (do_poplevel (scope
));
716 /* Begin a while-statement. Returns a newly created WHILE_STMT if
720 begin_while_stmt (void)
723 r
= build_stmt (input_location
, WHILE_STMT
, NULL_TREE
, NULL_TREE
);
725 WHILE_BODY (r
) = do_pushlevel (sk_block
);
726 begin_cond (&WHILE_COND (r
));
730 /* Process the COND of a while-statement, which may be given by
734 finish_while_stmt_cond (tree cond
, tree while_stmt
)
736 finish_cond (&WHILE_COND (while_stmt
), maybe_convert_cond (cond
));
737 simplify_loop_decl_cond (&WHILE_COND (while_stmt
), WHILE_BODY (while_stmt
));
740 /* Finish a while-statement, which may be given by WHILE_STMT. */
743 finish_while_stmt (tree while_stmt
)
745 WHILE_BODY (while_stmt
) = do_poplevel (WHILE_BODY (while_stmt
));
749 /* Begin a do-statement. Returns a newly created DO_STMT if
755 tree r
= build_stmt (input_location
, DO_STMT
, NULL_TREE
, NULL_TREE
);
757 DO_BODY (r
) = push_stmt_list ();
761 /* Finish the body of a do-statement, which may be given by DO_STMT. */
764 finish_do_body (tree do_stmt
)
766 tree body
= DO_BODY (do_stmt
) = pop_stmt_list (DO_BODY (do_stmt
));
768 if (TREE_CODE (body
) == STATEMENT_LIST
&& STATEMENT_LIST_TAIL (body
))
769 body
= STATEMENT_LIST_TAIL (body
)->stmt
;
771 if (IS_EMPTY_STMT (body
))
772 warning (OPT_Wempty_body
,
773 "suggest explicit braces around empty body in %<do%> statement");
776 /* Finish a do-statement, which may be given by DO_STMT, and whose
777 COND is as indicated. */
780 finish_do_stmt (tree cond
, tree do_stmt
)
782 cond
= maybe_convert_cond (cond
);
783 DO_COND (do_stmt
) = cond
;
787 /* Finish a return-statement. The EXPRESSION returned, if any, is as
791 finish_return_stmt (tree expr
)
796 expr
= check_return_expr (expr
, &no_warning
);
798 if (flag_openmp
&& !check_omp_return ())
799 return error_mark_node
;
800 if (!processing_template_decl
)
802 if (warn_sequence_point
)
803 verify_sequence_points (expr
);
805 if (DECL_DESTRUCTOR_P (current_function_decl
)
806 || (DECL_CONSTRUCTOR_P (current_function_decl
)
807 && targetm
.cxx
.cdtor_returns_this ()))
809 /* Similarly, all destructors must run destructors for
810 base-classes before returning. So, all returns in a
811 destructor get sent to the DTOR_LABEL; finish_function emits
812 code to return a value there. */
813 return finish_goto_stmt (cdtor_label
);
817 r
= build_stmt (input_location
, RETURN_EXPR
, expr
);
818 TREE_NO_WARNING (r
) |= no_warning
;
819 r
= maybe_cleanup_point_expr_void (r
);
826 /* Begin the scope of a for-statement or a range-for-statement.
827 Both the returned trees are to be used in a call to
828 begin_for_stmt or begin_range_for_stmt. */
831 begin_for_scope (tree
*init
)
833 tree scope
= NULL_TREE
;
834 if (flag_new_for_scope
> 0)
835 scope
= do_pushlevel (sk_for
);
837 if (processing_template_decl
)
838 *init
= push_stmt_list ();
845 /* Begin a for-statement. Returns a new FOR_STMT.
846 SCOPE and INIT should be the return of begin_for_scope,
850 begin_for_stmt (tree scope
, tree init
)
854 r
= build_stmt (input_location
, FOR_STMT
, NULL_TREE
, NULL_TREE
,
855 NULL_TREE
, NULL_TREE
, NULL_TREE
);
857 if (scope
== NULL_TREE
)
859 gcc_assert (!init
|| !(flag_new_for_scope
> 0));
861 scope
= begin_for_scope (&init
);
863 FOR_INIT_STMT (r
) = init
;
864 FOR_SCOPE (r
) = scope
;
869 /* Finish the for-init-statement of a for-statement, which may be
870 given by FOR_STMT. */
873 finish_for_init_stmt (tree for_stmt
)
875 if (processing_template_decl
)
876 FOR_INIT_STMT (for_stmt
) = pop_stmt_list (FOR_INIT_STMT (for_stmt
));
878 FOR_BODY (for_stmt
) = do_pushlevel (sk_block
);
879 begin_cond (&FOR_COND (for_stmt
));
882 /* Finish the COND of a for-statement, which may be given by
886 finish_for_cond (tree cond
, tree for_stmt
)
888 finish_cond (&FOR_COND (for_stmt
), maybe_convert_cond (cond
));
889 simplify_loop_decl_cond (&FOR_COND (for_stmt
), FOR_BODY (for_stmt
));
892 /* Finish the increment-EXPRESSION in a for-statement, which may be
893 given by FOR_STMT. */
896 finish_for_expr (tree expr
, tree for_stmt
)
900 /* If EXPR is an overloaded function, issue an error; there is no
901 context available to use to perform overload resolution. */
902 if (type_unknown_p (expr
))
904 cxx_incomplete_type_error (expr
, TREE_TYPE (expr
));
905 expr
= error_mark_node
;
907 if (!processing_template_decl
)
909 if (warn_sequence_point
)
910 verify_sequence_points (expr
);
911 expr
= convert_to_void (expr
, ICV_THIRD_IN_FOR
,
912 tf_warning_or_error
);
914 else if (!type_dependent_expression_p (expr
))
915 convert_to_void (build_non_dependent_expr (expr
), ICV_THIRD_IN_FOR
,
916 tf_warning_or_error
);
917 expr
= maybe_cleanup_point_expr_void (expr
);
918 if (check_for_bare_parameter_packs (expr
))
919 expr
= error_mark_node
;
920 FOR_EXPR (for_stmt
) = expr
;
923 /* Finish the body of a for-statement, which may be given by
924 FOR_STMT. The increment-EXPR for the loop must be
926 It can also finish RANGE_FOR_STMT. */
929 finish_for_stmt (tree for_stmt
)
931 if (TREE_CODE (for_stmt
) == RANGE_FOR_STMT
)
932 RANGE_FOR_BODY (for_stmt
) = do_poplevel (RANGE_FOR_BODY (for_stmt
));
934 FOR_BODY (for_stmt
) = do_poplevel (FOR_BODY (for_stmt
));
936 /* Pop the scope for the body of the loop. */
937 if (flag_new_for_scope
> 0)
940 tree
*scope_ptr
= (TREE_CODE (for_stmt
) == RANGE_FOR_STMT
941 ? &RANGE_FOR_SCOPE (for_stmt
)
942 : &FOR_SCOPE (for_stmt
));
945 add_stmt (do_poplevel (scope
));
951 /* Begin a range-for-statement. Returns a new RANGE_FOR_STMT.
952 SCOPE and INIT should be the return of begin_for_scope,
954 To finish it call finish_for_stmt(). */
957 begin_range_for_stmt (tree scope
, tree init
)
961 r
= build_stmt (input_location
, RANGE_FOR_STMT
,
962 NULL_TREE
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
964 if (scope
== NULL_TREE
)
966 gcc_assert (!init
|| !(flag_new_for_scope
> 0));
968 scope
= begin_for_scope (&init
);
971 /* RANGE_FOR_STMTs do not use nor save the init tree, so we
974 pop_stmt_list (init
);
975 RANGE_FOR_SCOPE (r
) = scope
;
980 /* Finish the head of a range-based for statement, which may
981 be given by RANGE_FOR_STMT. DECL must be the declaration
982 and EXPR must be the loop expression. */
985 finish_range_for_decl (tree range_for_stmt
, tree decl
, tree expr
)
987 RANGE_FOR_DECL (range_for_stmt
) = decl
;
988 RANGE_FOR_EXPR (range_for_stmt
) = expr
;
989 add_stmt (range_for_stmt
);
990 RANGE_FOR_BODY (range_for_stmt
) = do_pushlevel (sk_block
);
993 /* Finish a break-statement. */
996 finish_break_stmt (void)
998 return add_stmt (build_stmt (input_location
, BREAK_STMT
));
1001 /* Finish a continue-statement. */
1004 finish_continue_stmt (void)
1006 return add_stmt (build_stmt (input_location
, CONTINUE_STMT
));
1009 /* Begin a switch-statement. Returns a new SWITCH_STMT if
1013 begin_switch_stmt (void)
1017 scope
= do_pushlevel (sk_cond
);
1018 r
= build_stmt (input_location
, SWITCH_STMT
, NULL_TREE
, NULL_TREE
, NULL_TREE
, scope
);
1020 begin_cond (&SWITCH_STMT_COND (r
));
1025 /* Finish the cond of a switch-statement. */
1028 finish_switch_cond (tree cond
, tree switch_stmt
)
1030 tree orig_type
= NULL
;
1031 if (!processing_template_decl
)
1033 /* Convert the condition to an integer or enumeration type. */
1034 cond
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
, cond
, true);
1035 if (cond
== NULL_TREE
)
1037 error ("switch quantity not an integer");
1038 cond
= error_mark_node
;
1040 orig_type
= TREE_TYPE (cond
);
1041 if (cond
!= error_mark_node
)
1045 Integral promotions are performed. */
1046 cond
= perform_integral_promotions (cond
);
1047 cond
= maybe_cleanup_point_expr (cond
);
1050 if (check_for_bare_parameter_packs (cond
))
1051 cond
= error_mark_node
;
1052 else if (!processing_template_decl
&& warn_sequence_point
)
1053 verify_sequence_points (cond
);
1055 finish_cond (&SWITCH_STMT_COND (switch_stmt
), cond
);
1056 SWITCH_STMT_TYPE (switch_stmt
) = orig_type
;
1057 add_stmt (switch_stmt
);
1058 push_switch (switch_stmt
);
1059 SWITCH_STMT_BODY (switch_stmt
) = push_stmt_list ();
1062 /* Finish the body of a switch-statement, which may be given by
1063 SWITCH_STMT. The COND to switch on is indicated. */
1066 finish_switch_stmt (tree switch_stmt
)
1070 SWITCH_STMT_BODY (switch_stmt
) =
1071 pop_stmt_list (SWITCH_STMT_BODY (switch_stmt
));
1075 scope
= SWITCH_STMT_SCOPE (switch_stmt
);
1076 SWITCH_STMT_SCOPE (switch_stmt
) = NULL
;
1077 add_stmt (do_poplevel (scope
));
1080 /* Begin a try-block. Returns a newly-created TRY_BLOCK if
1084 begin_try_block (void)
1086 tree r
= build_stmt (input_location
, TRY_BLOCK
, NULL_TREE
, NULL_TREE
);
1088 TRY_STMTS (r
) = push_stmt_list ();
1092 /* Likewise, for a function-try-block. The block returned in
1093 *COMPOUND_STMT is an artificial outer scope, containing the
1094 function-try-block. */
1097 begin_function_try_block (tree
*compound_stmt
)
1100 /* This outer scope does not exist in the C++ standard, but we need
1101 a place to put __FUNCTION__ and similar variables. */
1102 *compound_stmt
= begin_compound_stmt (0);
1103 r
= begin_try_block ();
1104 FN_TRY_BLOCK_P (r
) = 1;
1108 /* Finish a try-block, which may be given by TRY_BLOCK. */
1111 finish_try_block (tree try_block
)
1113 TRY_STMTS (try_block
) = pop_stmt_list (TRY_STMTS (try_block
));
1114 TRY_HANDLERS (try_block
) = push_stmt_list ();
1117 /* Finish the body of a cleanup try-block, which may be given by
1121 finish_cleanup_try_block (tree try_block
)
1123 TRY_STMTS (try_block
) = pop_stmt_list (TRY_STMTS (try_block
));
1126 /* Finish an implicitly generated try-block, with a cleanup is given
1130 finish_cleanup (tree cleanup
, tree try_block
)
1132 TRY_HANDLERS (try_block
) = cleanup
;
1133 CLEANUP_P (try_block
) = 1;
1136 /* Likewise, for a function-try-block. */
1139 finish_function_try_block (tree try_block
)
1141 finish_try_block (try_block
);
1142 /* FIXME : something queer about CTOR_INITIALIZER somehow following
1143 the try block, but moving it inside. */
1144 in_function_try_handler
= 1;
1147 /* Finish a handler-sequence for a try-block, which may be given by
1151 finish_handler_sequence (tree try_block
)
1153 TRY_HANDLERS (try_block
) = pop_stmt_list (TRY_HANDLERS (try_block
));
1154 check_handlers (TRY_HANDLERS (try_block
));
1157 /* Finish the handler-seq for a function-try-block, given by
1158 TRY_BLOCK. COMPOUND_STMT is the outer block created by
1159 begin_function_try_block. */
1162 finish_function_handler_sequence (tree try_block
, tree compound_stmt
)
1164 in_function_try_handler
= 0;
1165 finish_handler_sequence (try_block
);
1166 finish_compound_stmt (compound_stmt
);
1169 /* Begin a handler. Returns a HANDLER if appropriate. */
1172 begin_handler (void)
1176 r
= build_stmt (input_location
, HANDLER
, NULL_TREE
, NULL_TREE
);
1179 /* Create a binding level for the eh_info and the exception object
1181 HANDLER_BODY (r
) = do_pushlevel (sk_catch
);
1186 /* Finish the handler-parameters for a handler, which may be given by
1187 HANDLER. DECL is the declaration for the catch parameter, or NULL
1188 if this is a `catch (...)' clause. */
1191 finish_handler_parms (tree decl
, tree handler
)
1193 tree type
= NULL_TREE
;
1194 if (processing_template_decl
)
1198 decl
= pushdecl (decl
);
1199 decl
= push_template_decl (decl
);
1200 HANDLER_PARMS (handler
) = decl
;
1201 type
= TREE_TYPE (decl
);
1205 type
= expand_start_catch_block (decl
);
1206 HANDLER_TYPE (handler
) = type
;
1207 if (!processing_template_decl
&& type
)
1208 mark_used (eh_type_info (type
));
1211 /* Finish a handler, which may be given by HANDLER. The BLOCKs are
1212 the return value from the matching call to finish_handler_parms. */
1215 finish_handler (tree handler
)
1217 if (!processing_template_decl
)
1218 expand_end_catch_block ();
1219 HANDLER_BODY (handler
) = do_poplevel (HANDLER_BODY (handler
));
1222 /* Begin a compound statement. FLAGS contains some bits that control the
1223 behavior and context. If BCS_NO_SCOPE is set, the compound statement
1224 does not define a scope. If BCS_FN_BODY is set, this is the outermost
1225 block of a function. If BCS_TRY_BLOCK is set, this is the block
1226 created on behalf of a TRY statement. Returns a token to be passed to
1227 finish_compound_stmt. */
1230 begin_compound_stmt (unsigned int flags
)
1234 if (flags
& BCS_NO_SCOPE
)
1236 r
= push_stmt_list ();
1237 STATEMENT_LIST_NO_SCOPE (r
) = 1;
1239 /* Normally, we try hard to keep the BLOCK for a statement-expression.
1240 But, if it's a statement-expression with a scopeless block, there's
1241 nothing to keep, and we don't want to accidentally keep a block
1242 *inside* the scopeless block. */
1243 keep_next_level (false);
1246 r
= do_pushlevel (flags
& BCS_TRY_BLOCK
? sk_try
: sk_block
);
1248 /* When processing a template, we need to remember where the braces were,
1249 so that we can set up identical scopes when instantiating the template
1250 later. BIND_EXPR is a handy candidate for this.
1251 Note that do_poplevel won't create a BIND_EXPR itself here (and thus
1252 result in nested BIND_EXPRs), since we don't build BLOCK nodes when
1253 processing templates. */
1254 if (processing_template_decl
)
1256 r
= build3 (BIND_EXPR
, NULL
, NULL
, r
, NULL
);
1257 BIND_EXPR_TRY_BLOCK (r
) = (flags
& BCS_TRY_BLOCK
) != 0;
1258 BIND_EXPR_BODY_BLOCK (r
) = (flags
& BCS_FN_BODY
) != 0;
1259 TREE_SIDE_EFFECTS (r
) = 1;
1265 /* Finish a compound-statement, which is given by STMT. */
1268 finish_compound_stmt (tree stmt
)
1270 if (TREE_CODE (stmt
) == BIND_EXPR
)
1272 tree body
= do_poplevel (BIND_EXPR_BODY (stmt
));
1273 /* If the STATEMENT_LIST is empty and this BIND_EXPR isn't special,
1274 discard the BIND_EXPR so it can be merged with the containing
1276 if (TREE_CODE (body
) == STATEMENT_LIST
1277 && STATEMENT_LIST_HEAD (body
) == NULL
1278 && !BIND_EXPR_BODY_BLOCK (stmt
)
1279 && !BIND_EXPR_TRY_BLOCK (stmt
))
1282 BIND_EXPR_BODY (stmt
) = body
;
1284 else if (STATEMENT_LIST_NO_SCOPE (stmt
))
1285 stmt
= pop_stmt_list (stmt
);
1288 /* Destroy any ObjC "super" receivers that may have been
1290 objc_clear_super_receiver ();
1292 stmt
= do_poplevel (stmt
);
1295 /* ??? See c_end_compound_stmt wrt statement expressions. */
1300 /* Finish an asm-statement, whose components are a STRING, some
1301 OUTPUT_OPERANDS, some INPUT_OPERANDS, some CLOBBERS and some
1302 LABELS. Also note whether the asm-statement should be
1303 considered volatile. */
1306 finish_asm_stmt (int volatile_p
, tree string
, tree output_operands
,
1307 tree input_operands
, tree clobbers
, tree labels
)
1311 int ninputs
= list_length (input_operands
);
1312 int noutputs
= list_length (output_operands
);
1314 if (!processing_template_decl
)
1316 const char *constraint
;
1317 const char **oconstraints
;
1318 bool allows_mem
, allows_reg
, is_inout
;
1322 oconstraints
= XALLOCAVEC (const char *, noutputs
);
1324 string
= resolve_asm_operand_names (string
, output_operands
,
1325 input_operands
, labels
);
1327 for (i
= 0, t
= output_operands
; t
; t
= TREE_CHAIN (t
), ++i
)
1329 operand
= TREE_VALUE (t
);
1331 /* ??? Really, this should not be here. Users should be using a
1332 proper lvalue, dammit. But there's a long history of using
1333 casts in the output operands. In cases like longlong.h, this
1334 becomes a primitive form of typechecking -- if the cast can be
1335 removed, then the output operand had a type of the proper width;
1336 otherwise we'll get an error. Gross, but ... */
1337 STRIP_NOPS (operand
);
1339 operand
= mark_lvalue_use (operand
);
1341 if (!lvalue_or_else (operand
, lv_asm
, tf_warning_or_error
))
1342 operand
= error_mark_node
;
1344 if (operand
!= error_mark_node
1345 && (TREE_READONLY (operand
)
1346 || CP_TYPE_CONST_P (TREE_TYPE (operand
))
1347 /* Functions are not modifiable, even though they are
1349 || TREE_CODE (TREE_TYPE (operand
)) == FUNCTION_TYPE
1350 || TREE_CODE (TREE_TYPE (operand
)) == METHOD_TYPE
1351 /* If it's an aggregate and any field is const, then it is
1352 effectively const. */
1353 || (CLASS_TYPE_P (TREE_TYPE (operand
))
1354 && C_TYPE_FIELDS_READONLY (TREE_TYPE (operand
)))))
1355 cxx_readonly_error (operand
, lv_asm
);
1357 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
1358 oconstraints
[i
] = constraint
;
1360 if (parse_output_constraint (&constraint
, i
, ninputs
, noutputs
,
1361 &allows_mem
, &allows_reg
, &is_inout
))
1363 /* If the operand is going to end up in memory,
1364 mark it addressable. */
1365 if (!allows_reg
&& !cxx_mark_addressable (operand
))
1366 operand
= error_mark_node
;
1369 operand
= error_mark_node
;
1371 TREE_VALUE (t
) = operand
;
1374 for (i
= 0, t
= input_operands
; t
; ++i
, t
= TREE_CHAIN (t
))
1376 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
1377 operand
= decay_conversion (TREE_VALUE (t
));
1379 /* If the type of the operand hasn't been determined (e.g.,
1380 because it involves an overloaded function), then issue
1381 an error message. There's no context available to
1382 resolve the overloading. */
1383 if (TREE_TYPE (operand
) == unknown_type_node
)
1385 error ("type of asm operand %qE could not be determined",
1387 operand
= error_mark_node
;
1390 if (parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, 0,
1391 oconstraints
, &allows_mem
, &allows_reg
))
1393 /* If the operand is going to end up in memory,
1394 mark it addressable. */
1395 if (!allows_reg
&& allows_mem
)
1397 /* Strip the nops as we allow this case. FIXME, this really
1398 should be rejected or made deprecated. */
1399 STRIP_NOPS (operand
);
1400 if (!cxx_mark_addressable (operand
))
1401 operand
= error_mark_node
;
1405 operand
= error_mark_node
;
1407 TREE_VALUE (t
) = operand
;
1411 r
= build_stmt (input_location
, ASM_EXPR
, string
,
1412 output_operands
, input_operands
,
1414 ASM_VOLATILE_P (r
) = volatile_p
|| noutputs
== 0;
1415 r
= maybe_cleanup_point_expr_void (r
);
1416 return add_stmt (r
);
1419 /* Finish a label with the indicated NAME. Returns the new label. */
1422 finish_label_stmt (tree name
)
1424 tree decl
= define_label (input_location
, name
);
1426 if (decl
== error_mark_node
)
1427 return error_mark_node
;
1429 add_stmt (build_stmt (input_location
, LABEL_EXPR
, decl
));
1434 /* Finish a series of declarations for local labels. G++ allows users
1435 to declare "local" labels, i.e., labels with scope. This extension
1436 is useful when writing code involving statement-expressions. */
1439 finish_label_decl (tree name
)
1441 if (!at_function_scope_p ())
1443 error ("__label__ declarations are only allowed in function scopes");
1447 add_decl_expr (declare_local_label (name
));
1450 /* When DECL goes out of scope, make sure that CLEANUP is executed. */
1453 finish_decl_cleanup (tree decl
, tree cleanup
)
1455 push_cleanup (decl
, cleanup
, false);
1458 /* If the current scope exits with an exception, run CLEANUP. */
1461 finish_eh_cleanup (tree cleanup
)
1463 push_cleanup (NULL
, cleanup
, true);
1466 /* The MEM_INITS is a list of mem-initializers, in reverse of the
1467 order they were written by the user. Each node is as for
1468 emit_mem_initializers. */
1471 finish_mem_initializers (tree mem_inits
)
1473 /* Reorder the MEM_INITS so that they are in the order they appeared
1474 in the source program. */
1475 mem_inits
= nreverse (mem_inits
);
1477 if (processing_template_decl
)
1481 for (mem
= mem_inits
; mem
; mem
= TREE_CHAIN (mem
))
1483 /* If the TREE_PURPOSE is a TYPE_PACK_EXPANSION, skip the
1484 check for bare parameter packs in the TREE_VALUE, because
1485 any parameter packs in the TREE_VALUE have already been
1486 bound as part of the TREE_PURPOSE. See
1487 make_pack_expansion for more information. */
1488 if (TREE_CODE (TREE_PURPOSE (mem
)) != TYPE_PACK_EXPANSION
1489 && check_for_bare_parameter_packs (TREE_VALUE (mem
)))
1490 TREE_VALUE (mem
) = error_mark_node
;
1493 add_stmt (build_min_nt (CTOR_INITIALIZER
, mem_inits
));
1496 emit_mem_initializers (mem_inits
);
1499 /* Finish a parenthesized expression EXPR. */
1502 finish_parenthesized_expr (tree expr
)
1505 /* This inhibits warnings in c_common_truthvalue_conversion. */
1506 TREE_NO_WARNING (expr
) = 1;
1508 if (TREE_CODE (expr
) == OFFSET_REF
)
1509 /* [expr.unary.op]/3 The qualified id of a pointer-to-member must not be
1510 enclosed in parentheses. */
1511 PTRMEM_OK_P (expr
) = 0;
1513 if (TREE_CODE (expr
) == STRING_CST
)
1514 PAREN_STRING_LITERAL_P (expr
) = 1;
1519 /* Finish a reference to a non-static data member (DECL) that is not
1520 preceded by `.' or `->'. */
1523 finish_non_static_data_member (tree decl
, tree object
, tree qualifying_scope
)
1525 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
);
1529 tree scope
= qualifying_scope
;
1530 if (scope
== NULL_TREE
)
1531 scope
= context_for_name_lookup (decl
);
1532 object
= maybe_dummy_object (scope
, NULL
);
1535 if (object
== error_mark_node
)
1536 return error_mark_node
;
1538 /* DR 613: Can use non-static data members without an associated
1539 object in sizeof/decltype/alignof. */
1540 if (is_dummy_object (object
) && cp_unevaluated_operand
== 0
1541 && (!processing_template_decl
|| !current_class_ref
))
1543 if (current_function_decl
1544 && DECL_STATIC_FUNCTION_P (current_function_decl
))
1545 error ("invalid use of member %q+D in static member function", decl
);
1547 error ("invalid use of non-static data member %q+D", decl
);
1548 error ("from this location");
1550 return error_mark_node
;
1553 if (current_class_ptr
)
1554 TREE_USED (current_class_ptr
) = 1;
1555 if (processing_template_decl
&& !qualifying_scope
)
1557 tree type
= TREE_TYPE (decl
);
1559 if (TREE_CODE (type
) == REFERENCE_TYPE
)
1560 type
= TREE_TYPE (type
);
1563 /* Set the cv qualifiers. */
1564 int quals
= (current_class_ref
1565 ? cp_type_quals (TREE_TYPE (current_class_ref
))
1566 : TYPE_UNQUALIFIED
);
1568 if (DECL_MUTABLE_P (decl
))
1569 quals
&= ~TYPE_QUAL_CONST
;
1571 quals
|= cp_type_quals (TREE_TYPE (decl
));
1572 type
= cp_build_qualified_type (type
, quals
);
1575 return build_min (COMPONENT_REF
, type
, object
, decl
, NULL_TREE
);
1577 /* If PROCESSING_TEMPLATE_DECL is nonzero here, then
1578 QUALIFYING_SCOPE is also non-null. Wrap this in a SCOPE_REF
1580 else if (processing_template_decl
)
1581 return build_qualified_name (TREE_TYPE (decl
),
1584 /*template_p=*/false);
1587 tree access_type
= TREE_TYPE (object
);
1589 perform_or_defer_access_check (TYPE_BINFO (access_type
), decl
,
1592 /* If the data member was named `C::M', convert `*this' to `C'
1594 if (qualifying_scope
)
1596 tree binfo
= NULL_TREE
;
1597 object
= build_scoped_ref (object
, qualifying_scope
,
1601 return build_class_member_access_expr (object
, decl
,
1602 /*access_path=*/NULL_TREE
,
1603 /*preserve_reference=*/false,
1604 tf_warning_or_error
);
1608 /* If we are currently parsing a template and we encountered a typedef
1609 TYPEDEF_DECL that is being accessed though CONTEXT, this function
1610 adds the typedef to a list tied to the current template.
1611 At tempate instantiatin time, that list is walked and access check
1612 performed for each typedef.
1613 LOCATION is the location of the usage point of TYPEDEF_DECL. */
1616 add_typedef_to_current_template_for_access_check (tree typedef_decl
,
1618 location_t location
)
1620 tree template_info
= NULL
;
1621 tree cs
= current_scope ();
1623 if (!is_typedef_decl (typedef_decl
)
1625 || !CLASS_TYPE_P (context
)
1629 if (CLASS_TYPE_P (cs
) || TREE_CODE (cs
) == FUNCTION_DECL
)
1630 template_info
= get_template_info (cs
);
1633 && TI_TEMPLATE (template_info
)
1634 && !currently_open_class (context
))
1635 append_type_to_template_for_access_check (cs
, typedef_decl
,
1639 /* DECL was the declaration to which a qualified-id resolved. Issue
1640 an error message if it is not accessible. If OBJECT_TYPE is
1641 non-NULL, we have just seen `x->' or `x.' and OBJECT_TYPE is the
1642 type of `*x', or `x', respectively. If the DECL was named as
1643 `A::B' then NESTED_NAME_SPECIFIER is `A'. */
1646 check_accessibility_of_qualified_id (tree decl
,
1648 tree nested_name_specifier
)
1651 tree qualifying_type
= NULL_TREE
;
1653 /* If we are parsing a template declaration and if decl is a typedef,
1654 add it to a list tied to the template.
1655 At template instantiation time, that list will be walked and
1656 access check performed. */
1657 add_typedef_to_current_template_for_access_check (decl
,
1658 nested_name_specifier
1659 ? nested_name_specifier
1660 : DECL_CONTEXT (decl
),
1663 /* If we're not checking, return immediately. */
1664 if (deferred_access_no_check
)
1667 /* Determine the SCOPE of DECL. */
1668 scope
= context_for_name_lookup (decl
);
1669 /* If the SCOPE is not a type, then DECL is not a member. */
1670 if (!TYPE_P (scope
))
1672 /* Compute the scope through which DECL is being accessed. */
1674 /* OBJECT_TYPE might not be a class type; consider:
1676 class A { typedef int I; };
1680 In this case, we will have "A::I" as the DECL, but "I" as the
1682 && CLASS_TYPE_P (object_type
)
1683 && DERIVED_FROM_P (scope
, object_type
))
1684 /* If we are processing a `->' or `.' expression, use the type of the
1686 qualifying_type
= object_type
;
1687 else if (nested_name_specifier
)
1689 /* If the reference is to a non-static member of the
1690 current class, treat it as if it were referenced through
1692 if (DECL_NONSTATIC_MEMBER_P (decl
)
1693 && current_class_ptr
1694 && DERIVED_FROM_P (scope
, current_class_type
))
1695 qualifying_type
= current_class_type
;
1696 /* Otherwise, use the type indicated by the
1697 nested-name-specifier. */
1699 qualifying_type
= nested_name_specifier
;
1702 /* Otherwise, the name must be from the current class or one of
1704 qualifying_type
= currently_open_derived_class (scope
);
1707 /* It is possible for qualifying type to be a TEMPLATE_TYPE_PARM
1708 or similar in a default argument value. */
1709 && CLASS_TYPE_P (qualifying_type
)
1710 && !dependent_type_p (qualifying_type
))
1711 perform_or_defer_access_check (TYPE_BINFO (qualifying_type
), decl
,
1715 /* EXPR is the result of a qualified-id. The QUALIFYING_CLASS was the
1716 class named to the left of the "::" operator. DONE is true if this
1717 expression is a complete postfix-expression; it is false if this
1718 expression is followed by '->', '[', '(', etc. ADDRESS_P is true
1719 iff this expression is the operand of '&'. TEMPLATE_P is true iff
1720 the qualified-id was of the form "A::template B". TEMPLATE_ARG_P
1721 is true iff this qualified name appears as a template argument. */
1724 finish_qualified_id_expr (tree qualifying_class
,
1729 bool template_arg_p
)
1731 gcc_assert (TYPE_P (qualifying_class
));
1733 if (error_operand_p (expr
))
1734 return error_mark_node
;
1736 if (DECL_P (expr
) || BASELINK_P (expr
))
1740 check_template_keyword (expr
);
1742 /* If EXPR occurs as the operand of '&', use special handling that
1743 permits a pointer-to-member. */
1744 if (address_p
&& done
)
1746 if (TREE_CODE (expr
) == SCOPE_REF
)
1747 expr
= TREE_OPERAND (expr
, 1);
1748 expr
= build_offset_ref (qualifying_class
, expr
,
1749 /*address_p=*/true);
1753 /* Within the scope of a class, turn references to non-static
1754 members into expression of the form "this->...". */
1756 /* But, within a template argument, we do not want make the
1757 transformation, as there is no "this" pointer. */
1759 else if (TREE_CODE (expr
) == FIELD_DECL
)
1761 push_deferring_access_checks (dk_no_check
);
1762 expr
= finish_non_static_data_member (expr
, NULL_TREE
,
1764 pop_deferring_access_checks ();
1766 else if (BASELINK_P (expr
) && !processing_template_decl
)
1770 /* See if any of the functions are non-static members. */
1771 /* If so, the expression may be relative to 'this'. */
1772 if (!shared_member_p (expr
)
1773 && (ob
= maybe_dummy_object (qualifying_class
, NULL
),
1774 !is_dummy_object (ob
)))
1775 expr
= (build_class_member_access_expr
1778 BASELINK_ACCESS_BINFO (expr
),
1779 /*preserve_reference=*/false,
1780 tf_warning_or_error
));
1782 /* The expression is a qualified name whose address is not
1784 expr
= build_offset_ref (qualifying_class
, expr
, /*address_p=*/false);
1790 /* Begin a statement-expression. The value returned must be passed to
1791 finish_stmt_expr. */
1794 begin_stmt_expr (void)
1796 return push_stmt_list ();
1799 /* Process the final expression of a statement expression. EXPR can be
1800 NULL, if the final expression is empty. Return a STATEMENT_LIST
1801 containing all the statements in the statement-expression, or
1802 ERROR_MARK_NODE if there was an error. */
1805 finish_stmt_expr_expr (tree expr
, tree stmt_expr
)
1807 if (error_operand_p (expr
))
1809 /* The type of the statement-expression is the type of the last
1811 TREE_TYPE (stmt_expr
) = error_mark_node
;
1812 return error_mark_node
;
1815 /* If the last statement does not have "void" type, then the value
1816 of the last statement is the value of the entire expression. */
1819 tree type
= TREE_TYPE (expr
);
1821 if (processing_template_decl
)
1823 expr
= build_stmt (input_location
, EXPR_STMT
, expr
);
1824 expr
= add_stmt (expr
);
1825 /* Mark the last statement so that we can recognize it as such at
1826 template-instantiation time. */
1827 EXPR_STMT_STMT_EXPR_RESULT (expr
) = 1;
1829 else if (VOID_TYPE_P (type
))
1831 /* Just treat this like an ordinary statement. */
1832 expr
= finish_expr_stmt (expr
);
1836 /* It actually has a value we need to deal with. First, force it
1837 to be an rvalue so that we won't need to build up a copy
1838 constructor call later when we try to assign it to something. */
1839 expr
= force_rvalue (expr
, tf_warning_or_error
);
1840 if (error_operand_p (expr
))
1841 return error_mark_node
;
1843 /* Update for array-to-pointer decay. */
1844 type
= TREE_TYPE (expr
);
1846 /* Wrap it in a CLEANUP_POINT_EXPR and add it to the list like a
1847 normal statement, but don't convert to void or actually add
1849 if (TREE_CODE (expr
) != CLEANUP_POINT_EXPR
)
1850 expr
= maybe_cleanup_point_expr (expr
);
1854 /* The type of the statement-expression is the type of the last
1856 TREE_TYPE (stmt_expr
) = type
;
1862 /* Finish a statement-expression. EXPR should be the value returned
1863 by the previous begin_stmt_expr. Returns an expression
1864 representing the statement-expression. */
1867 finish_stmt_expr (tree stmt_expr
, bool has_no_scope
)
1872 if (error_operand_p (stmt_expr
))
1874 pop_stmt_list (stmt_expr
);
1875 return error_mark_node
;
1878 gcc_assert (TREE_CODE (stmt_expr
) == STATEMENT_LIST
);
1880 type
= TREE_TYPE (stmt_expr
);
1881 result
= pop_stmt_list (stmt_expr
);
1882 TREE_TYPE (result
) = type
;
1884 if (processing_template_decl
)
1886 result
= build_min (STMT_EXPR
, type
, result
);
1887 TREE_SIDE_EFFECTS (result
) = 1;
1888 STMT_EXPR_NO_SCOPE (result
) = has_no_scope
;
1890 else if (CLASS_TYPE_P (type
))
1892 /* Wrap the statement-expression in a TARGET_EXPR so that the
1893 temporary object created by the final expression is destroyed at
1894 the end of the full-expression containing the
1895 statement-expression. */
1896 result
= force_target_expr (type
, result
, tf_warning_or_error
);
1902 /* Returns the expression which provides the value of STMT_EXPR. */
1905 stmt_expr_value_expr (tree stmt_expr
)
1907 tree t
= STMT_EXPR_STMT (stmt_expr
);
1909 if (TREE_CODE (t
) == BIND_EXPR
)
1910 t
= BIND_EXPR_BODY (t
);
1912 if (TREE_CODE (t
) == STATEMENT_LIST
&& STATEMENT_LIST_TAIL (t
))
1913 t
= STATEMENT_LIST_TAIL (t
)->stmt
;
1915 if (TREE_CODE (t
) == EXPR_STMT
)
1916 t
= EXPR_STMT_EXPR (t
);
1921 /* Return TRUE iff EXPR_STMT is an empty list of
1922 expression statements. */
1925 empty_expr_stmt_p (tree expr_stmt
)
1927 tree body
= NULL_TREE
;
1929 if (expr_stmt
== void_zero_node
)
1934 if (TREE_CODE (expr_stmt
) == EXPR_STMT
)
1935 body
= EXPR_STMT_EXPR (expr_stmt
);
1936 else if (TREE_CODE (expr_stmt
) == STATEMENT_LIST
)
1942 if (TREE_CODE (body
) == STATEMENT_LIST
)
1943 return tsi_end_p (tsi_start (body
));
1945 return empty_expr_stmt_p (body
);
1950 /* Perform Koenig lookup. FN is the postfix-expression representing
1951 the function (or functions) to call; ARGS are the arguments to the
1952 call; if INCLUDE_STD then the `std' namespace is automatically
1953 considered an associated namespace (used in range-based for loops).
1954 Returns the functions to be considered by overload resolution. */
1957 perform_koenig_lookup (tree fn
, VEC(tree
,gc
) *args
, bool include_std
,
1958 tsubst_flags_t complain
)
1960 tree identifier
= NULL_TREE
;
1961 tree functions
= NULL_TREE
;
1962 tree tmpl_args
= NULL_TREE
;
1963 bool template_id
= false;
1965 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
1967 /* Use a separate flag to handle null args. */
1969 tmpl_args
= TREE_OPERAND (fn
, 1);
1970 fn
= TREE_OPERAND (fn
, 0);
1973 /* Find the name of the overloaded function. */
1974 if (TREE_CODE (fn
) == IDENTIFIER_NODE
)
1976 else if (is_overloaded_fn (fn
))
1979 identifier
= DECL_NAME (get_first_fn (functions
));
1981 else if (DECL_P (fn
))
1984 identifier
= DECL_NAME (fn
);
1987 /* A call to a namespace-scope function using an unqualified name.
1989 Do Koenig lookup -- unless any of the arguments are
1991 if (!any_type_dependent_arguments_p (args
)
1992 && !any_dependent_template_arguments_p (tmpl_args
))
1994 fn
= lookup_arg_dependent (identifier
, functions
, args
, include_std
);
1997 /* The unqualified name could not be resolved. */
1999 fn
= unqualified_fn_lookup_error (identifier
);
2005 if (fn
&& template_id
)
2006 fn
= build2 (TEMPLATE_ID_EXPR
, unknown_type_node
, fn
, tmpl_args
);
2011 /* Generate an expression for `FN (ARGS)'. This may change the
2014 If DISALLOW_VIRTUAL is true, the call to FN will be not generated
2015 as a virtual call, even if FN is virtual. (This flag is set when
2016 encountering an expression where the function name is explicitly
2017 qualified. For example a call to `X::f' never generates a virtual
2020 Returns code for the call. */
2023 finish_call_expr (tree fn
, VEC(tree
,gc
) **args
, bool disallow_virtual
,
2024 bool koenig_p
, tsubst_flags_t complain
)
2028 VEC(tree
,gc
) *orig_args
= NULL
;
2030 if (fn
== error_mark_node
)
2031 return error_mark_node
;
2033 gcc_assert (!TYPE_P (fn
));
2037 if (processing_template_decl
)
2039 /* If the call expression is dependent, build a CALL_EXPR node
2040 with no type; type_dependent_expression_p recognizes
2041 expressions with no type as being dependent. */
2042 if (type_dependent_expression_p (fn
)
2043 || any_type_dependent_arguments_p (*args
)
2044 /* For a non-static member function, we need to specifically
2045 test the type dependency of the "this" pointer because it
2046 is not included in *ARGS even though it is considered to
2047 be part of the list of arguments. Note that this is
2048 related to CWG issues 515 and 1005. */
2049 || (non_static_member_function_p (fn
)
2050 && current_class_ref
2051 && type_dependent_expression_p (current_class_ref
)))
2053 result
= build_nt_call_vec (fn
, *args
);
2054 KOENIG_LOOKUP_P (result
) = koenig_p
;
2059 tree fndecl
= OVL_CURRENT (fn
);
2060 if (TREE_CODE (fndecl
) != FUNCTION_DECL
2061 || !TREE_THIS_VOLATILE (fndecl
))
2067 current_function_returns_abnormally
= 1;
2071 orig_args
= make_tree_vector_copy (*args
);
2072 if (!BASELINK_P (fn
)
2073 && TREE_CODE (fn
) != PSEUDO_DTOR_EXPR
2074 && TREE_TYPE (fn
) != unknown_type_node
)
2075 fn
= build_non_dependent_expr (fn
);
2076 make_args_non_dependent (*args
);
2079 if (TREE_CODE (fn
) == COMPONENT_REF
)
2081 tree member
= TREE_OPERAND (fn
, 1);
2082 if (BASELINK_P (member
))
2084 tree object
= TREE_OPERAND (fn
, 0);
2085 return build_new_method_call (object
, member
,
2088 ? LOOKUP_NORMAL
| LOOKUP_NONVIRTUAL
2095 if (is_overloaded_fn (fn
))
2096 fn
= baselink_for_fns (fn
);
2099 if (BASELINK_P (fn
))
2103 /* A call to a member function. From [over.call.func]:
2105 If the keyword this is in scope and refers to the class of
2106 that member function, or a derived class thereof, then the
2107 function call is transformed into a qualified function call
2108 using (*this) as the postfix-expression to the left of the
2109 . operator.... [Otherwise] a contrived object of type T
2110 becomes the implied object argument.
2114 struct A { void f(); };
2115 struct B : public A {};
2116 struct C : public A { void g() { B::f(); }};
2118 "the class of that member function" refers to `A'. But 11.2
2119 [class.access.base] says that we need to convert 'this' to B* as
2120 part of the access, so we pass 'B' to maybe_dummy_object. */
2122 object
= maybe_dummy_object (BINFO_TYPE (BASELINK_ACCESS_BINFO (fn
)),
2125 if (processing_template_decl
)
2127 if (type_dependent_expression_p (object
))
2129 tree ret
= build_nt_call_vec (orig_fn
, orig_args
);
2130 release_tree_vector (orig_args
);
2133 object
= build_non_dependent_expr (object
);
2136 result
= build_new_method_call (object
, fn
, args
, NULL_TREE
,
2138 ? LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
2143 else if (is_overloaded_fn (fn
))
2145 /* If the function is an overloaded builtin, resolve it. */
2146 if (TREE_CODE (fn
) == FUNCTION_DECL
2147 && (DECL_BUILT_IN_CLASS (fn
) == BUILT_IN_NORMAL
2148 || DECL_BUILT_IN_CLASS (fn
) == BUILT_IN_MD
))
2149 result
= resolve_overloaded_builtin (input_location
, fn
, *args
);
2152 /* A call to a namespace-scope function. */
2153 result
= build_new_function_call (fn
, args
, koenig_p
, complain
);
2155 else if (TREE_CODE (fn
) == PSEUDO_DTOR_EXPR
)
2157 if (!VEC_empty (tree
, *args
))
2158 error ("arguments to destructor are not allowed");
2159 /* Mark the pseudo-destructor call as having side-effects so
2160 that we do not issue warnings about its use. */
2161 result
= build1 (NOP_EXPR
,
2163 TREE_OPERAND (fn
, 0));
2164 TREE_SIDE_EFFECTS (result
) = 1;
2166 else if (CLASS_TYPE_P (TREE_TYPE (fn
)))
2167 /* If the "function" is really an object of class type, it might
2168 have an overloaded `operator ()'. */
2169 result
= build_op_call (fn
, args
, complain
);
2172 /* A call where the function is unknown. */
2173 result
= cp_build_function_call_vec (fn
, args
, complain
);
2175 if (processing_template_decl
&& result
!= error_mark_node
)
2177 if (TREE_CODE (result
) == INDIRECT_REF
)
2178 result
= TREE_OPERAND (result
, 0);
2179 result
= build_call_vec (TREE_TYPE (result
), orig_fn
, orig_args
);
2180 SET_EXPR_LOCATION (result
, input_location
);
2181 KOENIG_LOOKUP_P (result
) = koenig_p
;
2182 release_tree_vector (orig_args
);
2183 result
= convert_from_reference (result
);
2188 /* Free garbage OVERLOADs from arg-dependent lookup. */
2189 tree next
= NULL_TREE
;
2191 fn
&& TREE_CODE (fn
) == OVERLOAD
&& OVL_ARG_DEPENDENT (fn
);
2194 if (processing_template_decl
)
2195 /* In a template, we'll re-use them at instantiation time. */
2196 OVL_ARG_DEPENDENT (fn
) = false;
2199 next
= OVL_CHAIN (fn
);
2208 /* Finish a call to a postfix increment or decrement or EXPR. (Which
2209 is indicated by CODE, which should be POSTINCREMENT_EXPR or
2210 POSTDECREMENT_EXPR.) */
2213 finish_increment_expr (tree expr
, enum tree_code code
)
2215 return build_x_unary_op (code
, expr
, tf_warning_or_error
);
2218 /* Finish a use of `this'. Returns an expression for `this'. */
2221 finish_this_expr (void)
2225 if (current_class_ptr
)
2227 tree type
= TREE_TYPE (current_class_ref
);
2229 /* In a lambda expression, 'this' refers to the captured 'this'. */
2230 if (LAMBDA_TYPE_P (type
))
2231 result
= lambda_expr_this_capture (CLASSTYPE_LAMBDA_EXPR (type
));
2233 result
= current_class_ptr
;
2236 else if (current_function_decl
2237 && DECL_STATIC_FUNCTION_P (current_function_decl
))
2239 error ("%<this%> is unavailable for static member functions");
2240 result
= error_mark_node
;
2244 if (current_function_decl
)
2245 error ("invalid use of %<this%> in non-member function");
2247 error ("invalid use of %<this%> at top level");
2248 result
= error_mark_node
;
2254 /* Finish a pseudo-destructor expression. If SCOPE is NULL, the
2255 expression was of the form `OBJECT.~DESTRUCTOR' where DESTRUCTOR is
2256 the TYPE for the type given. If SCOPE is non-NULL, the expression
2257 was of the form `OBJECT.SCOPE::~DESTRUCTOR'. */
2260 finish_pseudo_destructor_expr (tree object
, tree scope
, tree destructor
)
2262 if (object
== error_mark_node
|| destructor
== error_mark_node
)
2263 return error_mark_node
;
2265 gcc_assert (TYPE_P (destructor
));
2267 if (!processing_template_decl
)
2269 if (scope
== error_mark_node
)
2271 error ("invalid qualifying scope in pseudo-destructor name");
2272 return error_mark_node
;
2274 if (scope
&& TYPE_P (scope
) && !check_dtor_name (scope
, destructor
))
2276 error ("qualified type %qT does not match destructor name ~%qT",
2278 return error_mark_node
;
2282 /* [expr.pseudo] says both:
2284 The type designated by the pseudo-destructor-name shall be
2285 the same as the object type.
2289 The cv-unqualified versions of the object type and of the
2290 type designated by the pseudo-destructor-name shall be the
2293 We implement the more generous second sentence, since that is
2294 what most other compilers do. */
2295 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (object
),
2298 error ("%qE is not of type %qT", object
, destructor
);
2299 return error_mark_node
;
2303 return build3 (PSEUDO_DTOR_EXPR
, void_type_node
, object
, scope
, destructor
);
2306 /* Finish an expression of the form CODE EXPR. */
2309 finish_unary_op_expr (enum tree_code code
, tree expr
)
2311 tree result
= build_x_unary_op (code
, expr
, tf_warning_or_error
);
2312 /* Inside a template, build_x_unary_op does not fold the
2313 expression. So check whether the result is folded before
2314 setting TREE_NEGATED_INT. */
2315 if (code
== NEGATE_EXPR
&& TREE_CODE (expr
) == INTEGER_CST
2316 && TREE_CODE (result
) == INTEGER_CST
2317 && !TYPE_UNSIGNED (TREE_TYPE (result
))
2318 && INT_CST_LT (result
, integer_zero_node
))
2320 /* RESULT may be a cached INTEGER_CST, so we must copy it before
2321 setting TREE_NEGATED_INT. */
2322 result
= copy_node (result
);
2323 TREE_NEGATED_INT (result
) = 1;
2325 if (TREE_OVERFLOW_P (result
) && !TREE_OVERFLOW_P (expr
))
2326 overflow_warning (input_location
, result
);
2331 /* Finish a compound-literal expression. TYPE is the type to which
2332 the CONSTRUCTOR in COMPOUND_LITERAL is being cast. */
2335 finish_compound_literal (tree type
, tree compound_literal
,
2336 tsubst_flags_t complain
)
2338 if (type
== error_mark_node
)
2339 return error_mark_node
;
2341 if (TREE_CODE (type
) == REFERENCE_TYPE
)
2344 = finish_compound_literal (TREE_TYPE (type
), compound_literal
,
2346 return cp_build_c_cast (type
, compound_literal
, complain
);
2349 if (!TYPE_OBJ_P (type
))
2351 if (complain
& tf_error
)
2352 error ("compound literal of non-object type %qT", type
);
2353 return error_mark_node
;
2356 if (processing_template_decl
)
2358 TREE_TYPE (compound_literal
) = type
;
2359 /* Mark the expression as a compound literal. */
2360 TREE_HAS_CONSTRUCTOR (compound_literal
) = 1;
2361 return compound_literal
;
2364 type
= complete_type (type
);
2366 if (TYPE_NON_AGGREGATE_CLASS (type
))
2368 /* Trying to deal with a CONSTRUCTOR instead of a TREE_LIST
2369 everywhere that deals with function arguments would be a pain, so
2370 just wrap it in a TREE_LIST. The parser set a flag so we know
2371 that it came from T{} rather than T({}). */
2372 CONSTRUCTOR_IS_DIRECT_INIT (compound_literal
) = 1;
2373 compound_literal
= build_tree_list (NULL_TREE
, compound_literal
);
2374 return build_functional_cast (type
, compound_literal
, complain
);
2377 if (TREE_CODE (type
) == ARRAY_TYPE
2378 && check_array_initializer (NULL_TREE
, type
, compound_literal
))
2379 return error_mark_node
;
2380 compound_literal
= reshape_init (type
, compound_literal
, complain
);
2381 if (TREE_CODE (type
) == ARRAY_TYPE
2382 && TYPE_DOMAIN (type
) == NULL_TREE
)
2384 cp_complete_array_type_or_error (&type
, compound_literal
,
2386 if (type
== error_mark_node
)
2387 return error_mark_node
;
2389 compound_literal
= digest_init (type
, compound_literal
, complain
);
2390 /* Put static/constant array temporaries in static variables, but always
2391 represent class temporaries with TARGET_EXPR so we elide copies. */
2392 if ((!at_function_scope_p () || CP_TYPE_CONST_P (type
))
2393 && TREE_CODE (type
) == ARRAY_TYPE
2394 && !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
2395 && initializer_constant_valid_p (compound_literal
, type
))
2397 tree decl
= create_temporary_var (type
);
2398 DECL_INITIAL (decl
) = compound_literal
;
2399 TREE_STATIC (decl
) = 1;
2400 if (literal_type_p (type
) && CP_TYPE_CONST_NON_VOLATILE_P (type
))
2402 /* 5.19 says that a constant expression can include an
2403 lvalue-rvalue conversion applied to "a glvalue of literal type
2404 that refers to a non-volatile temporary object initialized
2405 with a constant expression". Rather than try to communicate
2406 that this VAR_DECL is a temporary, just mark it constexpr. */
2407 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
2408 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = true;
2409 TREE_CONSTANT (decl
) = true;
2411 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
2412 decl
= pushdecl_top_level (decl
);
2413 DECL_NAME (decl
) = make_anon_name ();
2414 SET_DECL_ASSEMBLER_NAME (decl
, DECL_NAME (decl
));
2418 return get_target_expr_sfinae (compound_literal
, complain
);
2421 /* Return the declaration for the function-name variable indicated by
2425 finish_fname (tree id
)
2429 decl
= fname_decl (input_location
, C_RID_CODE (id
), id
);
2430 if (processing_template_decl
&& current_function_decl
)
2431 decl
= DECL_NAME (decl
);
2435 /* Finish a translation unit. */
2438 finish_translation_unit (void)
2440 /* In case there were missing closebraces,
2441 get us back to the global binding level. */
2443 while (current_namespace
!= global_namespace
)
2446 /* Do file scope __FUNCTION__ et al. */
2447 finish_fname_decls ();
2450 /* Finish a template type parameter, specified as AGGR IDENTIFIER.
2451 Returns the parameter. */
2454 finish_template_type_parm (tree aggr
, tree identifier
)
2456 if (aggr
!= class_type_node
)
2458 permerror (input_location
, "template type parameters must use the keyword %<class%> or %<typename%>");
2459 aggr
= class_type_node
;
2462 return build_tree_list (aggr
, identifier
);
2465 /* Finish a template template parameter, specified as AGGR IDENTIFIER.
2466 Returns the parameter. */
2469 finish_template_template_parm (tree aggr
, tree identifier
)
2471 tree decl
= build_decl (input_location
,
2472 TYPE_DECL
, identifier
, NULL_TREE
);
2473 tree tmpl
= build_lang_decl (TEMPLATE_DECL
, identifier
, NULL_TREE
);
2474 DECL_TEMPLATE_PARMS (tmpl
) = current_template_parms
;
2475 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
2476 DECL_ARTIFICIAL (decl
) = 1;
2477 end_template_decl ();
2479 gcc_assert (DECL_TEMPLATE_PARMS (tmpl
));
2481 check_default_tmpl_args (decl
, DECL_TEMPLATE_PARMS (tmpl
),
2482 /*is_primary=*/true, /*is_partial=*/false,
2485 return finish_template_type_parm (aggr
, tmpl
);
2488 /* ARGUMENT is the default-argument value for a template template
2489 parameter. If ARGUMENT is invalid, issue error messages and return
2490 the ERROR_MARK_NODE. Otherwise, ARGUMENT itself is returned. */
2493 check_template_template_default_arg (tree argument
)
2495 if (TREE_CODE (argument
) != TEMPLATE_DECL
2496 && TREE_CODE (argument
) != TEMPLATE_TEMPLATE_PARM
2497 && TREE_CODE (argument
) != UNBOUND_CLASS_TEMPLATE
)
2499 if (TREE_CODE (argument
) == TYPE_DECL
)
2500 error ("invalid use of type %qT as a default value for a template "
2501 "template-parameter", TREE_TYPE (argument
));
2503 error ("invalid default argument for a template template parameter");
2504 return error_mark_node
;
2510 /* Begin a class definition, as indicated by T. */
2513 begin_class_definition (tree t
, tree attributes
)
2515 if (error_operand_p (t
) || error_operand_p (TYPE_MAIN_DECL (t
)))
2516 return error_mark_node
;
2518 if (processing_template_parmlist
)
2520 error ("definition of %q#T inside template parameter list", t
);
2521 return error_mark_node
;
2524 /* According to the C++ ABI, decimal classes defined in ISO/IEC TR 24733
2525 are passed the same as decimal scalar types. */
2526 if (TREE_CODE (t
) == RECORD_TYPE
2527 && !processing_template_decl
)
2529 tree ns
= TYPE_CONTEXT (t
);
2530 if (ns
&& TREE_CODE (ns
) == NAMESPACE_DECL
2531 && DECL_CONTEXT (ns
) == std_node
2533 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (ns
)), "decimal"))
2535 const char *n
= TYPE_NAME_STRING (t
);
2536 if ((strcmp (n
, "decimal32") == 0)
2537 || (strcmp (n
, "decimal64") == 0)
2538 || (strcmp (n
, "decimal128") == 0))
2539 TYPE_TRANSPARENT_AGGR (t
) = 1;
2543 /* A non-implicit typename comes from code like:
2545 template <typename T> struct A {
2546 template <typename U> struct A<T>::B ...
2548 This is erroneous. */
2549 else if (TREE_CODE (t
) == TYPENAME_TYPE
)
2551 error ("invalid definition of qualified type %qT", t
);
2552 t
= error_mark_node
;
2555 if (t
== error_mark_node
|| ! MAYBE_CLASS_TYPE_P (t
))
2557 t
= make_class_type (RECORD_TYPE
);
2558 pushtag (make_anon_name (), t
, /*tag_scope=*/ts_current
);
2561 if (TYPE_BEING_DEFINED (t
))
2563 t
= make_class_type (TREE_CODE (t
));
2564 pushtag (TYPE_IDENTIFIER (t
), t
, /*tag_scope=*/ts_current
);
2566 maybe_process_partial_specialization (t
);
2568 TYPE_BEING_DEFINED (t
) = 1;
2570 cplus_decl_attributes (&t
, attributes
, (int) ATTR_FLAG_TYPE_IN_PLACE
);
2571 fixup_attribute_variants (t
);
2573 if (flag_pack_struct
)
2576 TYPE_PACKED (t
) = 1;
2577 /* Even though the type is being defined for the first time
2578 here, there might have been a forward declaration, so there
2579 might be cv-qualified variants of T. */
2580 for (v
= TYPE_NEXT_VARIANT (t
); v
; v
= TYPE_NEXT_VARIANT (v
))
2581 TYPE_PACKED (v
) = 1;
2583 /* Reset the interface data, at the earliest possible
2584 moment, as it might have been set via a class foo;
2586 if (! TYPE_ANONYMOUS_P (t
))
2588 struct c_fileinfo
*finfo
= get_fileinfo (input_filename
);
2589 CLASSTYPE_INTERFACE_ONLY (t
) = finfo
->interface_only
;
2590 SET_CLASSTYPE_INTERFACE_UNKNOWN_X
2591 (t
, finfo
->interface_unknown
);
2593 reset_specialization();
2595 /* Make a declaration for this class in its own scope. */
2596 build_self_reference ();
2601 /* Finish the member declaration given by DECL. */
2604 finish_member_declaration (tree decl
)
2606 if (decl
== error_mark_node
|| decl
== NULL_TREE
)
2609 if (decl
== void_type_node
)
2610 /* The COMPONENT was a friend, not a member, and so there's
2611 nothing for us to do. */
2614 /* We should see only one DECL at a time. */
2615 gcc_assert (DECL_CHAIN (decl
) == NULL_TREE
);
2617 /* Set up access control for DECL. */
2619 = (current_access_specifier
== access_private_node
);
2620 TREE_PROTECTED (decl
)
2621 = (current_access_specifier
== access_protected_node
);
2622 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
2624 TREE_PRIVATE (DECL_TEMPLATE_RESULT (decl
)) = TREE_PRIVATE (decl
);
2625 TREE_PROTECTED (DECL_TEMPLATE_RESULT (decl
)) = TREE_PROTECTED (decl
);
2628 /* Mark the DECL as a member of the current class. */
2629 DECL_CONTEXT (decl
) = current_class_type
;
2631 /* Check for bare parameter packs in the member variable declaration. */
2632 if (TREE_CODE (decl
) == FIELD_DECL
)
2634 if (check_for_bare_parameter_packs (TREE_TYPE (decl
)))
2635 TREE_TYPE (decl
) = error_mark_node
;
2636 if (check_for_bare_parameter_packs (DECL_ATTRIBUTES (decl
)))
2637 DECL_ATTRIBUTES (decl
) = NULL_TREE
;
2642 A C language linkage is ignored for the names of class members
2643 and the member function type of class member functions. */
2644 if (DECL_LANG_SPECIFIC (decl
) && DECL_LANGUAGE (decl
) == lang_c
)
2645 SET_DECL_LANGUAGE (decl
, lang_cplusplus
);
2647 /* Put functions on the TYPE_METHODS list and everything else on the
2648 TYPE_FIELDS list. Note that these are built up in reverse order.
2649 We reverse them (to obtain declaration order) in finish_struct. */
2650 if (TREE_CODE (decl
) == FUNCTION_DECL
2651 || DECL_FUNCTION_TEMPLATE_P (decl
))
2653 /* We also need to add this function to the
2654 CLASSTYPE_METHOD_VEC. */
2655 if (add_method (current_class_type
, decl
, NULL_TREE
))
2657 DECL_CHAIN (decl
) = TYPE_METHODS (current_class_type
);
2658 TYPE_METHODS (current_class_type
) = decl
;
2660 maybe_add_class_template_decl_list (current_class_type
, decl
,
2664 /* Enter the DECL into the scope of the class. */
2665 else if ((TREE_CODE (decl
) == USING_DECL
&& !DECL_DEPENDENT_P (decl
))
2666 || pushdecl_class_level (decl
))
2668 /* All TYPE_DECLs go at the end of TYPE_FIELDS. Ordinary fields
2669 go at the beginning. The reason is that lookup_field_1
2670 searches the list in order, and we want a field name to
2671 override a type name so that the "struct stat hack" will
2672 work. In particular:
2674 struct S { enum E { }; int E } s;
2677 is valid. In addition, the FIELD_DECLs must be maintained in
2678 declaration order so that class layout works as expected.
2679 However, we don't need that order until class layout, so we
2680 save a little time by putting FIELD_DECLs on in reverse order
2681 here, and then reversing them in finish_struct_1. (We could
2682 also keep a pointer to the correct insertion points in the
2685 if (TREE_CODE (decl
) == TYPE_DECL
)
2686 TYPE_FIELDS (current_class_type
)
2687 = chainon (TYPE_FIELDS (current_class_type
), decl
);
2690 DECL_CHAIN (decl
) = TYPE_FIELDS (current_class_type
);
2691 TYPE_FIELDS (current_class_type
) = decl
;
2694 maybe_add_class_template_decl_list (current_class_type
, decl
,
2699 note_decl_for_pch (decl
);
2702 /* DECL has been declared while we are building a PCH file. Perform
2703 actions that we might normally undertake lazily, but which can be
2704 performed now so that they do not have to be performed in
2705 translation units which include the PCH file. */
2708 note_decl_for_pch (tree decl
)
2710 gcc_assert (pch_file
);
2712 /* There's a good chance that we'll have to mangle names at some
2713 point, even if only for emission in debugging information. */
2714 if ((TREE_CODE (decl
) == VAR_DECL
2715 || TREE_CODE (decl
) == FUNCTION_DECL
)
2716 && !processing_template_decl
)
2720 /* Finish processing a complete template declaration. The PARMS are
2721 the template parameters. */
2724 finish_template_decl (tree parms
)
2727 end_template_decl ();
2729 end_specialization ();
2732 /* Finish processing a template-id (which names a type) of the form
2733 NAME < ARGS >. Return the TYPE_DECL for the type named by the
2734 template-id. If ENTERING_SCOPE is nonzero we are about to enter
2735 the scope of template-id indicated. */
2738 finish_template_type (tree name
, tree args
, int entering_scope
)
2742 decl
= lookup_template_class (name
, args
,
2743 NULL_TREE
, NULL_TREE
, entering_scope
,
2744 tf_warning_or_error
| tf_user
);
2745 if (decl
!= error_mark_node
)
2746 decl
= TYPE_STUB_DECL (decl
);
2751 /* Finish processing a BASE_CLASS with the indicated ACCESS_SPECIFIER.
2752 Return a TREE_LIST containing the ACCESS_SPECIFIER and the
2753 BASE_CLASS, or NULL_TREE if an error occurred. The
2754 ACCESS_SPECIFIER is one of
2755 access_{default,public,protected_private}_node. For a virtual base
2756 we set TREE_TYPE. */
2759 finish_base_specifier (tree base
, tree access
, bool virtual_p
)
2763 if (base
== error_mark_node
)
2765 error ("invalid base-class specification");
2768 else if (! MAYBE_CLASS_TYPE_P (base
))
2770 error ("%qT is not a class type", base
);
2775 if (cp_type_quals (base
) != 0)
2777 /* DR 484: Can a base-specifier name a cv-qualified
2779 base
= TYPE_MAIN_VARIANT (base
);
2781 result
= build_tree_list (access
, base
);
2783 TREE_TYPE (result
) = integer_type_node
;
2789 /* If FNS is a member function, a set of member functions, or a
2790 template-id referring to one or more member functions, return a
2791 BASELINK for FNS, incorporating the current access context.
2792 Otherwise, return FNS unchanged. */
2795 baselink_for_fns (tree fns
)
2800 if (BASELINK_P (fns
)
2801 || error_operand_p (fns
))
2805 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
2806 fn
= TREE_OPERAND (fn
, 0);
2807 fn
= get_first_fn (fn
);
2808 if (!DECL_FUNCTION_MEMBER_P (fn
))
2811 cl
= currently_open_derived_class (DECL_CONTEXT (fn
));
2813 cl
= DECL_CONTEXT (fn
);
2814 cl
= TYPE_BINFO (cl
);
2815 return build_baselink (cl
, cl
, fns
, /*optype=*/NULL_TREE
);
2818 /* Returns true iff DECL is an automatic variable from a function outside
2822 outer_automatic_var_p (tree decl
)
2824 return ((TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == PARM_DECL
)
2825 && DECL_FUNCTION_SCOPE_P (decl
)
2826 && !TREE_STATIC (decl
)
2827 && DECL_CONTEXT (decl
) != current_function_decl
);
2830 /* Returns true iff DECL is a capture field from a lambda that is not our
2831 immediate context. */
2834 outer_lambda_capture_p (tree decl
)
2836 return (TREE_CODE (decl
) == FIELD_DECL
2837 && LAMBDA_TYPE_P (DECL_CONTEXT (decl
))
2838 && (!current_class_type
2839 || !DERIVED_FROM_P (DECL_CONTEXT (decl
), current_class_type
)));
2842 /* ID_EXPRESSION is a representation of parsed, but unprocessed,
2843 id-expression. (See cp_parser_id_expression for details.) SCOPE,
2844 if non-NULL, is the type or namespace used to explicitly qualify
2845 ID_EXPRESSION. DECL is the entity to which that name has been
2848 *CONSTANT_EXPRESSION_P is true if we are presently parsing a
2849 constant-expression. In that case, *NON_CONSTANT_EXPRESSION_P will
2850 be set to true if this expression isn't permitted in a
2851 constant-expression, but it is otherwise not set by this function.
2852 *ALLOW_NON_CONSTANT_EXPRESSION_P is true if we are parsing a
2853 constant-expression, but a non-constant expression is also
2856 DONE is true if this expression is a complete postfix-expression;
2857 it is false if this expression is followed by '->', '[', '(', etc.
2858 ADDRESS_P is true iff this expression is the operand of '&'.
2859 TEMPLATE_P is true iff the qualified-id was of the form
2860 "A::template B". TEMPLATE_ARG_P is true iff this qualified name
2861 appears as a template argument.
2863 If an error occurs, and it is the kind of error that might cause
2864 the parser to abort a tentative parse, *ERROR_MSG is filled in. It
2865 is the caller's responsibility to issue the message. *ERROR_MSG
2866 will be a string with static storage duration, so the caller need
2869 Return an expression for the entity, after issuing appropriate
2870 diagnostics. This function is also responsible for transforming a
2871 reference to a non-static member into a COMPONENT_REF that makes
2872 the use of "this" explicit.
2874 Upon return, *IDK will be filled in appropriately. */
2876 finish_id_expression (tree id_expression
,
2880 bool integral_constant_expression_p
,
2881 bool allow_non_integral_constant_expression_p
,
2882 bool *non_integral_constant_expression_p
,
2886 bool template_arg_p
,
2887 const char **error_msg
,
2888 location_t location
)
2890 /* Initialize the output parameters. */
2891 *idk
= CP_ID_KIND_NONE
;
2894 if (id_expression
== error_mark_node
)
2895 return error_mark_node
;
2896 /* If we have a template-id, then no further lookup is
2897 required. If the template-id was for a template-class, we
2898 will sometimes have a TYPE_DECL at this point. */
2899 else if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
2900 || TREE_CODE (decl
) == TYPE_DECL
)
2902 /* Look up the name. */
2905 if (decl
== error_mark_node
)
2907 /* Name lookup failed. */
2910 || (!dependent_type_p (scope
)
2911 && !(TREE_CODE (id_expression
) == IDENTIFIER_NODE
2912 && IDENTIFIER_TYPENAME_P (id_expression
)
2913 && dependent_type_p (TREE_TYPE (id_expression
))))))
2915 /* If the qualifying type is non-dependent (and the name
2916 does not name a conversion operator to a dependent
2917 type), issue an error. */
2918 qualified_name_lookup_error (scope
, id_expression
, decl
, location
);
2919 return error_mark_node
;
2923 /* It may be resolved via Koenig lookup. */
2924 *idk
= CP_ID_KIND_UNQUALIFIED
;
2925 return id_expression
;
2928 decl
= id_expression
;
2930 /* If DECL is a variable that would be out of scope under
2931 ANSI/ISO rules, but in scope in the ARM, name lookup
2932 will succeed. Issue a diagnostic here. */
2934 decl
= check_for_out_of_scope_variable (decl
);
2936 /* Remember that the name was used in the definition of
2937 the current class so that we can check later to see if
2938 the meaning would have been different after the class
2939 was entirely defined. */
2940 if (!scope
&& decl
!= error_mark_node
2941 && TREE_CODE (id_expression
) == IDENTIFIER_NODE
)
2942 maybe_note_name_used_in_class (id_expression
, decl
);
2944 /* Disallow uses of local variables from containing functions, except
2945 within lambda-expressions. */
2946 if ((outer_automatic_var_p (decl
)
2947 || outer_lambda_capture_p (decl
))
2948 /* It's not a use (3.2) if we're in an unevaluated context. */
2949 && !cp_unevaluated_operand
)
2951 tree context
= DECL_CONTEXT (decl
);
2952 tree containing_function
= current_function_decl
;
2953 tree lambda_stack
= NULL_TREE
;
2954 tree lambda_expr
= NULL_TREE
;
2955 tree initializer
= decl
;
2957 /* Core issue 696: "[At the July 2009 meeting] the CWG expressed
2958 support for an approach in which a reference to a local
2959 [constant] automatic variable in a nested class or lambda body
2960 would enter the expression as an rvalue, which would reduce
2961 the complexity of the problem"
2963 FIXME update for final resolution of core issue 696. */
2964 if (decl_constant_var_p (decl
))
2965 return integral_constant_value (decl
);
2967 if (TYPE_P (context
))
2969 /* Implicit capture of an explicit capture. */
2970 context
= lambda_function (context
);
2971 initializer
= thisify_lambda_field (decl
);
2974 /* If we are in a lambda function, we can move out until we hit
2976 2. a non-lambda function, or
2977 3. a non-default capturing lambda function. */
2978 while (context
!= containing_function
2979 && LAMBDA_FUNCTION_P (containing_function
))
2981 lambda_expr
= CLASSTYPE_LAMBDA_EXPR
2982 (DECL_CONTEXT (containing_function
));
2984 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr
)
2988 lambda_stack
= tree_cons (NULL_TREE
,
2993 = decl_function_context (containing_function
);
2996 if (context
== containing_function
)
2998 decl
= add_default_capture (lambda_stack
,
2999 /*id=*/DECL_NAME (decl
),
3002 else if (lambda_expr
)
3004 error ("%qD is not captured", decl
);
3005 return error_mark_node
;
3009 error (TREE_CODE (decl
) == VAR_DECL
3010 ? "use of %<auto%> variable from containing function"
3011 : "use of parameter from containing function");
3012 error (" %q+#D declared here", decl
);
3013 return error_mark_node
;
3017 /* Also disallow uses of function parameters outside the function
3018 body, except inside an unevaluated context (i.e. decltype). */
3019 if (TREE_CODE (decl
) == PARM_DECL
3020 && DECL_CONTEXT (decl
) == NULL_TREE
3021 && !cp_unevaluated_operand
)
3023 error ("use of parameter %qD outside function body", decl
);
3024 return error_mark_node
;
3028 /* If we didn't find anything, or what we found was a type,
3029 then this wasn't really an id-expression. */
3030 if (TREE_CODE (decl
) == TEMPLATE_DECL
3031 && !DECL_FUNCTION_TEMPLATE_P (decl
))
3033 *error_msg
= "missing template arguments";
3034 return error_mark_node
;
3036 else if (TREE_CODE (decl
) == TYPE_DECL
3037 || TREE_CODE (decl
) == NAMESPACE_DECL
)
3039 *error_msg
= "expected primary-expression";
3040 return error_mark_node
;
3043 /* If the name resolved to a template parameter, there is no
3044 need to look it up again later. */
3045 if ((TREE_CODE (decl
) == CONST_DECL
&& DECL_TEMPLATE_PARM_P (decl
))
3046 || TREE_CODE (decl
) == TEMPLATE_PARM_INDEX
)
3050 *idk
= CP_ID_KIND_NONE
;
3051 if (TREE_CODE (decl
) == TEMPLATE_PARM_INDEX
)
3052 decl
= TEMPLATE_PARM_DECL (decl
);
3053 r
= convert_from_reference (DECL_INITIAL (decl
));
3055 if (integral_constant_expression_p
3056 && !dependent_type_p (TREE_TYPE (decl
))
3057 && !(INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (r
))))
3059 if (!allow_non_integral_constant_expression_p
)
3060 error ("template parameter %qD of type %qT is not allowed in "
3061 "an integral constant expression because it is not of "
3062 "integral or enumeration type", decl
, TREE_TYPE (decl
));
3063 *non_integral_constant_expression_p
= true;
3067 /* Similarly, we resolve enumeration constants to their
3068 underlying values. */
3069 else if (TREE_CODE (decl
) == CONST_DECL
)
3071 *idk
= CP_ID_KIND_NONE
;
3072 if (!processing_template_decl
)
3074 used_types_insert (TREE_TYPE (decl
));
3075 return DECL_INITIAL (decl
);
3083 /* If the declaration was explicitly qualified indicate
3084 that. The semantics of `A::f(3)' are different than
3085 `f(3)' if `f' is virtual. */
3087 ? CP_ID_KIND_QUALIFIED
3088 : (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
3089 ? CP_ID_KIND_TEMPLATE_ID
3090 : CP_ID_KIND_UNQUALIFIED
));
3095 An id-expression is type-dependent if it contains an
3096 identifier that was declared with a dependent type.
3098 The standard is not very specific about an id-expression that
3099 names a set of overloaded functions. What if some of them
3100 have dependent types and some of them do not? Presumably,
3101 such a name should be treated as a dependent name. */
3102 /* Assume the name is not dependent. */
3103 dependent_p
= false;
3104 if (!processing_template_decl
)
3105 /* No names are dependent outside a template. */
3107 /* A template-id where the name of the template was not resolved
3108 is definitely dependent. */
3109 else if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
3110 && (TREE_CODE (TREE_OPERAND (decl
, 0))
3111 == IDENTIFIER_NODE
))
3113 /* For anything except an overloaded function, just check its
3115 else if (!is_overloaded_fn (decl
))
3117 = dependent_type_p (TREE_TYPE (decl
));
3118 /* For a set of overloaded functions, check each of the
3124 if (BASELINK_P (fns
))
3125 fns
= BASELINK_FUNCTIONS (fns
);
3127 /* For a template-id, check to see if the template
3128 arguments are dependent. */
3129 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
3131 tree args
= TREE_OPERAND (fns
, 1);
3132 dependent_p
= any_dependent_template_arguments_p (args
);
3133 /* The functions are those referred to by the
3135 fns
= TREE_OPERAND (fns
, 0);
3138 /* If there are no dependent template arguments, go through
3139 the overloaded functions. */
3140 while (fns
&& !dependent_p
)
3142 tree fn
= OVL_CURRENT (fns
);
3144 /* Member functions of dependent classes are
3146 if (TREE_CODE (fn
) == FUNCTION_DECL
3147 && type_dependent_expression_p (fn
))
3149 else if (TREE_CODE (fn
) == TEMPLATE_DECL
3150 && dependent_template_p (fn
))
3153 fns
= OVL_NEXT (fns
);
3157 /* If the name was dependent on a template parameter, we will
3158 resolve the name at instantiation time. */
3161 /* Create a SCOPE_REF for qualified names, if the scope is
3167 if (address_p
&& done
)
3168 decl
= finish_qualified_id_expr (scope
, decl
,
3174 tree type
= NULL_TREE
;
3175 if (DECL_P (decl
) && !dependent_scope_p (scope
))
3176 type
= TREE_TYPE (decl
);
3177 decl
= build_qualified_name (type
,
3183 if (TREE_TYPE (decl
))
3184 decl
= convert_from_reference (decl
);
3187 /* A TEMPLATE_ID already contains all the information we
3189 if (TREE_CODE (id_expression
) == TEMPLATE_ID_EXPR
)
3190 return id_expression
;
3191 *idk
= CP_ID_KIND_UNQUALIFIED_DEPENDENT
;
3192 /* If we found a variable, then name lookup during the
3193 instantiation will always resolve to the same VAR_DECL
3194 (or an instantiation thereof). */
3195 if (TREE_CODE (decl
) == VAR_DECL
3196 || TREE_CODE (decl
) == PARM_DECL
)
3197 return convert_from_reference (decl
);
3198 /* The same is true for FIELD_DECL, but we also need to
3199 make sure that the syntax is correct. */
3200 else if (TREE_CODE (decl
) == FIELD_DECL
)
3202 /* Since SCOPE is NULL here, this is an unqualified name.
3203 Access checking has been performed during name lookup
3204 already. Turn off checking to avoid duplicate errors. */
3205 push_deferring_access_checks (dk_no_check
);
3206 decl
= finish_non_static_data_member
3208 /*qualifying_scope=*/NULL_TREE
);
3209 pop_deferring_access_checks ();
3212 return id_expression
;
3215 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
3217 error ("use of namespace %qD as expression", decl
);
3218 return error_mark_node
;
3220 else if (DECL_CLASS_TEMPLATE_P (decl
))
3222 error ("use of class template %qT as expression", decl
);
3223 return error_mark_node
;
3225 else if (TREE_CODE (decl
) == TREE_LIST
)
3227 /* Ambiguous reference to base members. */
3228 error ("request for member %qD is ambiguous in "
3229 "multiple inheritance lattice", id_expression
);
3230 print_candidates (decl
);
3231 return error_mark_node
;
3234 /* Mark variable-like entities as used. Functions are similarly
3235 marked either below or after overload resolution. */
3236 if (TREE_CODE (decl
) == VAR_DECL
3237 || TREE_CODE (decl
) == PARM_DECL
3238 || TREE_CODE (decl
) == RESULT_DECL
)
3241 /* Only certain kinds of names are allowed in constant
3242 expression. Enumerators and template parameters have already
3243 been handled above. */
3244 if (! error_operand_p (decl
)
3245 && integral_constant_expression_p
3246 && ! decl_constant_var_p (decl
)
3247 && ! builtin_valid_in_constant_expr_p (decl
))
3249 if (!allow_non_integral_constant_expression_p
)
3251 error ("%qD cannot appear in a constant-expression", decl
);
3252 return error_mark_node
;
3254 *non_integral_constant_expression_p
= true;
3259 decl
= (adjust_result_of_qualified_name_lookup
3260 (decl
, scope
, current_class_type
));
3262 if (TREE_CODE (decl
) == FUNCTION_DECL
)
3265 if (TREE_CODE (decl
) == FIELD_DECL
|| BASELINK_P (decl
))
3266 decl
= finish_qualified_id_expr (scope
,
3274 tree r
= convert_from_reference (decl
);
3276 /* In a template, return a SCOPE_REF for most qualified-ids
3277 so that we can check access at instantiation time. But if
3278 we're looking at a member of the current instantiation, we
3279 know we have access and building up the SCOPE_REF confuses
3280 non-type template argument handling. */
3281 if (processing_template_decl
&& TYPE_P (scope
)
3282 && !currently_open_class (scope
))
3283 r
= build_qualified_name (TREE_TYPE (r
),
3289 else if (TREE_CODE (decl
) == FIELD_DECL
)
3291 /* Since SCOPE is NULL here, this is an unqualified name.
3292 Access checking has been performed during name lookup
3293 already. Turn off checking to avoid duplicate errors. */
3294 push_deferring_access_checks (dk_no_check
);
3295 decl
= finish_non_static_data_member (decl
, NULL_TREE
,
3296 /*qualifying_scope=*/NULL_TREE
);
3297 pop_deferring_access_checks ();
3299 else if (is_overloaded_fn (decl
))
3303 first_fn
= get_first_fn (decl
);
3304 if (TREE_CODE (first_fn
) == TEMPLATE_DECL
)
3305 first_fn
= DECL_TEMPLATE_RESULT (first_fn
);
3307 if (!really_overloaded_fn (decl
))
3308 mark_used (first_fn
);
3311 && TREE_CODE (first_fn
) == FUNCTION_DECL
3312 && DECL_FUNCTION_MEMBER_P (first_fn
)
3313 && !shared_member_p (decl
))
3315 /* A set of member functions. */
3316 decl
= maybe_dummy_object (DECL_CONTEXT (first_fn
), 0);
3317 return finish_class_member_access_expr (decl
, id_expression
,
3318 /*template_p=*/false,
3319 tf_warning_or_error
);
3322 decl
= baselink_for_fns (decl
);
3326 if (DECL_P (decl
) && DECL_NONLOCAL (decl
)
3327 && DECL_CLASS_SCOPE_P (decl
))
3329 tree context
= context_for_name_lookup (decl
);
3330 if (context
!= current_class_type
)
3332 tree path
= currently_open_derived_class (context
);
3333 perform_or_defer_access_check (TYPE_BINFO (path
),
3338 decl
= convert_from_reference (decl
);
3342 if (TREE_DEPRECATED (decl
))
3343 warn_deprecated_use (decl
, NULL_TREE
);
3348 /* Implement the __typeof keyword: Return the type of EXPR, suitable for
3349 use as a type-specifier. */
3352 finish_typeof (tree expr
)
3356 if (type_dependent_expression_p (expr
))
3358 type
= cxx_make_type (TYPEOF_TYPE
);
3359 TYPEOF_TYPE_EXPR (type
) = expr
;
3360 SET_TYPE_STRUCTURAL_EQUALITY (type
);
3365 expr
= mark_type_use (expr
);
3367 type
= unlowered_expr_type (expr
);
3369 if (!type
|| type
== unknown_type_node
)
3371 error ("type of %qE is unknown", expr
);
3372 return error_mark_node
;
3378 /* Implement the __underlying_type keyword: Return the underlying
3379 type of TYPE, suitable for use as a type-specifier. */
3382 finish_underlying_type (tree type
)
3384 tree underlying_type
;
3386 if (processing_template_decl
)
3388 underlying_type
= cxx_make_type (UNDERLYING_TYPE
);
3389 UNDERLYING_TYPE_TYPE (underlying_type
) = type
;
3390 SET_TYPE_STRUCTURAL_EQUALITY (underlying_type
);
3392 return underlying_type
;
3395 complete_type (type
);
3397 if (TREE_CODE (type
) != ENUMERAL_TYPE
)
3399 error ("%qE is not an enumeration type", type
);
3400 return error_mark_node
;
3403 underlying_type
= ENUM_UNDERLYING_TYPE (type
);
3405 /* Fixup necessary in this case because ENUM_UNDERLYING_TYPE
3406 includes TYPE_MIN_VALUE and TYPE_MAX_VALUE information.
3407 See finish_enum_value_list for details. */
3408 if (!ENUM_FIXED_UNDERLYING_TYPE_P (type
))
3410 = c_common_type_for_mode (TYPE_MODE (underlying_type
),
3411 TYPE_UNSIGNED (underlying_type
));
3413 return underlying_type
;
3416 /* Perform C++-specific checks for __builtin_offsetof before calling
3420 finish_offsetof (tree expr
)
3422 if (TREE_CODE (expr
) == PSEUDO_DTOR_EXPR
)
3424 error ("cannot apply %<offsetof%> to destructor %<~%T%>",
3425 TREE_OPERAND (expr
, 2));
3426 return error_mark_node
;
3428 if (TREE_CODE (TREE_TYPE (expr
)) == FUNCTION_TYPE
3429 || TREE_CODE (TREE_TYPE (expr
)) == METHOD_TYPE
3430 || TREE_TYPE (expr
) == unknown_type_node
)
3432 if (TREE_CODE (expr
) == COMPONENT_REF
3433 || TREE_CODE (expr
) == COMPOUND_EXPR
)
3434 expr
= TREE_OPERAND (expr
, 1);
3435 error ("cannot apply %<offsetof%> to member function %qD", expr
);
3436 return error_mark_node
;
3438 if (REFERENCE_REF_P (expr
))
3439 expr
= TREE_OPERAND (expr
, 0);
3440 return fold_offsetof (expr
, NULL_TREE
);
3443 /* Replace the AGGR_INIT_EXPR at *TP with an equivalent CALL_EXPR. This
3444 function is broken out from the above for the benefit of the tree-ssa
3448 simplify_aggr_init_expr (tree
*tp
)
3450 tree aggr_init_expr
= *tp
;
3452 /* Form an appropriate CALL_EXPR. */
3453 tree fn
= AGGR_INIT_EXPR_FN (aggr_init_expr
);
3454 tree slot
= AGGR_INIT_EXPR_SLOT (aggr_init_expr
);
3455 tree type
= TREE_TYPE (slot
);
3458 enum style_t
{ ctor
, arg
, pcc
} style
;
3460 if (AGGR_INIT_VIA_CTOR_P (aggr_init_expr
))
3462 #ifdef PCC_STATIC_STRUCT_RETURN
3468 gcc_assert (TREE_ADDRESSABLE (type
));
3472 call_expr
= build_call_array_loc (input_location
,
3473 TREE_TYPE (TREE_TYPE (TREE_TYPE (fn
))),
3475 aggr_init_expr_nargs (aggr_init_expr
),
3476 AGGR_INIT_EXPR_ARGP (aggr_init_expr
));
3477 TREE_NOTHROW (call_expr
) = TREE_NOTHROW (aggr_init_expr
);
3481 /* Replace the first argument to the ctor with the address of the
3483 cxx_mark_addressable (slot
);
3484 CALL_EXPR_ARG (call_expr
, 0) =
3485 build1 (ADDR_EXPR
, build_pointer_type (type
), slot
);
3487 else if (style
== arg
)
3489 /* Just mark it addressable here, and leave the rest to
3490 expand_call{,_inline}. */
3491 cxx_mark_addressable (slot
);
3492 CALL_EXPR_RETURN_SLOT_OPT (call_expr
) = true;
3493 call_expr
= build2 (INIT_EXPR
, TREE_TYPE (call_expr
), slot
, call_expr
);
3495 else if (style
== pcc
)
3497 /* If we're using the non-reentrant PCC calling convention, then we
3498 need to copy the returned value out of the static buffer into the
3500 push_deferring_access_checks (dk_no_check
);
3501 call_expr
= build_aggr_init (slot
, call_expr
,
3502 DIRECT_BIND
| LOOKUP_ONLYCONVERTING
,
3503 tf_warning_or_error
);
3504 pop_deferring_access_checks ();
3505 call_expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (slot
), call_expr
, slot
);
3508 if (AGGR_INIT_ZERO_FIRST (aggr_init_expr
))
3510 tree init
= build_zero_init (type
, NULL_TREE
,
3511 /*static_storage_p=*/false);
3512 init
= build2 (INIT_EXPR
, void_type_node
, slot
, init
);
3513 call_expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (call_expr
),
3520 /* Emit all thunks to FN that should be emitted when FN is emitted. */
3523 emit_associated_thunks (tree fn
)
3525 /* When we use vcall offsets, we emit thunks with the virtual
3526 functions to which they thunk. The whole point of vcall offsets
3527 is so that you can know statically the entire set of thunks that
3528 will ever be needed for a given virtual function, thereby
3529 enabling you to output all the thunks with the function itself. */
3530 if (DECL_VIRTUAL_P (fn
)
3531 /* Do not emit thunks for extern template instantiations. */
3532 && ! DECL_REALLY_EXTERN (fn
))
3536 for (thunk
= DECL_THUNKS (fn
); thunk
; thunk
= DECL_CHAIN (thunk
))
3538 if (!THUNK_ALIAS (thunk
))
3540 use_thunk (thunk
, /*emit_p=*/1);
3541 if (DECL_RESULT_THUNK_P (thunk
))
3545 for (probe
= DECL_THUNKS (thunk
);
3546 probe
; probe
= DECL_CHAIN (probe
))
3547 use_thunk (probe
, /*emit_p=*/1);
3551 gcc_assert (!DECL_THUNKS (thunk
));
3556 /* Generate RTL for FN. */
3559 expand_or_defer_fn_1 (tree fn
)
3561 /* When the parser calls us after finishing the body of a template
3562 function, we don't really want to expand the body. */
3563 if (processing_template_decl
)
3565 /* Normally, collection only occurs in rest_of_compilation. So,
3566 if we don't collect here, we never collect junk generated
3567 during the processing of templates until we hit a
3568 non-template function. It's not safe to do this inside a
3569 nested class, though, as the parser may have local state that
3570 is not a GC root. */
3571 if (!function_depth
)
3576 gcc_assert (DECL_SAVED_TREE (fn
));
3578 /* If this is a constructor or destructor body, we have to clone
3580 if (maybe_clone_body (fn
))
3582 /* We don't want to process FN again, so pretend we've written
3583 it out, even though we haven't. */
3584 TREE_ASM_WRITTEN (fn
) = 1;
3585 DECL_SAVED_TREE (fn
) = NULL_TREE
;
3589 /* We make a decision about linkage for these functions at the end
3590 of the compilation. Until that point, we do not want the back
3591 end to output them -- but we do want it to see the bodies of
3592 these functions so that it can inline them as appropriate. */
3593 if (DECL_DECLARED_INLINE_P (fn
) || DECL_IMPLICIT_INSTANTIATION (fn
))
3595 if (DECL_INTERFACE_KNOWN (fn
))
3596 /* We've already made a decision as to how this function will
3600 DECL_EXTERNAL (fn
) = 1;
3601 DECL_NOT_REALLY_EXTERN (fn
) = 1;
3602 note_vague_linkage_fn (fn
);
3603 /* A non-template inline function with external linkage will
3604 always be COMDAT. As we must eventually determine the
3605 linkage of all functions, and as that causes writes to
3606 the data mapped in from the PCH file, it's advantageous
3607 to mark the functions at this point. */
3608 if (!DECL_IMPLICIT_INSTANTIATION (fn
))
3610 /* This function must have external linkage, as
3611 otherwise DECL_INTERFACE_KNOWN would have been
3613 gcc_assert (TREE_PUBLIC (fn
));
3614 comdat_linkage (fn
);
3615 DECL_INTERFACE_KNOWN (fn
) = 1;
3619 import_export_decl (fn
);
3621 /* If the user wants us to keep all inline functions, then mark
3622 this function as needed so that finish_file will make sure to
3623 output it later. Similarly, all dllexport'd functions must
3624 be emitted; there may be callers in other DLLs. */
3625 if ((flag_keep_inline_functions
3626 && DECL_DECLARED_INLINE_P (fn
)
3627 && !DECL_REALLY_EXTERN (fn
))
3628 || (flag_keep_inline_dllexport
3629 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (fn
))))
3633 /* There's no reason to do any of the work here if we're only doing
3634 semantic analysis; this code just generates RTL. */
3635 if (flag_syntax_only
)
3642 expand_or_defer_fn (tree fn
)
3644 if (expand_or_defer_fn_1 (fn
))
3648 /* Expand or defer, at the whim of the compilation unit manager. */
3649 cgraph_finalize_function (fn
, function_depth
> 1);
3650 emit_associated_thunks (fn
);
3663 /* Helper function for walk_tree, used by finalize_nrv below. */
3666 finalize_nrv_r (tree
* tp
, int* walk_subtrees
, void* data
)
3668 struct nrv_data
*dp
= (struct nrv_data
*)data
;
3671 /* No need to walk into types. There wouldn't be any need to walk into
3672 non-statements, except that we have to consider STMT_EXPRs. */
3675 /* Change all returns to just refer to the RESULT_DECL; this is a nop,
3676 but differs from using NULL_TREE in that it indicates that we care
3677 about the value of the RESULT_DECL. */
3678 else if (TREE_CODE (*tp
) == RETURN_EXPR
)
3679 TREE_OPERAND (*tp
, 0) = dp
->result
;
3680 /* Change all cleanups for the NRV to only run when an exception is
3682 else if (TREE_CODE (*tp
) == CLEANUP_STMT
3683 && CLEANUP_DECL (*tp
) == dp
->var
)
3684 CLEANUP_EH_ONLY (*tp
) = 1;
3685 /* Replace the DECL_EXPR for the NRV with an initialization of the
3686 RESULT_DECL, if needed. */
3687 else if (TREE_CODE (*tp
) == DECL_EXPR
3688 && DECL_EXPR_DECL (*tp
) == dp
->var
)
3691 if (DECL_INITIAL (dp
->var
)
3692 && DECL_INITIAL (dp
->var
) != error_mark_node
)
3693 init
= build2 (INIT_EXPR
, void_type_node
, dp
->result
,
3694 DECL_INITIAL (dp
->var
));
3696 init
= build_empty_stmt (EXPR_LOCATION (*tp
));
3697 DECL_INITIAL (dp
->var
) = NULL_TREE
;
3698 SET_EXPR_LOCATION (init
, EXPR_LOCATION (*tp
));
3701 /* And replace all uses of the NRV with the RESULT_DECL. */
3702 else if (*tp
== dp
->var
)
3705 /* Avoid walking into the same tree more than once. Unfortunately, we
3706 can't just use walk_tree_without duplicates because it would only call
3707 us for the first occurrence of dp->var in the function body. */
3708 slot
= htab_find_slot (dp
->visited
, *tp
, INSERT
);
3714 /* Keep iterating. */
3718 /* Called from finish_function to implement the named return value
3719 optimization by overriding all the RETURN_EXPRs and pertinent
3720 CLEANUP_STMTs and replacing all occurrences of VAR with RESULT, the
3721 RESULT_DECL for the function. */
3724 finalize_nrv (tree
*tp
, tree var
, tree result
)
3726 struct nrv_data data
;
3728 /* Copy name from VAR to RESULT. */
3729 DECL_NAME (result
) = DECL_NAME (var
);
3730 /* Don't forget that we take its address. */
3731 TREE_ADDRESSABLE (result
) = TREE_ADDRESSABLE (var
);
3732 /* Finally set DECL_VALUE_EXPR to avoid assigning
3733 a stack slot at -O0 for the original var and debug info
3734 uses RESULT location for VAR. */
3735 SET_DECL_VALUE_EXPR (var
, result
);
3736 DECL_HAS_VALUE_EXPR_P (var
) = 1;
3739 data
.result
= result
;
3740 data
.visited
= htab_create (37, htab_hash_pointer
, htab_eq_pointer
, NULL
);
3741 cp_walk_tree (tp
, finalize_nrv_r
, &data
, 0);
3742 htab_delete (data
.visited
);
3745 /* Create CP_OMP_CLAUSE_INFO for clause C. Returns true if it is invalid. */
3748 cxx_omp_create_clause_info (tree c
, tree type
, bool need_default_ctor
,
3749 bool need_copy_ctor
, bool need_copy_assignment
)
3751 int save_errorcount
= errorcount
;
3754 /* Always allocate 3 elements for simplicity. These are the
3755 function decls for the ctor, dtor, and assignment op.
3756 This layout is known to the three lang hooks,
3757 cxx_omp_clause_default_init, cxx_omp_clause_copy_init,
3758 and cxx_omp_clause_assign_op. */
3759 info
= make_tree_vec (3);
3760 CP_OMP_CLAUSE_INFO (c
) = info
;
3762 if (need_default_ctor
|| need_copy_ctor
)
3764 if (need_default_ctor
)
3765 t
= get_default_ctor (type
);
3767 t
= get_copy_ctor (type
, tf_warning_or_error
);
3769 if (t
&& !trivial_fn_p (t
))
3770 TREE_VEC_ELT (info
, 0) = t
;
3773 if ((need_default_ctor
|| need_copy_ctor
)
3774 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
3775 TREE_VEC_ELT (info
, 1) = get_dtor (type
, tf_warning_or_error
);
3777 if (need_copy_assignment
)
3779 t
= get_copy_assign (type
);
3781 if (t
&& !trivial_fn_p (t
))
3782 TREE_VEC_ELT (info
, 2) = t
;
3785 return errorcount
!= save_errorcount
;
3788 /* For all elements of CLAUSES, validate them vs OpenMP constraints.
3789 Remove any elements from the list that are invalid. */
3792 finish_omp_clauses (tree clauses
)
3794 bitmap_head generic_head
, firstprivate_head
, lastprivate_head
;
3795 tree c
, t
, *pc
= &clauses
;
3798 bitmap_obstack_initialize (NULL
);
3799 bitmap_initialize (&generic_head
, &bitmap_default_obstack
);
3800 bitmap_initialize (&firstprivate_head
, &bitmap_default_obstack
);
3801 bitmap_initialize (&lastprivate_head
, &bitmap_default_obstack
);
3803 for (pc
= &clauses
, c
= clauses
; c
; c
= *pc
)
3805 bool remove
= false;
3807 switch (OMP_CLAUSE_CODE (c
))
3809 case OMP_CLAUSE_SHARED
:
3811 goto check_dup_generic
;
3812 case OMP_CLAUSE_PRIVATE
:
3814 goto check_dup_generic
;
3815 case OMP_CLAUSE_REDUCTION
:
3817 goto check_dup_generic
;
3818 case OMP_CLAUSE_COPYPRIVATE
:
3819 name
= "copyprivate";
3820 goto check_dup_generic
;
3821 case OMP_CLAUSE_COPYIN
:
3823 goto check_dup_generic
;
3825 t
= OMP_CLAUSE_DECL (c
);
3826 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
3828 if (processing_template_decl
)
3831 error ("%qD is not a variable in clause %qs", t
, name
);
3833 error ("%qE is not a variable in clause %qs", t
, name
);
3836 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
3837 || bitmap_bit_p (&firstprivate_head
, DECL_UID (t
))
3838 || bitmap_bit_p (&lastprivate_head
, DECL_UID (t
)))
3840 error ("%qD appears more than once in data clauses", t
);
3844 bitmap_set_bit (&generic_head
, DECL_UID (t
));
3847 case OMP_CLAUSE_FIRSTPRIVATE
:
3848 t
= OMP_CLAUSE_DECL (c
);
3849 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
3851 if (processing_template_decl
)
3854 error ("%qD is not a variable in clause %<firstprivate%>", t
);
3856 error ("%qE is not a variable in clause %<firstprivate%>", t
);
3859 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
3860 || bitmap_bit_p (&firstprivate_head
, DECL_UID (t
)))
3862 error ("%qD appears more than once in data clauses", t
);
3866 bitmap_set_bit (&firstprivate_head
, DECL_UID (t
));
3869 case OMP_CLAUSE_LASTPRIVATE
:
3870 t
= OMP_CLAUSE_DECL (c
);
3871 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
3873 if (processing_template_decl
)
3876 error ("%qD is not a variable in clause %<lastprivate%>", t
);
3878 error ("%qE is not a variable in clause %<lastprivate%>", t
);
3881 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
3882 || bitmap_bit_p (&lastprivate_head
, DECL_UID (t
)))
3884 error ("%qD appears more than once in data clauses", t
);
3888 bitmap_set_bit (&lastprivate_head
, DECL_UID (t
));
3892 t
= OMP_CLAUSE_IF_EXPR (c
);
3893 t
= maybe_convert_cond (t
);
3894 if (t
== error_mark_node
)
3896 OMP_CLAUSE_IF_EXPR (c
) = t
;
3899 case OMP_CLAUSE_NUM_THREADS
:
3900 t
= OMP_CLAUSE_NUM_THREADS_EXPR (c
);
3901 if (t
== error_mark_node
)
3903 else if (!type_dependent_expression_p (t
)
3904 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
3906 error ("num_threads expression must be integral");
3911 case OMP_CLAUSE_SCHEDULE
:
3912 t
= OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c
);
3915 else if (t
== error_mark_node
)
3917 else if (!type_dependent_expression_p (t
)
3918 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
3920 error ("schedule chunk size expression must be integral");
3925 case OMP_CLAUSE_NOWAIT
:
3926 case OMP_CLAUSE_ORDERED
:
3927 case OMP_CLAUSE_DEFAULT
:
3928 case OMP_CLAUSE_UNTIED
:
3929 case OMP_CLAUSE_COLLAPSE
:
3937 *pc
= OMP_CLAUSE_CHAIN (c
);
3939 pc
= &OMP_CLAUSE_CHAIN (c
);
3942 for (pc
= &clauses
, c
= clauses
; c
; c
= *pc
)
3944 enum omp_clause_code c_kind
= OMP_CLAUSE_CODE (c
);
3945 bool remove
= false;
3946 bool need_complete_non_reference
= false;
3947 bool need_default_ctor
= false;
3948 bool need_copy_ctor
= false;
3949 bool need_copy_assignment
= false;
3950 bool need_implicitly_determined
= false;
3951 tree type
, inner_type
;
3955 case OMP_CLAUSE_SHARED
:
3957 need_implicitly_determined
= true;
3959 case OMP_CLAUSE_PRIVATE
:
3961 need_complete_non_reference
= true;
3962 need_default_ctor
= true;
3963 need_implicitly_determined
= true;
3965 case OMP_CLAUSE_FIRSTPRIVATE
:
3966 name
= "firstprivate";
3967 need_complete_non_reference
= true;
3968 need_copy_ctor
= true;
3969 need_implicitly_determined
= true;
3971 case OMP_CLAUSE_LASTPRIVATE
:
3972 name
= "lastprivate";
3973 need_complete_non_reference
= true;
3974 need_copy_assignment
= true;
3975 need_implicitly_determined
= true;
3977 case OMP_CLAUSE_REDUCTION
:
3979 need_implicitly_determined
= true;
3981 case OMP_CLAUSE_COPYPRIVATE
:
3982 name
= "copyprivate";
3983 need_copy_assignment
= true;
3985 case OMP_CLAUSE_COPYIN
:
3987 need_copy_assignment
= true;
3990 pc
= &OMP_CLAUSE_CHAIN (c
);
3994 t
= OMP_CLAUSE_DECL (c
);
3995 if (processing_template_decl
3996 && TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
3998 pc
= &OMP_CLAUSE_CHAIN (c
);
4004 case OMP_CLAUSE_LASTPRIVATE
:
4005 if (!bitmap_bit_p (&firstprivate_head
, DECL_UID (t
)))
4006 need_default_ctor
= true;
4009 case OMP_CLAUSE_REDUCTION
:
4010 if (AGGREGATE_TYPE_P (TREE_TYPE (t
))
4011 || POINTER_TYPE_P (TREE_TYPE (t
)))
4013 error ("%qE has invalid type for %<reduction%>", t
);
4016 else if (FLOAT_TYPE_P (TREE_TYPE (t
)))
4018 enum tree_code r_code
= OMP_CLAUSE_REDUCTION_CODE (c
);
4026 error ("%qE has invalid type for %<reduction(%s)%>",
4027 t
, operator_name_info
[r_code
].name
);
4033 case OMP_CLAUSE_COPYIN
:
4034 if (TREE_CODE (t
) != VAR_DECL
|| !DECL_THREAD_LOCAL_P (t
))
4036 error ("%qE must be %<threadprivate%> for %<copyin%>", t
);
4045 if (need_complete_non_reference
|| need_copy_assignment
)
4047 t
= require_complete_type (t
);
4048 if (t
== error_mark_node
)
4050 else if (TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
4051 && need_complete_non_reference
)
4053 error ("%qE has reference type for %qs", t
, name
);
4057 if (need_implicitly_determined
)
4059 const char *share_name
= NULL
;
4061 if (TREE_CODE (t
) == VAR_DECL
&& DECL_THREAD_LOCAL_P (t
))
4062 share_name
= "threadprivate";
4063 else switch (cxx_omp_predetermined_sharing (t
))
4065 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
4067 case OMP_CLAUSE_DEFAULT_SHARED
:
4068 share_name
= "shared";
4070 case OMP_CLAUSE_DEFAULT_PRIVATE
:
4071 share_name
= "private";
4078 error ("%qE is predetermined %qs for %qs",
4079 t
, share_name
, name
);
4084 /* We're interested in the base element, not arrays. */
4085 inner_type
= type
= TREE_TYPE (t
);
4086 while (TREE_CODE (inner_type
) == ARRAY_TYPE
)
4087 inner_type
= TREE_TYPE (inner_type
);
4089 /* Check for special function availability by building a call to one.
4090 Save the results, because later we won't be in the right context
4091 for making these queries. */
4092 if (CLASS_TYPE_P (inner_type
)
4093 && COMPLETE_TYPE_P (inner_type
)
4094 && (need_default_ctor
|| need_copy_ctor
|| need_copy_assignment
)
4095 && !type_dependent_expression_p (t
)
4096 && cxx_omp_create_clause_info (c
, inner_type
, need_default_ctor
,
4097 need_copy_ctor
, need_copy_assignment
))
4101 *pc
= OMP_CLAUSE_CHAIN (c
);
4103 pc
= &OMP_CLAUSE_CHAIN (c
);
4106 bitmap_obstack_release (NULL
);
4110 /* For all variables in the tree_list VARS, mark them as thread local. */
4113 finish_omp_threadprivate (tree vars
)
4117 /* Mark every variable in VARS to be assigned thread local storage. */
4118 for (t
= vars
; t
; t
= TREE_CHAIN (t
))
4120 tree v
= TREE_PURPOSE (t
);
4122 if (error_operand_p (v
))
4124 else if (TREE_CODE (v
) != VAR_DECL
)
4125 error ("%<threadprivate%> %qD is not file, namespace "
4126 "or block scope variable", v
);
4127 /* If V had already been marked threadprivate, it doesn't matter
4128 whether it had been used prior to this point. */
4129 else if (TREE_USED (v
)
4130 && (DECL_LANG_SPECIFIC (v
) == NULL
4131 || !CP_DECL_THREADPRIVATE_P (v
)))
4132 error ("%qE declared %<threadprivate%> after first use", v
);
4133 else if (! TREE_STATIC (v
) && ! DECL_EXTERNAL (v
))
4134 error ("automatic variable %qE cannot be %<threadprivate%>", v
);
4135 else if (! COMPLETE_TYPE_P (TREE_TYPE (v
)))
4136 error ("%<threadprivate%> %qE has incomplete type", v
);
4137 else if (TREE_STATIC (v
) && TYPE_P (CP_DECL_CONTEXT (v
))
4138 && CP_DECL_CONTEXT (v
) != current_class_type
)
4139 error ("%<threadprivate%> %qE directive not "
4140 "in %qT definition", v
, CP_DECL_CONTEXT (v
));
4143 /* Allocate a LANG_SPECIFIC structure for V, if needed. */
4144 if (DECL_LANG_SPECIFIC (v
) == NULL
)
4146 retrofit_lang_decl (v
);
4148 /* Make sure that DECL_DISCRIMINATOR_P continues to be true
4149 after the allocation of the lang_decl structure. */
4150 if (DECL_DISCRIMINATOR_P (v
))
4151 DECL_LANG_SPECIFIC (v
)->u
.base
.u2sel
= 1;
4154 if (! DECL_THREAD_LOCAL_P (v
))
4156 DECL_TLS_MODEL (v
) = decl_default_tls_model (v
);
4157 /* If rtl has been already set for this var, call
4158 make_decl_rtl once again, so that encode_section_info
4159 has a chance to look at the new decl flags. */
4160 if (DECL_RTL_SET_P (v
))
4163 CP_DECL_THREADPRIVATE_P (v
) = 1;
4168 /* Build an OpenMP structured block. */
4171 begin_omp_structured_block (void)
4173 return do_pushlevel (sk_omp
);
4177 finish_omp_structured_block (tree block
)
4179 return do_poplevel (block
);
4182 /* Similarly, except force the retention of the BLOCK. */
4185 begin_omp_parallel (void)
4187 keep_next_level (true);
4188 return begin_omp_structured_block ();
4192 finish_omp_parallel (tree clauses
, tree body
)
4196 body
= finish_omp_structured_block (body
);
4198 stmt
= make_node (OMP_PARALLEL
);
4199 TREE_TYPE (stmt
) = void_type_node
;
4200 OMP_PARALLEL_CLAUSES (stmt
) = clauses
;
4201 OMP_PARALLEL_BODY (stmt
) = body
;
4203 return add_stmt (stmt
);
4207 begin_omp_task (void)
4209 keep_next_level (true);
4210 return begin_omp_structured_block ();
4214 finish_omp_task (tree clauses
, tree body
)
4218 body
= finish_omp_structured_block (body
);
4220 stmt
= make_node (OMP_TASK
);
4221 TREE_TYPE (stmt
) = void_type_node
;
4222 OMP_TASK_CLAUSES (stmt
) = clauses
;
4223 OMP_TASK_BODY (stmt
) = body
;
4225 return add_stmt (stmt
);
4228 /* Helper function for finish_omp_for. Convert Ith random access iterator
4229 into integral iterator. Return FALSE if successful. */
4232 handle_omp_for_class_iterator (int i
, location_t locus
, tree declv
, tree initv
,
4233 tree condv
, tree incrv
, tree
*body
,
4234 tree
*pre_body
, tree clauses
)
4236 tree diff
, iter_init
, iter_incr
= NULL
, last
;
4237 tree incr_var
= NULL
, orig_pre_body
, orig_body
, c
;
4238 tree decl
= TREE_VEC_ELT (declv
, i
);
4239 tree init
= TREE_VEC_ELT (initv
, i
);
4240 tree cond
= TREE_VEC_ELT (condv
, i
);
4241 tree incr
= TREE_VEC_ELT (incrv
, i
);
4243 location_t elocus
= locus
;
4245 if (init
&& EXPR_HAS_LOCATION (init
))
4246 elocus
= EXPR_LOCATION (init
);
4248 switch (TREE_CODE (cond
))
4254 if (TREE_OPERAND (cond
, 1) == iter
)
4255 cond
= build2 (swap_tree_comparison (TREE_CODE (cond
)),
4256 TREE_TYPE (cond
), iter
, TREE_OPERAND (cond
, 0));
4257 if (TREE_OPERAND (cond
, 0) != iter
)
4258 cond
= error_mark_node
;
4261 tree tem
= build_x_binary_op (TREE_CODE (cond
), iter
, ERROR_MARK
,
4262 TREE_OPERAND (cond
, 1), ERROR_MARK
,
4263 NULL
, tf_warning_or_error
);
4264 if (error_operand_p (tem
))
4269 cond
= error_mark_node
;
4272 if (cond
== error_mark_node
)
4274 error_at (elocus
, "invalid controlling predicate");
4277 diff
= build_x_binary_op (MINUS_EXPR
, TREE_OPERAND (cond
, 1),
4278 ERROR_MARK
, iter
, ERROR_MARK
, NULL
,
4279 tf_warning_or_error
);
4280 if (error_operand_p (diff
))
4282 if (TREE_CODE (TREE_TYPE (diff
)) != INTEGER_TYPE
)
4284 error_at (elocus
, "difference between %qE and %qD does not have integer type",
4285 TREE_OPERAND (cond
, 1), iter
);
4289 switch (TREE_CODE (incr
))
4291 case PREINCREMENT_EXPR
:
4292 case PREDECREMENT_EXPR
:
4293 case POSTINCREMENT_EXPR
:
4294 case POSTDECREMENT_EXPR
:
4295 if (TREE_OPERAND (incr
, 0) != iter
)
4297 incr
= error_mark_node
;
4300 iter_incr
= build_x_unary_op (TREE_CODE (incr
), iter
,
4301 tf_warning_or_error
);
4302 if (error_operand_p (iter_incr
))
4304 else if (TREE_CODE (incr
) == PREINCREMENT_EXPR
4305 || TREE_CODE (incr
) == POSTINCREMENT_EXPR
)
4306 incr
= integer_one_node
;
4308 incr
= integer_minus_one_node
;
4311 if (TREE_OPERAND (incr
, 0) != iter
)
4312 incr
= error_mark_node
;
4313 else if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
4314 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
4316 tree rhs
= TREE_OPERAND (incr
, 1);
4317 if (TREE_OPERAND (rhs
, 0) == iter
)
4319 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs
, 1)))
4321 incr
= error_mark_node
;
4324 iter_incr
= build_x_modify_expr (iter
, TREE_CODE (rhs
),
4325 TREE_OPERAND (rhs
, 1),
4326 tf_warning_or_error
);
4327 if (error_operand_p (iter_incr
))
4329 incr
= TREE_OPERAND (rhs
, 1);
4330 incr
= cp_convert (TREE_TYPE (diff
), incr
);
4331 if (TREE_CODE (rhs
) == MINUS_EXPR
)
4333 incr
= build1 (NEGATE_EXPR
, TREE_TYPE (diff
), incr
);
4334 incr
= fold_if_not_in_template (incr
);
4336 if (TREE_CODE (incr
) != INTEGER_CST
4337 && (TREE_CODE (incr
) != NOP_EXPR
4338 || (TREE_CODE (TREE_OPERAND (incr
, 0))
4343 else if (TREE_OPERAND (rhs
, 1) == iter
)
4345 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs
, 0))) != INTEGER_TYPE
4346 || TREE_CODE (rhs
) != PLUS_EXPR
)
4347 incr
= error_mark_node
;
4350 iter_incr
= build_x_binary_op (PLUS_EXPR
,
4351 TREE_OPERAND (rhs
, 0),
4354 tf_warning_or_error
);
4355 if (error_operand_p (iter_incr
))
4357 iter_incr
= build_x_modify_expr (iter
, NOP_EXPR
,
4359 tf_warning_or_error
);
4360 if (error_operand_p (iter_incr
))
4362 incr
= TREE_OPERAND (rhs
, 0);
4367 incr
= error_mark_node
;
4370 incr
= error_mark_node
;
4373 incr
= error_mark_node
;
4377 if (incr
== error_mark_node
)
4379 error_at (elocus
, "invalid increment expression");
4383 incr
= cp_convert (TREE_TYPE (diff
), incr
);
4384 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
4385 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
4386 && OMP_CLAUSE_DECL (c
) == iter
)
4389 decl
= create_temporary_var (TREE_TYPE (diff
));
4391 add_decl_expr (decl
);
4392 last
= create_temporary_var (TREE_TYPE (diff
));
4394 add_decl_expr (last
);
4395 if (c
&& iter_incr
== NULL
)
4397 incr_var
= create_temporary_var (TREE_TYPE (diff
));
4398 pushdecl (incr_var
);
4399 add_decl_expr (incr_var
);
4401 gcc_assert (stmts_are_full_exprs_p ());
4403 orig_pre_body
= *pre_body
;
4404 *pre_body
= push_stmt_list ();
4406 add_stmt (orig_pre_body
);
4408 finish_expr_stmt (build_x_modify_expr (iter
, NOP_EXPR
, init
,
4409 tf_warning_or_error
));
4410 init
= build_int_cst (TREE_TYPE (diff
), 0);
4411 if (c
&& iter_incr
== NULL
)
4413 finish_expr_stmt (build_x_modify_expr (incr_var
, NOP_EXPR
,
4414 incr
, tf_warning_or_error
));
4416 iter_incr
= build_x_modify_expr (iter
, PLUS_EXPR
, incr
,
4417 tf_warning_or_error
);
4419 finish_expr_stmt (build_x_modify_expr (last
, NOP_EXPR
, init
,
4420 tf_warning_or_error
));
4421 *pre_body
= pop_stmt_list (*pre_body
);
4423 cond
= cp_build_binary_op (elocus
,
4424 TREE_CODE (cond
), decl
, diff
,
4425 tf_warning_or_error
);
4426 incr
= build_modify_expr (elocus
, decl
, NULL_TREE
, PLUS_EXPR
,
4427 elocus
, incr
, NULL_TREE
);
4430 *body
= push_stmt_list ();
4431 iter_init
= build2 (MINUS_EXPR
, TREE_TYPE (diff
), decl
, last
);
4432 iter_init
= build_x_modify_expr (iter
, PLUS_EXPR
, iter_init
,
4433 tf_warning_or_error
);
4434 iter_init
= build1 (NOP_EXPR
, void_type_node
, iter_init
);
4435 finish_expr_stmt (iter_init
);
4436 finish_expr_stmt (build_x_modify_expr (last
, NOP_EXPR
, decl
,
4437 tf_warning_or_error
));
4438 add_stmt (orig_body
);
4439 *body
= pop_stmt_list (*body
);
4443 OMP_CLAUSE_LASTPRIVATE_STMT (c
) = push_stmt_list ();
4444 finish_expr_stmt (iter_incr
);
4445 OMP_CLAUSE_LASTPRIVATE_STMT (c
)
4446 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (c
));
4449 TREE_VEC_ELT (declv
, i
) = decl
;
4450 TREE_VEC_ELT (initv
, i
) = init
;
4451 TREE_VEC_ELT (condv
, i
) = cond
;
4452 TREE_VEC_ELT (incrv
, i
) = incr
;
4457 /* Build and validate an OMP_FOR statement. CLAUSES, BODY, COND, INCR
4458 are directly for their associated operands in the statement. DECL
4459 and INIT are a combo; if DECL is NULL then INIT ought to be a
4460 MODIFY_EXPR, and the DECL should be extracted. PRE_BODY are
4461 optional statements that need to go before the loop into its
4465 finish_omp_for (location_t locus
, tree declv
, tree initv
, tree condv
,
4466 tree incrv
, tree body
, tree pre_body
, tree clauses
)
4468 tree omp_for
= NULL
, orig_incr
= NULL
;
4469 tree decl
, init
, cond
, incr
;
4473 gcc_assert (TREE_VEC_LENGTH (declv
) == TREE_VEC_LENGTH (initv
));
4474 gcc_assert (TREE_VEC_LENGTH (declv
) == TREE_VEC_LENGTH (condv
));
4475 gcc_assert (TREE_VEC_LENGTH (declv
) == TREE_VEC_LENGTH (incrv
));
4476 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
4478 decl
= TREE_VEC_ELT (declv
, i
);
4479 init
= TREE_VEC_ELT (initv
, i
);
4480 cond
= TREE_VEC_ELT (condv
, i
);
4481 incr
= TREE_VEC_ELT (incrv
, i
);
4487 switch (TREE_CODE (init
))
4490 decl
= TREE_OPERAND (init
, 0);
4491 init
= TREE_OPERAND (init
, 1);
4494 if (TREE_CODE (TREE_OPERAND (init
, 1)) == NOP_EXPR
)
4496 decl
= TREE_OPERAND (init
, 0);
4497 init
= TREE_OPERAND (init
, 2);
4507 "expected iteration declaration or initialization");
4512 if (init
&& EXPR_HAS_LOCATION (init
))
4513 elocus
= EXPR_LOCATION (init
);
4517 error_at (elocus
, "missing controlling predicate");
4523 error_at (elocus
, "missing increment expression");
4527 TREE_VEC_ELT (declv
, i
) = decl
;
4528 TREE_VEC_ELT (initv
, i
) = init
;
4531 if (dependent_omp_for_p (declv
, initv
, condv
, incrv
))
4535 stmt
= make_node (OMP_FOR
);
4537 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
4539 /* This is really just a place-holder. We'll be decomposing this
4540 again and going through the cp_build_modify_expr path below when
4541 we instantiate the thing. */
4542 TREE_VEC_ELT (initv
, i
)
4543 = build2 (MODIFY_EXPR
, void_type_node
, TREE_VEC_ELT (declv
, i
),
4544 TREE_VEC_ELT (initv
, i
));
4547 TREE_TYPE (stmt
) = void_type_node
;
4548 OMP_FOR_INIT (stmt
) = initv
;
4549 OMP_FOR_COND (stmt
) = condv
;
4550 OMP_FOR_INCR (stmt
) = incrv
;
4551 OMP_FOR_BODY (stmt
) = body
;
4552 OMP_FOR_PRE_BODY (stmt
) = pre_body
;
4553 OMP_FOR_CLAUSES (stmt
) = clauses
;
4555 SET_EXPR_LOCATION (stmt
, locus
);
4556 return add_stmt (stmt
);
4559 if (processing_template_decl
)
4560 orig_incr
= make_tree_vec (TREE_VEC_LENGTH (incrv
));
4562 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); )
4564 decl
= TREE_VEC_ELT (declv
, i
);
4565 init
= TREE_VEC_ELT (initv
, i
);
4566 cond
= TREE_VEC_ELT (condv
, i
);
4567 incr
= TREE_VEC_ELT (incrv
, i
);
4569 TREE_VEC_ELT (orig_incr
, i
) = incr
;
4572 if (init
&& EXPR_HAS_LOCATION (init
))
4573 elocus
= EXPR_LOCATION (init
);
4577 error_at (elocus
, "expected iteration declaration or initialization");
4581 if (incr
&& TREE_CODE (incr
) == MODOP_EXPR
)
4584 TREE_VEC_ELT (orig_incr
, i
) = incr
;
4585 incr
= cp_build_modify_expr (TREE_OPERAND (incr
, 0),
4586 TREE_CODE (TREE_OPERAND (incr
, 1)),
4587 TREE_OPERAND (incr
, 2),
4588 tf_warning_or_error
);
4591 if (CLASS_TYPE_P (TREE_TYPE (decl
)))
4593 if (handle_omp_for_class_iterator (i
, locus
, declv
, initv
, condv
,
4594 incrv
, &body
, &pre_body
, clauses
))
4599 if (!INTEGRAL_TYPE_P (TREE_TYPE (decl
))
4600 && TREE_CODE (TREE_TYPE (decl
)) != POINTER_TYPE
)
4602 error_at (elocus
, "invalid type for iteration variable %qE", decl
);
4606 if (!processing_template_decl
)
4608 init
= fold_build_cleanup_point_expr (TREE_TYPE (init
), init
);
4609 init
= cp_build_modify_expr (decl
, NOP_EXPR
, init
, tf_warning_or_error
);
4612 init
= build2 (MODIFY_EXPR
, void_type_node
, decl
, init
);
4614 && TREE_SIDE_EFFECTS (cond
)
4615 && COMPARISON_CLASS_P (cond
)
4616 && !processing_template_decl
)
4618 tree t
= TREE_OPERAND (cond
, 0);
4619 if (TREE_SIDE_EFFECTS (t
)
4621 && (TREE_CODE (t
) != NOP_EXPR
4622 || TREE_OPERAND (t
, 0) != decl
))
4623 TREE_OPERAND (cond
, 0)
4624 = fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4626 t
= TREE_OPERAND (cond
, 1);
4627 if (TREE_SIDE_EFFECTS (t
)
4629 && (TREE_CODE (t
) != NOP_EXPR
4630 || TREE_OPERAND (t
, 0) != decl
))
4631 TREE_OPERAND (cond
, 1)
4632 = fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4634 if (decl
== error_mark_node
|| init
== error_mark_node
)
4637 TREE_VEC_ELT (declv
, i
) = decl
;
4638 TREE_VEC_ELT (initv
, i
) = init
;
4639 TREE_VEC_ELT (condv
, i
) = cond
;
4640 TREE_VEC_ELT (incrv
, i
) = incr
;
4644 if (IS_EMPTY_STMT (pre_body
))
4647 omp_for
= c_finish_omp_for (locus
, declv
, initv
, condv
, incrv
,
4650 if (omp_for
== NULL
)
4653 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INCR (omp_for
)); i
++)
4655 decl
= TREE_OPERAND (TREE_VEC_ELT (OMP_FOR_INIT (omp_for
), i
), 0);
4656 incr
= TREE_VEC_ELT (OMP_FOR_INCR (omp_for
), i
);
4658 if (TREE_CODE (incr
) != MODIFY_EXPR
)
4661 if (TREE_SIDE_EFFECTS (TREE_OPERAND (incr
, 1))
4662 && BINARY_CLASS_P (TREE_OPERAND (incr
, 1))
4663 && !processing_template_decl
)
4665 tree t
= TREE_OPERAND (TREE_OPERAND (incr
, 1), 0);
4666 if (TREE_SIDE_EFFECTS (t
)
4668 && (TREE_CODE (t
) != NOP_EXPR
4669 || TREE_OPERAND (t
, 0) != decl
))
4670 TREE_OPERAND (TREE_OPERAND (incr
, 1), 0)
4671 = fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4673 t
= TREE_OPERAND (TREE_OPERAND (incr
, 1), 1);
4674 if (TREE_SIDE_EFFECTS (t
)
4676 && (TREE_CODE (t
) != NOP_EXPR
4677 || TREE_OPERAND (t
, 0) != decl
))
4678 TREE_OPERAND (TREE_OPERAND (incr
, 1), 1)
4679 = fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4683 TREE_VEC_ELT (OMP_FOR_INCR (omp_for
), i
) = TREE_VEC_ELT (orig_incr
, i
);
4685 if (omp_for
!= NULL
)
4686 OMP_FOR_CLAUSES (omp_for
) = clauses
;
4691 finish_omp_atomic (enum tree_code code
, tree lhs
, tree rhs
)
4700 dependent_p
= false;
4703 /* Even in a template, we can detect invalid uses of the atomic
4704 pragma if neither LHS nor RHS is type-dependent. */
4705 if (processing_template_decl
)
4707 dependent_p
= (type_dependent_expression_p (lhs
)
4708 || type_dependent_expression_p (rhs
));
4711 lhs
= build_non_dependent_expr (lhs
);
4712 rhs
= build_non_dependent_expr (rhs
);
4717 stmt
= c_finish_omp_atomic (input_location
, code
, lhs
, rhs
);
4718 if (stmt
== error_mark_node
)
4721 if (processing_template_decl
)
4722 stmt
= build2 (OMP_ATOMIC
, void_type_node
, integer_zero_node
,
4723 build2 (code
, void_type_node
, orig_lhs
, orig_rhs
));
4728 finish_omp_barrier (void)
4730 tree fn
= built_in_decls
[BUILT_IN_GOMP_BARRIER
];
4731 VEC(tree
,gc
) *vec
= make_tree_vector ();
4732 tree stmt
= finish_call_expr (fn
, &vec
, false, false, tf_warning_or_error
);
4733 release_tree_vector (vec
);
4734 finish_expr_stmt (stmt
);
4738 finish_omp_flush (void)
4740 tree fn
= built_in_decls
[BUILT_IN_SYNCHRONIZE
];
4741 VEC(tree
,gc
) *vec
= make_tree_vector ();
4742 tree stmt
= finish_call_expr (fn
, &vec
, false, false, tf_warning_or_error
);
4743 release_tree_vector (vec
);
4744 finish_expr_stmt (stmt
);
4748 finish_omp_taskwait (void)
4750 tree fn
= built_in_decls
[BUILT_IN_GOMP_TASKWAIT
];
4751 VEC(tree
,gc
) *vec
= make_tree_vector ();
4752 tree stmt
= finish_call_expr (fn
, &vec
, false, false, tf_warning_or_error
);
4753 release_tree_vector (vec
);
4754 finish_expr_stmt (stmt
);
4758 init_cp_semantics (void)
4762 /* Build a STATIC_ASSERT for a static assertion with the condition
4763 CONDITION and the message text MESSAGE. LOCATION is the location
4764 of the static assertion in the source code. When MEMBER_P, this
4765 static assertion is a member of a class. */
4767 finish_static_assert (tree condition
, tree message
, location_t location
,
4770 if (check_for_bare_parameter_packs (condition
))
4771 condition
= error_mark_node
;
4773 if (type_dependent_expression_p (condition
)
4774 || value_dependent_expression_p (condition
))
4776 /* We're in a template; build a STATIC_ASSERT and put it in
4780 assertion
= make_node (STATIC_ASSERT
);
4781 STATIC_ASSERT_CONDITION (assertion
) = condition
;
4782 STATIC_ASSERT_MESSAGE (assertion
) = message
;
4783 STATIC_ASSERT_SOURCE_LOCATION (assertion
) = location
;
4786 maybe_add_class_template_decl_list (current_class_type
,
4790 add_stmt (assertion
);
4795 /* Fold the expression and convert it to a boolean value. */
4796 condition
= fold_non_dependent_expr (condition
);
4797 condition
= cp_convert (boolean_type_node
, condition
);
4798 condition
= maybe_constant_value (condition
);
4800 if (TREE_CODE (condition
) == INTEGER_CST
&& !integer_zerop (condition
))
4801 /* Do nothing; the condition is satisfied. */
4805 location_t saved_loc
= input_location
;
4807 input_location
= location
;
4808 if (TREE_CODE (condition
) == INTEGER_CST
4809 && integer_zerop (condition
))
4810 /* Report the error. */
4811 error ("static assertion failed: %E", message
);
4812 else if (condition
&& condition
!= error_mark_node
)
4814 error ("non-constant condition for static assertion");
4815 cxx_constant_value (condition
);
4817 input_location
= saved_loc
;
4821 /* Returns the type of EXPR for cases where we can determine it even though
4822 EXPR is a type-dependent expression. */
4825 describable_type (tree expr
)
4827 tree type
= NULL_TREE
;
4829 if (! type_dependent_expression_p (expr
)
4830 && ! type_unknown_p (expr
))
4832 type
= unlowered_expr_type (expr
);
4833 if (real_lvalue_p (expr
))
4834 type
= build_reference_type (type
);
4840 switch (TREE_CODE (expr
))
4846 return TREE_TYPE (expr
);
4851 case TEMPLATE_PARM_INDEX
:
4853 case STATIC_CAST_EXPR
:
4854 case REINTERPRET_CAST_EXPR
:
4855 case CONST_CAST_EXPR
:
4856 case DYNAMIC_CAST_EXPR
:
4857 type
= TREE_TYPE (expr
);
4862 tree ptrtype
= describable_type (TREE_OPERAND (expr
, 0));
4863 if (ptrtype
&& POINTER_TYPE_P (ptrtype
))
4864 type
= build_reference_type (TREE_TYPE (ptrtype
));
4869 if (TREE_CODE_CLASS (TREE_CODE (expr
)) == tcc_constant
)
4870 type
= TREE_TYPE (expr
);
4874 if (type
&& type_uses_auto (type
))
4880 /* Implements the C++0x decltype keyword. Returns the type of EXPR,
4881 suitable for use as a type-specifier.
4883 ID_EXPRESSION_OR_MEMBER_ACCESS_P is true when EXPR was parsed as an
4884 id-expression or a class member access, FALSE when it was parsed as
4885 a full expression. */
4888 finish_decltype_type (tree expr
, bool id_expression_or_member_access_p
,
4889 tsubst_flags_t complain
)
4891 tree type
= NULL_TREE
;
4893 if (!expr
|| error_operand_p (expr
))
4894 return error_mark_node
;
4897 || TREE_CODE (expr
) == TYPE_DECL
4898 || (TREE_CODE (expr
) == BIT_NOT_EXPR
4899 && TYPE_P (TREE_OPERAND (expr
, 0))))
4901 if (complain
& tf_error
)
4902 error ("argument to decltype must be an expression");
4903 return error_mark_node
;
4906 /* FIXME instantiation-dependent */
4907 if (type_dependent_expression_p (expr
)
4908 /* In a template, a COMPONENT_REF has an IDENTIFIER_NODE for op1 even
4909 if it isn't dependent, so that we can check access control at
4910 instantiation time, so defer the decltype as well (PR 42277). */
4911 || (id_expression_or_member_access_p
4912 && processing_template_decl
4913 && TREE_CODE (expr
) == COMPONENT_REF
))
4915 type
= cxx_make_type (DECLTYPE_TYPE
);
4916 DECLTYPE_TYPE_EXPR (type
) = expr
;
4917 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type
)
4918 = id_expression_or_member_access_p
;
4919 SET_TYPE_STRUCTURAL_EQUALITY (type
);
4924 /* The type denoted by decltype(e) is defined as follows: */
4926 expr
= resolve_nondeduced_context (expr
);
4928 if (type_unknown_p (expr
))
4930 if (complain
& tf_error
)
4931 error ("decltype cannot resolve address of overloaded function");
4932 return error_mark_node
;
4935 /* To get the size of a static data member declared as an array of
4936 unknown bound, we need to instantiate it. */
4937 if (TREE_CODE (expr
) == VAR_DECL
4938 && VAR_HAD_UNKNOWN_BOUND (expr
)
4939 && DECL_TEMPLATE_INSTANTIATION (expr
))
4940 instantiate_decl (expr
, /*defer_ok*/true, /*expl_inst_mem*/false);
4942 if (id_expression_or_member_access_p
)
4944 /* If e is an id-expression or a class member access (5.2.5
4945 [expr.ref]), decltype(e) is defined as the type of the entity
4946 named by e. If there is no such entity, or e names a set of
4947 overloaded functions, the program is ill-formed. */
4948 if (TREE_CODE (expr
) == IDENTIFIER_NODE
)
4949 expr
= lookup_name (expr
);
4951 if (TREE_CODE (expr
) == INDIRECT_REF
)
4952 /* This can happen when the expression is, e.g., "a.b". Just
4953 look at the underlying operand. */
4954 expr
= TREE_OPERAND (expr
, 0);
4956 if (TREE_CODE (expr
) == OFFSET_REF
4957 || TREE_CODE (expr
) == MEMBER_REF
)
4958 /* We're only interested in the field itself. If it is a
4959 BASELINK, we will need to see through it in the next
4961 expr
= TREE_OPERAND (expr
, 1);
4963 if (TREE_CODE (expr
) == BASELINK
)
4964 /* See through BASELINK nodes to the underlying function. */
4965 expr
= BASELINK_FUNCTIONS (expr
);
4967 switch (TREE_CODE (expr
))
4970 if (DECL_BIT_FIELD_TYPE (expr
))
4972 type
= DECL_BIT_FIELD_TYPE (expr
);
4975 /* Fall through for fields that aren't bitfields. */
4982 case TEMPLATE_PARM_INDEX
:
4983 expr
= mark_type_use (expr
);
4984 type
= TREE_TYPE (expr
);
4988 type
= error_mark_node
;
4992 mark_type_use (expr
);
4993 type
= is_bitfield_expr_with_lowered_type (expr
);
4995 type
= TREE_TYPE (TREE_OPERAND (expr
, 1));
5002 /* We can get here when the id-expression refers to an
5004 type
= TREE_TYPE (expr
);
5009 return error_mark_node
;
5014 /* Within a lambda-expression:
5016 Every occurrence of decltype((x)) where x is a possibly
5017 parenthesized id-expression that names an entity of
5018 automatic storage duration is treated as if x were
5019 transformed into an access to a corresponding data member
5020 of the closure type that would have been declared if x
5021 were a use of the denoted entity. */
5022 if (outer_automatic_var_p (expr
)
5023 && current_function_decl
5024 && LAMBDA_FUNCTION_P (current_function_decl
))
5025 type
= capture_decltype (expr
);
5026 else if (error_operand_p (expr
))
5027 type
= error_mark_node
;
5028 else if (expr
== current_class_ptr
)
5029 /* If the expression is just "this", we want the
5030 cv-unqualified pointer for the "this" type. */
5031 type
= TYPE_MAIN_VARIANT (TREE_TYPE (expr
));
5034 /* Otherwise, where T is the type of e, if e is an lvalue,
5035 decltype(e) is defined as T&; if an xvalue, T&&; otherwise, T. */
5036 cp_lvalue_kind clk
= lvalue_kind (expr
);
5037 type
= unlowered_expr_type (expr
);
5038 gcc_assert (TREE_CODE (type
) != REFERENCE_TYPE
);
5039 if (clk
!= clk_none
&& !(clk
& clk_class
))
5040 type
= cp_build_reference_type (type
, (clk
& clk_rvalueref
));
5047 /* Called from trait_expr_value to evaluate either __has_nothrow_assign or
5048 __has_nothrow_copy, depending on assign_p. */
5051 classtype_has_nothrow_assign_or_copy_p (tree type
, bool assign_p
)
5058 ix
= lookup_fnfields_1 (type
, ansi_assopname (NOP_EXPR
));
5061 fns
= VEC_index (tree
, CLASSTYPE_METHOD_VEC (type
), ix
);
5063 else if (TYPE_HAS_COPY_CTOR (type
))
5065 /* If construction of the copy constructor was postponed, create
5067 if (CLASSTYPE_LAZY_COPY_CTOR (type
))
5068 lazily_declare_fn (sfk_copy_constructor
, type
);
5069 if (CLASSTYPE_LAZY_MOVE_CTOR (type
))
5070 lazily_declare_fn (sfk_move_constructor
, type
);
5071 fns
= CLASSTYPE_CONSTRUCTORS (type
);
5076 for (; fns
; fns
= OVL_NEXT (fns
))
5078 tree fn
= OVL_CURRENT (fns
);
5082 if (copy_fn_p (fn
) == 0)
5085 else if (copy_fn_p (fn
) <= 0)
5088 if (!TYPE_NOTHROW_P (TREE_TYPE (fn
)))
5095 /* Actually evaluates the trait. */
5098 trait_expr_value (cp_trait_kind kind
, tree type1
, tree type2
)
5100 enum tree_code type_code1
;
5103 type_code1
= TREE_CODE (type1
);
5107 case CPTK_HAS_NOTHROW_ASSIGN
:
5108 type1
= strip_array_types (type1
);
5109 return (!CP_TYPE_CONST_P (type1
) && type_code1
!= REFERENCE_TYPE
5110 && (trait_expr_value (CPTK_HAS_TRIVIAL_ASSIGN
, type1
, type2
)
5111 || (CLASS_TYPE_P (type1
)
5112 && classtype_has_nothrow_assign_or_copy_p (type1
,
5115 case CPTK_HAS_TRIVIAL_ASSIGN
:
5116 /* ??? The standard seems to be missing the "or array of such a class
5117 type" wording for this trait. */
5118 type1
= strip_array_types (type1
);
5119 return (!CP_TYPE_CONST_P (type1
) && type_code1
!= REFERENCE_TYPE
5120 && (trivial_type_p (type1
)
5121 || (CLASS_TYPE_P (type1
)
5122 && TYPE_HAS_TRIVIAL_COPY_ASSIGN (type1
))));
5124 case CPTK_HAS_NOTHROW_CONSTRUCTOR
:
5125 type1
= strip_array_types (type1
);
5126 return (trait_expr_value (CPTK_HAS_TRIVIAL_CONSTRUCTOR
, type1
, type2
)
5127 || (CLASS_TYPE_P (type1
)
5128 && (t
= locate_ctor (type1
))
5129 && TYPE_NOTHROW_P (TREE_TYPE (t
))));
5131 case CPTK_HAS_TRIVIAL_CONSTRUCTOR
:
5132 type1
= strip_array_types (type1
);
5133 return (trivial_type_p (type1
)
5134 || (CLASS_TYPE_P (type1
) && TYPE_HAS_TRIVIAL_DFLT (type1
)));
5136 case CPTK_HAS_NOTHROW_COPY
:
5137 type1
= strip_array_types (type1
);
5138 return (trait_expr_value (CPTK_HAS_TRIVIAL_COPY
, type1
, type2
)
5139 || (CLASS_TYPE_P (type1
)
5140 && classtype_has_nothrow_assign_or_copy_p (type1
, false)));
5142 case CPTK_HAS_TRIVIAL_COPY
:
5143 /* ??? The standard seems to be missing the "or array of such a class
5144 type" wording for this trait. */
5145 type1
= strip_array_types (type1
);
5146 return (trivial_type_p (type1
) || type_code1
== REFERENCE_TYPE
5147 || (CLASS_TYPE_P (type1
) && TYPE_HAS_TRIVIAL_COPY_CTOR (type1
)));
5149 case CPTK_HAS_TRIVIAL_DESTRUCTOR
:
5150 type1
= strip_array_types (type1
);
5151 return (trivial_type_p (type1
) || type_code1
== REFERENCE_TYPE
5152 || (CLASS_TYPE_P (type1
)
5153 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type1
)));
5155 case CPTK_HAS_VIRTUAL_DESTRUCTOR
:
5156 return type_has_virtual_destructor (type1
);
5158 case CPTK_IS_ABSTRACT
:
5159 return (CLASS_TYPE_P (type1
) && CLASSTYPE_PURE_VIRTUALS (type1
));
5161 case CPTK_IS_BASE_OF
:
5162 return (NON_UNION_CLASS_TYPE_P (type1
) && NON_UNION_CLASS_TYPE_P (type2
)
5163 && DERIVED_FROM_P (type1
, type2
));
5166 return (NON_UNION_CLASS_TYPE_P (type1
));
5168 case CPTK_IS_CONVERTIBLE_TO
:
5173 return (NON_UNION_CLASS_TYPE_P (type1
) && CLASSTYPE_EMPTY_P (type1
));
5176 return (type_code1
== ENUMERAL_TYPE
);
5178 case CPTK_IS_LITERAL_TYPE
:
5179 return (literal_type_p (type1
));
5182 return (pod_type_p (type1
));
5184 case CPTK_IS_POLYMORPHIC
:
5185 return (CLASS_TYPE_P (type1
) && TYPE_POLYMORPHIC_P (type1
));
5187 case CPTK_IS_STD_LAYOUT
:
5188 return (std_layout_type_p (type1
));
5190 case CPTK_IS_TRIVIAL
:
5191 return (trivial_type_p (type1
));
5194 return (type_code1
== UNION_TYPE
);
5202 /* Returns true if TYPE is a complete type, an array of unknown bound,
5203 or (possibly cv-qualified) void, returns false otherwise. */
5206 check_trait_type (tree type
)
5208 if (COMPLETE_TYPE_P (type
))
5211 if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
)
5212 && COMPLETE_TYPE_P (TREE_TYPE (type
)))
5215 if (VOID_TYPE_P (type
))
5221 /* Process a trait expression. */
5224 finish_trait_expr (cp_trait_kind kind
, tree type1
, tree type2
)
5226 gcc_assert (kind
== CPTK_HAS_NOTHROW_ASSIGN
5227 || kind
== CPTK_HAS_NOTHROW_CONSTRUCTOR
5228 || kind
== CPTK_HAS_NOTHROW_COPY
5229 || kind
== CPTK_HAS_TRIVIAL_ASSIGN
5230 || kind
== CPTK_HAS_TRIVIAL_CONSTRUCTOR
5231 || kind
== CPTK_HAS_TRIVIAL_COPY
5232 || kind
== CPTK_HAS_TRIVIAL_DESTRUCTOR
5233 || kind
== CPTK_HAS_VIRTUAL_DESTRUCTOR
5234 || kind
== CPTK_IS_ABSTRACT
5235 || kind
== CPTK_IS_BASE_OF
5236 || kind
== CPTK_IS_CLASS
5237 || kind
== CPTK_IS_CONVERTIBLE_TO
5238 || kind
== CPTK_IS_EMPTY
5239 || kind
== CPTK_IS_ENUM
5240 || kind
== CPTK_IS_LITERAL_TYPE
5241 || kind
== CPTK_IS_POD
5242 || kind
== CPTK_IS_POLYMORPHIC
5243 || kind
== CPTK_IS_STD_LAYOUT
5244 || kind
== CPTK_IS_TRIVIAL
5245 || kind
== CPTK_IS_UNION
);
5247 if (kind
== CPTK_IS_CONVERTIBLE_TO
)
5249 sorry ("__is_convertible_to");
5250 return error_mark_node
;
5253 if (type1
== error_mark_node
5254 || ((kind
== CPTK_IS_BASE_OF
|| kind
== CPTK_IS_CONVERTIBLE_TO
)
5255 && type2
== error_mark_node
))
5256 return error_mark_node
;
5258 if (processing_template_decl
)
5260 tree trait_expr
= make_node (TRAIT_EXPR
);
5261 TREE_TYPE (trait_expr
) = boolean_type_node
;
5262 TRAIT_EXPR_TYPE1 (trait_expr
) = type1
;
5263 TRAIT_EXPR_TYPE2 (trait_expr
) = type2
;
5264 TRAIT_EXPR_KIND (trait_expr
) = kind
;
5268 complete_type (type1
);
5270 complete_type (type2
);
5274 case CPTK_HAS_NOTHROW_ASSIGN
:
5275 case CPTK_HAS_TRIVIAL_ASSIGN
:
5276 case CPTK_HAS_NOTHROW_CONSTRUCTOR
:
5277 case CPTK_HAS_TRIVIAL_CONSTRUCTOR
:
5278 case CPTK_HAS_NOTHROW_COPY
:
5279 case CPTK_HAS_TRIVIAL_COPY
:
5280 case CPTK_HAS_TRIVIAL_DESTRUCTOR
:
5281 case CPTK_HAS_VIRTUAL_DESTRUCTOR
:
5282 case CPTK_IS_ABSTRACT
:
5284 case CPTK_IS_LITERAL_TYPE
:
5286 case CPTK_IS_POLYMORPHIC
:
5287 case CPTK_IS_STD_LAYOUT
:
5288 case CPTK_IS_TRIVIAL
:
5289 if (!check_trait_type (type1
))
5291 error ("incomplete type %qT not allowed", type1
);
5292 return error_mark_node
;
5296 case CPTK_IS_BASE_OF
:
5297 if (NON_UNION_CLASS_TYPE_P (type1
) && NON_UNION_CLASS_TYPE_P (type2
)
5298 && !same_type_ignoring_top_level_qualifiers_p (type1
, type2
)
5299 && !COMPLETE_TYPE_P (type2
))
5301 error ("incomplete type %qT not allowed", type2
);
5302 return error_mark_node
;
5311 case CPTK_IS_CONVERTIBLE_TO
:
5316 return (trait_expr_value (kind
, type1
, type2
)
5317 ? boolean_true_node
: boolean_false_node
);
5320 /* Do-nothing variants of functions to handle pragma FLOAT_CONST_DECIMAL64,
5321 which is ignored for C++. */
5324 set_float_const_decimal64 (void)
5329 clear_float_const_decimal64 (void)
5334 float_const_decimal64_p (void)
5340 /* Return true if T is a literal type. */
5343 literal_type_p (tree t
)
5345 if (SCALAR_TYPE_P (t
)
5346 || TREE_CODE (t
) == REFERENCE_TYPE
)
5348 if (CLASS_TYPE_P (t
))
5350 t
= complete_type (t
);
5351 gcc_assert (COMPLETE_TYPE_P (t
) || errorcount
);
5352 return CLASSTYPE_LITERAL_P (t
);
5354 if (TREE_CODE (t
) == ARRAY_TYPE
)
5355 return literal_type_p (strip_array_types (t
));
5359 /* If DECL is a variable declared `constexpr', require its type
5360 be literal. Return the DECL if OK, otherwise NULL. */
5363 ensure_literal_type_for_constexpr_object (tree decl
)
5365 tree type
= TREE_TYPE (decl
);
5366 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_DECLARED_CONSTEXPR_P (decl
)
5367 && !processing_template_decl
)
5369 if (CLASS_TYPE_P (type
) && !COMPLETE_TYPE_P (complete_type (type
)))
5370 /* Don't complain here, we'll complain about incompleteness
5371 when we try to initialize the variable. */;
5372 else if (!literal_type_p (type
))
5374 error ("the type %qT of constexpr variable %qD is not literal",
5382 /* Representation of entries in the constexpr function definition table. */
5384 typedef struct GTY(()) constexpr_fundef
{
5389 /* This table holds all constexpr function definitions seen in
5390 the current translation unit. */
5392 static GTY ((param_is (constexpr_fundef
))) htab_t constexpr_fundef_table
;
5394 /* Utility function used for managing the constexpr function table.
5395 Return true if the entries pointed to by P and Q are for the
5396 same constexpr function. */
5399 constexpr_fundef_equal (const void *p
, const void *q
)
5401 const constexpr_fundef
*lhs
= (const constexpr_fundef
*) p
;
5402 const constexpr_fundef
*rhs
= (const constexpr_fundef
*) q
;
5403 return lhs
->decl
== rhs
->decl
;
5406 /* Utility function used for managing the constexpr function table.
5407 Return a hash value for the entry pointed to by Q. */
5409 static inline hashval_t
5410 constexpr_fundef_hash (const void *p
)
5412 const constexpr_fundef
*fundef
= (const constexpr_fundef
*) p
;
5413 return DECL_UID (fundef
->decl
);
5416 /* Return a previously saved definition of function FUN. */
5418 static constexpr_fundef
*
5419 retrieve_constexpr_fundef (tree fun
)
5421 constexpr_fundef fundef
= { NULL
, NULL
};
5422 if (constexpr_fundef_table
== NULL
)
5426 return (constexpr_fundef
*) htab_find (constexpr_fundef_table
, &fundef
);
5429 /* Check whether the parameter and return types of FUN are valid for a
5430 constexpr function, and complain if COMPLAIN. */
5433 is_valid_constexpr_fn (tree fun
, bool complain
)
5435 tree parm
= FUNCTION_FIRST_USER_PARM (fun
);
5437 for (; parm
!= NULL
; parm
= TREE_CHAIN (parm
))
5438 if (!literal_type_p (TREE_TYPE (parm
)))
5442 error ("invalid type for parameter %d of constexpr "
5443 "function %q+#D", DECL_PARM_INDEX (parm
), fun
);
5446 if (!DECL_CONSTRUCTOR_P (fun
))
5448 tree rettype
= TREE_TYPE (TREE_TYPE (fun
));
5449 if (!literal_type_p (rettype
))
5453 error ("invalid return type %qT of constexpr function %q+D",
5457 /* Check this again here for cxx_eval_call_expression. */
5458 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
5459 && !CLASSTYPE_LITERAL_P (DECL_CONTEXT (fun
)))
5463 error ("enclosing class of %q+#D is not a literal type", fun
);
5470 /* Return non-null if FUN certainly designates a valid constexpr function
5471 declaration. Otherwise return NULL. Issue appropriate diagnostics
5472 if necessary. Note that we only check the declaration, not the body
5476 validate_constexpr_fundecl (tree fun
)
5478 if (processing_template_decl
|| !DECL_DECLARED_CONSTEXPR_P (fun
))
5480 else if (DECL_CLONED_FUNCTION_P (fun
))
5481 /* We already checked the original function. */
5484 if (!is_valid_constexpr_fn (fun
, !DECL_TEMPLATE_INFO (fun
)))
5486 DECL_DECLARED_CONSTEXPR_P (fun
) = false;
5493 /* Subroutine of build_constexpr_constructor_member_initializers.
5494 The expression tree T represents a data member initialization
5495 in a (constexpr) constructor definition. Build a pairing of
5496 the data member with its initializer, and prepend that pair
5497 to the existing initialization pair INITS. */
5500 build_data_member_initialization (tree t
, VEC(constructor_elt
,gc
) **vec
)
5503 if (TREE_CODE (t
) == CLEANUP_POINT_EXPR
)
5504 t
= TREE_OPERAND (t
, 0);
5505 if (TREE_CODE (t
) == EXPR_STMT
)
5506 t
= TREE_OPERAND (t
, 0);
5507 if (t
== error_mark_node
)
5509 if (TREE_CODE (t
) == STATEMENT_LIST
)
5511 tree_stmt_iterator i
;
5512 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
5514 if (! build_data_member_initialization (tsi_stmt (i
), vec
))
5519 if (TREE_CODE (t
) == CLEANUP_STMT
)
5521 /* We can't see a CLEANUP_STMT in a constructor for a literal class,
5522 but we can in a constexpr constructor for a non-literal class. Just
5523 ignore it; either all the initialization will be constant, in which
5524 case the cleanup can't run, or it can't be constexpr.
5525 Still recurse into CLEANUP_BODY. */
5526 return build_data_member_initialization (CLEANUP_BODY (t
), vec
);
5528 if (TREE_CODE (t
) == CONVERT_EXPR
)
5529 t
= TREE_OPERAND (t
, 0);
5530 if (TREE_CODE (t
) == INIT_EXPR
5531 || TREE_CODE (t
) == MODIFY_EXPR
)
5533 member
= TREE_OPERAND (t
, 0);
5534 init
= unshare_expr (TREE_OPERAND (t
, 1));
5538 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
5539 member
= CALL_EXPR_ARG (t
, 0);
5540 /* We don't use build_cplus_new here because it complains about
5541 abstract bases. Leaving the call unwrapped means that it has the
5542 wrong type, but cxx_eval_constant_expression doesn't care. */
5543 init
= unshare_expr (t
);
5545 if (TREE_CODE (member
) == INDIRECT_REF
)
5546 member
= TREE_OPERAND (member
, 0);
5547 if (TREE_CODE (member
) == NOP_EXPR
)
5551 if (TREE_CODE (op
) == ADDR_EXPR
)
5553 gcc_assert (same_type_ignoring_top_level_qualifiers_p
5554 (TREE_TYPE (TREE_TYPE (op
)),
5555 TREE_TYPE (TREE_TYPE (member
))));
5556 /* Initializing a cv-qualified member; we need to look through
5562 /* We don't put out anything for an empty base. */
5563 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member
))));
5564 /* But if the initializer isn't constexpr, leave it in so we
5566 if (potential_constant_expression (init
))
5570 if (TREE_CODE (member
) == ADDR_EXPR
)
5571 member
= TREE_OPERAND (member
, 0);
5572 if (TREE_CODE (member
) == COMPONENT_REF
5573 /* If we're initializing a member of a subaggregate, it's a vtable
5574 pointer. Leave it as COMPONENT_REF so we remember the path to get
5576 && TREE_CODE (TREE_OPERAND (member
, 0)) != COMPONENT_REF
)
5577 member
= TREE_OPERAND (member
, 1);
5578 CONSTRUCTOR_APPEND_ELT (*vec
, member
, init
);
5582 /* Make sure that there are no statements after LAST in the constructor
5583 body represented by LIST. */
5586 check_constexpr_ctor_body (tree last
, tree list
)
5589 if (TREE_CODE (list
) == STATEMENT_LIST
)
5591 tree_stmt_iterator i
= tsi_last (list
);
5592 for (; !tsi_end_p (i
); tsi_prev (&i
))
5594 tree t
= tsi_stmt (i
);
5597 if (TREE_CODE (t
) == BIND_EXPR
)
5599 if (!check_constexpr_ctor_body (last
, BIND_EXPR_BODY (t
)))
5604 /* We currently allow typedefs and static_assert.
5605 FIXME allow them in the standard, too. */
5606 if (TREE_CODE (t
) != STATIC_ASSERT
)
5613 else if (list
!= last
5614 && TREE_CODE (list
) != STATIC_ASSERT
)
5618 error ("constexpr constructor does not have empty body");
5619 DECL_DECLARED_CONSTEXPR_P (current_function_decl
) = false;
5624 /* Build compile-time evalable representations of member-initializer list
5625 for a constexpr constructor. */
5628 build_constexpr_constructor_member_initializers (tree type
, tree body
)
5630 VEC(constructor_elt
,gc
) *vec
= NULL
;
5632 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
5633 || TREE_CODE (body
) == EH_SPEC_BLOCK
)
5634 body
= TREE_OPERAND (body
, 0);
5635 if (TREE_CODE (body
) == STATEMENT_LIST
)
5636 body
= STATEMENT_LIST_HEAD (body
)->stmt
;
5637 body
= BIND_EXPR_BODY (body
);
5638 if (TREE_CODE (body
) == CLEANUP_POINT_EXPR
)
5640 body
= TREE_OPERAND (body
, 0);
5641 if (TREE_CODE (body
) == EXPR_STMT
)
5642 body
= TREE_OPERAND (body
, 0);
5643 if (TREE_CODE (body
) == INIT_EXPR
5644 && (same_type_ignoring_top_level_qualifiers_p
5645 (TREE_TYPE (TREE_OPERAND (body
, 0)),
5646 current_class_type
)))
5649 return TREE_OPERAND (body
, 1);
5651 ok
= build_data_member_initialization (body
, &vec
);
5653 else if (TREE_CODE (body
) == STATEMENT_LIST
)
5655 tree_stmt_iterator i
;
5656 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
5658 ok
= build_data_member_initialization (tsi_stmt (i
), &vec
);
5664 gcc_assert (errorcount
> 0);
5666 return build_constructor (type
, vec
);
5668 return error_mark_node
;
5671 /* Subroutine of register_constexpr_fundef. BODY is the body of a function
5672 declared to be constexpr, or a sub-statement thereof. Returns the
5673 return value if suitable, error_mark_node for a statement not allowed in
5674 a constexpr function, or NULL_TREE if no return value was found. */
5677 constexpr_fn_retval (tree body
)
5679 switch (TREE_CODE (body
))
5681 case STATEMENT_LIST
:
5683 tree_stmt_iterator i
;
5684 tree expr
= NULL_TREE
;
5685 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
5687 tree s
= constexpr_fn_retval (tsi_stmt (i
));
5688 if (s
== error_mark_node
)
5689 return error_mark_node
;
5690 else if (s
== NULL_TREE
)
5691 /* Keep iterating. */;
5693 /* Multiple return statements. */
5694 return error_mark_node
;
5702 return unshare_expr (TREE_OPERAND (body
, 0));
5705 if (TREE_CODE (DECL_EXPR_DECL (body
)) == USING_DECL
)
5707 return error_mark_node
;
5713 return error_mark_node
;
5717 /* We are processing the definition of the constexpr function FUN.
5718 Check that its BODY fulfills the propriate requirements and
5719 enter it in the constexpr function definition table.
5720 For constructor BODY is actually the TREE_LIST of the
5721 member-initializer list. */
5724 register_constexpr_fundef (tree fun
, tree body
)
5726 constexpr_fundef entry
;
5727 constexpr_fundef
**slot
;
5729 if (DECL_CONSTRUCTOR_P (fun
))
5730 body
= build_constexpr_constructor_member_initializers
5731 (DECL_CONTEXT (fun
), body
);
5734 if (TREE_CODE (body
) == BIND_EXPR
)
5735 body
= BIND_EXPR_BODY (body
);
5736 if (TREE_CODE (body
) == EH_SPEC_BLOCK
)
5737 body
= EH_SPEC_STMTS (body
);
5738 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
5739 body
= TREE_OPERAND (body
, 0);
5740 if (TREE_CODE (body
) == CLEANUP_POINT_EXPR
)
5741 body
= TREE_OPERAND (body
, 0);
5742 body
= constexpr_fn_retval (body
);
5743 if (body
== NULL_TREE
|| body
== error_mark_node
)
5745 error ("body of constexpr function %qD not a return-statement", fun
);
5746 DECL_DECLARED_CONSTEXPR_P (fun
) = false;
5751 if (!potential_rvalue_constant_expression (body
))
5753 DECL_DECLARED_CONSTEXPR_P (fun
) = false;
5754 if (!DECL_TEMPLATE_INFO (fun
))
5755 require_potential_rvalue_constant_expression (body
);
5759 /* Create the constexpr function table if necessary. */
5760 if (constexpr_fundef_table
== NULL
)
5761 constexpr_fundef_table
= htab_create_ggc (101,
5762 constexpr_fundef_hash
,
5763 constexpr_fundef_equal
,
5767 slot
= (constexpr_fundef
**)
5768 htab_find_slot (constexpr_fundef_table
, &entry
, INSERT
);
5770 gcc_assert (*slot
== NULL
);
5771 *slot
= ggc_alloc_constexpr_fundef ();
5777 /* Objects of this type represent calls to constexpr functions
5778 along with the bindings of parameters to their arguments, for
5779 the purpose of compile time evaluation. */
5781 typedef struct GTY(()) constexpr_call
{
5782 /* Description of the constexpr function definition. */
5783 constexpr_fundef
*fundef
;
5784 /* Parameter bindings enironment. A TREE_LIST where each TREE_PURPOSE
5785 is a parameter _DECL and the TREE_VALUE is the value of the parameter.
5786 Note: This arrangement is made to accomodate the use of
5787 iterative_hash_template_arg (see pt.c). If you change this
5788 representation, also change the hash calculation in
5789 cxx_eval_call_expression. */
5791 /* Result of the call.
5792 NULL means the call is being evaluated.
5793 error_mark_node means that the evaluation was erroneous;
5794 otherwise, the actuall value of the call. */
5796 /* The hash of this call; we remember it here to avoid having to
5797 recalculate it when expanding the hash table. */
5801 /* A table of all constexpr calls that have been evaluated by the
5802 compiler in this translation unit. */
5804 static GTY ((param_is (constexpr_call
))) htab_t constexpr_call_table
;
5806 static tree
cxx_eval_constant_expression (const constexpr_call
*, tree
,
5807 bool, bool, bool *);
5809 /* Compute a hash value for a constexpr call representation. */
5812 constexpr_call_hash (const void *p
)
5814 const constexpr_call
*info
= (const constexpr_call
*) p
;
5818 /* Return 1 if the objects pointed to by P and Q represent calls
5819 to the same constexpr function with the same arguments.
5820 Otherwise, return 0. */
5823 constexpr_call_equal (const void *p
, const void *q
)
5825 const constexpr_call
*lhs
= (const constexpr_call
*) p
;
5826 const constexpr_call
*rhs
= (const constexpr_call
*) q
;
5831 if (!constexpr_fundef_equal (lhs
->fundef
, rhs
->fundef
))
5833 lhs_bindings
= lhs
->bindings
;
5834 rhs_bindings
= rhs
->bindings
;
5835 while (lhs_bindings
!= NULL
&& rhs_bindings
!= NULL
)
5837 tree lhs_arg
= TREE_VALUE (lhs_bindings
);
5838 tree rhs_arg
= TREE_VALUE (rhs_bindings
);
5839 gcc_assert (TREE_TYPE (lhs_arg
) == TREE_TYPE (rhs_arg
));
5840 if (!cp_tree_equal (lhs_arg
, rhs_arg
))
5842 lhs_bindings
= TREE_CHAIN (lhs_bindings
);
5843 rhs_bindings
= TREE_CHAIN (rhs_bindings
);
5845 return lhs_bindings
== rhs_bindings
;
5848 /* Initialize the constexpr call table, if needed. */
5851 maybe_initialize_constexpr_call_table (void)
5853 if (constexpr_call_table
== NULL
)
5854 constexpr_call_table
= htab_create_ggc (101,
5855 constexpr_call_hash
,
5856 constexpr_call_equal
,
5860 /* Return true if T designates the implied `this' parameter. */
5863 is_this_parameter (tree t
)
5865 return t
== current_class_ptr
;
5868 /* We have an expression tree T that represents a call, either CALL_EXPR
5869 or AGGR_INIT_EXPR. If the call is lexically to a named function,
5870 retrun the _DECL for that function. */
5873 get_function_named_in_call (tree t
)
5876 switch (TREE_CODE (t
))
5879 fun
= CALL_EXPR_FN (t
);
5882 case AGGR_INIT_EXPR
:
5883 fun
= AGGR_INIT_EXPR_FN (t
);
5890 if (TREE_CODE (fun
) == ADDR_EXPR
5891 && TREE_CODE (TREE_OPERAND (fun
, 0)) == FUNCTION_DECL
)
5892 fun
= TREE_OPERAND (fun
, 0);
5896 /* We have an expression tree T that represents a call, either CALL_EXPR
5897 or AGGR_INIT_EXPR. Return the Nth argument. */
5900 get_nth_callarg (tree t
, int n
)
5902 switch (TREE_CODE (t
))
5905 return CALL_EXPR_ARG (t
, n
);
5907 case AGGR_INIT_EXPR
:
5908 return AGGR_INIT_EXPR_ARG (t
, n
);
5916 /* Look up the binding of the function parameter T in a constexpr
5917 function call context CALL. */
5920 lookup_parameter_binding (const constexpr_call
*call
, tree t
)
5922 tree b
= purpose_member (t
, call
->bindings
);
5923 return TREE_VALUE (b
);
5926 /* Attempt to evaluate T which represents a call to a builtin function.
5927 We assume here that all builtin functions evaluate to scalar types
5928 represented by _CST nodes. */
5931 cxx_eval_builtin_function_call (const constexpr_call
*call
, tree t
,
5932 bool allow_non_constant
, bool addr
,
5933 bool *non_constant_p
)
5935 const int nargs
= call_expr_nargs (t
);
5936 tree
*args
= (tree
*) alloca (nargs
* sizeof (tree
));
5939 for (i
= 0; i
< nargs
; ++i
)
5941 args
[i
] = cxx_eval_constant_expression (call
, CALL_EXPR_ARG (t
, i
),
5942 allow_non_constant
, addr
,
5944 if (allow_non_constant
&& *non_constant_p
)
5947 if (*non_constant_p
)
5949 new_call
= build_call_array_loc (EXPR_LOCATION (t
), TREE_TYPE (t
),
5950 CALL_EXPR_FN (t
), nargs
, args
);
5951 return fold (new_call
);
5954 /* TEMP is the constant value of a temporary object of type TYPE. Adjust
5955 the type of the value to match. */
5958 adjust_temp_type (tree type
, tree temp
)
5960 if (TREE_TYPE (temp
) == type
)
5962 /* Avoid wrapping an aggregate value in a NOP_EXPR. */
5963 if (TREE_CODE (temp
) == CONSTRUCTOR
)
5964 return build_constructor (type
, CONSTRUCTOR_ELTS (temp
));
5965 gcc_assert (SCALAR_TYPE_P (type
));
5966 return cp_fold_convert (type
, temp
);
5969 /* Subroutine of cxx_eval_call_expression.
5970 We are processing a call expression (either CALL_EXPR or
5971 AGGR_INIT_EXPR) in the call context of OLD_CALL. Evaluate
5972 all arguments and bind their values to correspondings
5973 parameters, making up the NEW_CALL context. */
5976 cxx_bind_parameters_in_call (const constexpr_call
*old_call
, tree t
,
5977 constexpr_call
*new_call
,
5978 bool allow_non_constant
,
5979 bool *non_constant_p
)
5981 const int nargs
= call_expr_nargs (t
);
5982 tree fun
= new_call
->fundef
->decl
;
5983 tree parms
= DECL_ARGUMENTS (fun
);
5985 for (i
= 0; i
< nargs
; ++i
)
5988 tree type
= parms
? TREE_TYPE (parms
) : void_type_node
;
5989 /* For member function, the first argument is a pointer to the implied
5990 object. And for an object contruction, don't bind `this' before
5991 it is fully constructed. */
5992 if (i
== 0 && DECL_CONSTRUCTOR_P (fun
))
5994 x
= get_nth_callarg (t
, i
);
5995 arg
= cxx_eval_constant_expression (old_call
, x
, allow_non_constant
,
5996 TREE_CODE (type
) == REFERENCE_TYPE
,
5998 /* Don't VERIFY_CONSTANT here. */
5999 if (*non_constant_p
&& allow_non_constant
)
6001 /* Just discard ellipsis args after checking their constantitude. */
6004 if (*non_constant_p
)
6005 /* Don't try to adjust the type of non-constant args. */
6008 /* Make sure the binding has the same type as the parm. */
6009 if (TREE_CODE (type
) != REFERENCE_TYPE
)
6010 arg
= adjust_temp_type (type
, arg
);
6011 new_call
->bindings
= tree_cons (parms
, arg
, new_call
->bindings
);
6013 parms
= TREE_CHAIN (parms
);
6017 /* Variables and functions to manage constexpr call expansion context.
6018 These do not need to be marked for PCH or GC. */
6020 /* FIXME remember and print actual constant arguments. */
6021 static VEC(tree
,heap
) *call_stack
= NULL
;
6022 static int call_stack_tick
;
6023 static int last_cx_error_tick
;
6026 push_cx_call_context (tree call
)
6029 if (!EXPR_HAS_LOCATION (call
))
6030 SET_EXPR_LOCATION (call
, input_location
);
6031 VEC_safe_push (tree
, heap
, call_stack
, call
);
6032 if (VEC_length (tree
, call_stack
) > (unsigned) max_constexpr_depth
)
6038 pop_cx_call_context (void)
6041 VEC_pop (tree
, call_stack
);
6045 cx_error_context (void)
6047 VEC(tree
,heap
) *r
= NULL
;
6048 if (call_stack_tick
!= last_cx_error_tick
6049 && !VEC_empty (tree
, call_stack
))
6051 last_cx_error_tick
= call_stack_tick
;
6055 /* Subroutine of cxx_eval_constant_expression.
6056 Evaluate the call expression tree T in the context of OLD_CALL expression
6060 cxx_eval_call_expression (const constexpr_call
*old_call
, tree t
,
6061 bool allow_non_constant
, bool addr
,
6062 bool *non_constant_p
)
6064 location_t loc
= EXPR_LOC_OR_HERE (t
);
6065 tree fun
= get_function_named_in_call (t
);
6067 constexpr_call new_call
= { NULL
, NULL
, NULL
, 0 };
6068 constexpr_call
**slot
;
6069 constexpr_call
*entry
;
6072 if (TREE_CODE (fun
) != FUNCTION_DECL
)
6074 /* Might be a constexpr function pointer. */
6075 fun
= cxx_eval_constant_expression (old_call
, fun
, allow_non_constant
,
6076 /*addr*/false, non_constant_p
);
6077 if (TREE_CODE (fun
) == ADDR_EXPR
)
6078 fun
= TREE_OPERAND (fun
, 0);
6080 if (TREE_CODE (fun
) != FUNCTION_DECL
)
6082 if (!allow_non_constant
)
6083 error_at (loc
, "expression %qE does not designate a constexpr "
6085 *non_constant_p
= true;
6088 if (DECL_CLONED_FUNCTION_P (fun
))
6089 fun
= DECL_CLONED_FUNCTION (fun
);
6090 if (is_builtin_fn (fun
))
6091 return cxx_eval_builtin_function_call (old_call
, t
, allow_non_constant
,
6092 addr
, non_constant_p
);
6093 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
6095 if (!allow_non_constant
)
6097 error_at (loc
, "%qD is not a constexpr function", fun
);
6098 if (DECL_TEMPLATE_INFO (fun
)
6099 && DECL_DECLARED_CONSTEXPR_P (DECL_TEMPLATE_RESULT
6100 (DECL_TI_TEMPLATE (fun
))))
6101 is_valid_constexpr_fn (fun
, true);
6103 *non_constant_p
= true;
6107 /* Shortcut trivial copy constructor/op=. */
6108 if (call_expr_nargs (t
) == 2 && trivial_fn_p (fun
))
6110 tree arg
= convert_from_reference (get_nth_callarg (t
, 1));
6111 return cxx_eval_constant_expression (old_call
, arg
, allow_non_constant
,
6112 addr
, non_constant_p
);
6115 /* If in direct recursive call, optimize definition search. */
6116 if (old_call
!= NULL
&& old_call
->fundef
->decl
== fun
)
6117 new_call
.fundef
= old_call
->fundef
;
6120 new_call
.fundef
= retrieve_constexpr_fundef (fun
);
6121 if (new_call
.fundef
== NULL
|| new_call
.fundef
->body
== NULL
)
6123 if (!allow_non_constant
)
6124 error_at (loc
, "%qD used before its definition", fun
);
6125 *non_constant_p
= true;
6129 cxx_bind_parameters_in_call (old_call
, t
, &new_call
,
6130 allow_non_constant
, non_constant_p
);
6131 if (*non_constant_p
)
6134 depth_ok
= push_cx_call_context (t
);
6137 = iterative_hash_template_arg (new_call
.bindings
,
6138 constexpr_fundef_hash (new_call
.fundef
));
6140 /* If we have seen this call before, we are done. */
6141 maybe_initialize_constexpr_call_table ();
6142 slot
= (constexpr_call
**)
6143 htab_find_slot (constexpr_call_table
, &new_call
, INSERT
);
6147 /* We need to keep a pointer to the entry, not just the slot, as the
6148 slot can move in the call to cxx_eval_builtin_function_call. */
6149 *slot
= entry
= ggc_alloc_constexpr_call ();
6152 /* Calls which are in progress have their result set to NULL
6153 so that we can detect circular dependencies. */
6154 else if (entry
->result
== NULL
)
6156 if (!allow_non_constant
)
6157 error ("call has circular dependency");
6158 *non_constant_p
= true;
6159 entry
->result
= result
= error_mark_node
;
6164 if (!allow_non_constant
)
6165 error ("constexpr evaluation depth exceeds maximum of %d (use "
6166 "-fconstexpr-depth= to increase the maximum)",
6167 max_constexpr_depth
);
6168 *non_constant_p
= true;
6169 entry
->result
= result
= error_mark_node
;
6173 result
= entry
->result
;
6174 if (!result
|| (result
== error_mark_node
&& !allow_non_constant
))
6175 result
= (cxx_eval_constant_expression
6176 (&new_call
, new_call
.fundef
->body
,
6177 allow_non_constant
, addr
,
6179 if (result
== error_mark_node
)
6180 *non_constant_p
= true;
6181 if (*non_constant_p
)
6182 entry
->result
= result
= error_mark_node
;
6185 /* If this was a call to initialize an object, set the type of
6186 the CONSTRUCTOR to the type of that object. */
6187 if (DECL_CONSTRUCTOR_P (fun
))
6189 tree ob_arg
= get_nth_callarg (t
, 0);
6190 STRIP_NOPS (ob_arg
);
6191 gcc_assert (TREE_CODE (TREE_TYPE (ob_arg
)) == POINTER_TYPE
6192 && CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (ob_arg
))));
6193 result
= adjust_temp_type (TREE_TYPE (TREE_TYPE (ob_arg
)),
6196 entry
->result
= result
;
6200 pop_cx_call_context ();
6201 return unshare_expr (result
);
6204 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
6207 reduced_constant_expression_p (tree t
)
6209 if (TREE_OVERFLOW_P (t
))
6210 /* Integer overflow makes this not a constant expression. */
6212 /* FIXME are we calling this too much? */
6213 return initializer_constant_valid_p (t
, TREE_TYPE (t
)) != NULL_TREE
;
6216 /* Some expressions may have constant operands but are not constant
6217 themselves, such as 1/0. Call this function (or rather, the macro
6218 following it) to check for that condition.
6220 We only call this in places that require an arithmetic constant, not in
6221 places where we might have a non-constant expression that can be a
6222 component of a constant expression, such as the address of a constexpr
6223 variable that might be dereferenced later. */
6226 verify_constant (tree t
, bool allow_non_constant
, bool *non_constant_p
)
6228 if (!*non_constant_p
&& !reduced_constant_expression_p (t
))
6230 if (!allow_non_constant
)
6232 /* If T was already folded to a _CST with TREE_OVERFLOW set,
6233 printing the folded constant isn't helpful. */
6234 if (TREE_OVERFLOW_P (t
))
6236 permerror (input_location
, "overflow in constant expression");
6237 /* If we're being permissive (and are in an enforcing
6238 context), consider this constant. */
6239 if (flag_permissive
)
6243 error ("%q+E is not a constant expression", t
);
6245 *non_constant_p
= true;
6247 return *non_constant_p
;
6249 #define VERIFY_CONSTANT(X) \
6251 if (verify_constant ((X), allow_non_constant, non_constant_p)) \
6255 /* Subroutine of cxx_eval_constant_expression.
6256 Attempt to reduce the unary expression tree T to a compile time value.
6257 If successful, return the value. Otherwise issue a diagnostic
6258 and return error_mark_node. */
6261 cxx_eval_unary_expression (const constexpr_call
*call
, tree t
,
6262 bool allow_non_constant
, bool addr
,
6263 bool *non_constant_p
)
6266 tree orig_arg
= TREE_OPERAND (t
, 0);
6267 tree arg
= cxx_eval_constant_expression (call
, orig_arg
, allow_non_constant
,
6268 addr
, non_constant_p
);
6269 VERIFY_CONSTANT (arg
);
6270 if (arg
== orig_arg
)
6272 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), arg
);
6273 VERIFY_CONSTANT (r
);
6277 /* Subroutine of cxx_eval_constant_expression.
6278 Like cxx_eval_unary_expression, except for binary expressions. */
6281 cxx_eval_binary_expression (const constexpr_call
*call
, tree t
,
6282 bool allow_non_constant
, bool addr
,
6283 bool *non_constant_p
)
6286 tree orig_lhs
= TREE_OPERAND (t
, 0);
6287 tree orig_rhs
= TREE_OPERAND (t
, 1);
6289 lhs
= cxx_eval_constant_expression (call
, orig_lhs
,
6290 allow_non_constant
, addr
,
6292 VERIFY_CONSTANT (lhs
);
6293 rhs
= cxx_eval_constant_expression (call
, orig_rhs
,
6294 allow_non_constant
, addr
,
6296 VERIFY_CONSTANT (rhs
);
6297 if (lhs
== orig_lhs
&& rhs
== orig_rhs
)
6299 r
= fold_build2 (TREE_CODE (t
), TREE_TYPE (t
), lhs
, rhs
);
6300 VERIFY_CONSTANT (r
);
6304 /* Subroutine of cxx_eval_constant_expression.
6305 Attempt to evaluate condition expressions. Dead branches are not
6309 cxx_eval_conditional_expression (const constexpr_call
*call
, tree t
,
6310 bool allow_non_constant
, bool addr
,
6311 bool *non_constant_p
)
6313 tree val
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 0),
6314 allow_non_constant
, addr
,
6316 VERIFY_CONSTANT (val
);
6317 /* Don't VERIFY_CONSTANT the other operands. */
6318 if (integer_zerop (val
))
6319 return cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 2),
6320 allow_non_constant
, addr
,
6322 return cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 1),
6323 allow_non_constant
, addr
,
6327 /* Subroutine of cxx_eval_constant_expression.
6328 Attempt to reduce a reference to an array slot. */
6331 cxx_eval_array_reference (const constexpr_call
*call
, tree t
,
6332 bool allow_non_constant
, bool addr
,
6333 bool *non_constant_p
)
6335 tree oldary
= TREE_OPERAND (t
, 0);
6336 tree ary
= cxx_eval_constant_expression (call
, oldary
,
6337 allow_non_constant
, addr
,
6342 unsigned len
, elem_nchars
= 1;
6343 if (*non_constant_p
)
6345 oldidx
= TREE_OPERAND (t
, 1);
6346 index
= cxx_eval_constant_expression (call
, oldidx
,
6347 allow_non_constant
, false,
6349 VERIFY_CONSTANT (index
);
6350 if (addr
&& ary
== oldary
&& index
== oldidx
)
6353 return build4 (ARRAY_REF
, TREE_TYPE (t
), ary
, index
, NULL
, NULL
);
6354 elem_type
= TREE_TYPE (TREE_TYPE (ary
));
6355 if (TREE_CODE (ary
) == CONSTRUCTOR
)
6356 len
= CONSTRUCTOR_NELTS (ary
);
6359 elem_nchars
= (TYPE_PRECISION (elem_type
)
6360 / TYPE_PRECISION (char_type_node
));
6361 len
= (unsigned) TREE_STRING_LENGTH (ary
) / elem_nchars
;
6363 if (compare_tree_int (index
, len
) >= 0)
6365 if (tree_int_cst_lt (index
, array_type_nelts_top (TREE_TYPE (ary
))))
6367 /* If it's within the array bounds but doesn't have an explicit
6368 initializer, it's value-initialized. */
6369 tree val
= build_value_init (elem_type
, tf_warning_or_error
);
6370 return cxx_eval_constant_expression (call
, val
,
6371 allow_non_constant
, addr
,
6375 if (!allow_non_constant
)
6376 error ("array subscript out of bound");
6377 *non_constant_p
= true;
6380 i
= tree_low_cst (index
, 0);
6381 if (TREE_CODE (ary
) == CONSTRUCTOR
)
6382 return VEC_index (constructor_elt
, CONSTRUCTOR_ELTS (ary
), i
)->value
;
6383 else if (elem_nchars
== 1)
6384 return build_int_cst (cv_unqualified (TREE_TYPE (TREE_TYPE (ary
))),
6385 TREE_STRING_POINTER (ary
)[i
]);
6388 tree type
= cv_unqualified (TREE_TYPE (TREE_TYPE (ary
)));
6389 return native_interpret_expr (type
, (const unsigned char *)
6390 TREE_STRING_POINTER (ary
)
6391 + i
* elem_nchars
, elem_nchars
);
6393 /* Don't VERIFY_CONSTANT here. */
6396 /* Subroutine of cxx_eval_constant_expression.
6397 Attempt to reduce a field access of a value of class type. */
6400 cxx_eval_component_reference (const constexpr_call
*call
, tree t
,
6401 bool allow_non_constant
, bool addr
,
6402 bool *non_constant_p
)
6404 unsigned HOST_WIDE_INT i
;
6407 tree part
= TREE_OPERAND (t
, 1);
6408 tree orig_whole
= TREE_OPERAND (t
, 0);
6409 tree whole
= cxx_eval_constant_expression (call
, orig_whole
,
6410 allow_non_constant
, addr
,
6412 if (whole
== orig_whole
)
6415 return fold_build3 (COMPONENT_REF
, TREE_TYPE (t
),
6416 whole
, part
, NULL_TREE
);
6417 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
6419 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
6421 if (!allow_non_constant
)
6422 error ("%qE is not a constant expression", orig_whole
);
6423 *non_constant_p
= true;
6425 if (*non_constant_p
)
6427 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
6432 if (TREE_CODE (TREE_TYPE (whole
)) == UNION_TYPE
)
6434 /* FIXME Mike Miller wants this to be OK. */
6435 if (!allow_non_constant
)
6436 error ("accessing %qD member instead of initialized %qD member in "
6437 "constant expression", part
, CONSTRUCTOR_ELT (whole
, 0)->index
);
6438 *non_constant_p
= true;
6442 return error_mark_node
;
6445 /* Subroutine of cxx_eval_constant_expression.
6446 Attempt to reduce a field access of a value of class type that is
6447 expressed as a BIT_FIELD_REF. */
6450 cxx_eval_bit_field_ref (const constexpr_call
*call
, tree t
,
6451 bool allow_non_constant
, bool addr
,
6452 bool *non_constant_p
)
6454 tree orig_whole
= TREE_OPERAND (t
, 0);
6455 tree retval
, fldval
, utype
, mask
;
6456 bool fld_seen
= false;
6457 HOST_WIDE_INT istart
, isize
;
6458 tree whole
= cxx_eval_constant_expression (call
, orig_whole
,
6459 allow_non_constant
, addr
,
6461 tree start
, field
, value
;
6462 unsigned HOST_WIDE_INT i
;
6464 if (whole
== orig_whole
)
6466 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
6468 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
6470 if (!allow_non_constant
)
6471 error ("%qE is not a constant expression", orig_whole
);
6472 *non_constant_p
= true;
6474 if (*non_constant_p
)
6477 start
= TREE_OPERAND (t
, 2);
6478 istart
= tree_low_cst (start
, 0);
6479 isize
= tree_low_cst (TREE_OPERAND (t
, 1), 0);
6480 utype
= TREE_TYPE (t
);
6481 if (!TYPE_UNSIGNED (utype
))
6482 utype
= build_nonstandard_integer_type (TYPE_PRECISION (utype
), 1);
6483 retval
= build_int_cst (utype
, 0);
6484 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
6486 tree bitpos
= bit_position (field
);
6487 if (bitpos
== start
&& DECL_SIZE (field
) == TREE_OPERAND (t
, 1))
6489 if (TREE_CODE (TREE_TYPE (field
)) == INTEGER_TYPE
6490 && TREE_CODE (value
) == INTEGER_CST
6491 && host_integerp (bitpos
, 0)
6492 && host_integerp (DECL_SIZE (field
), 0))
6494 HOST_WIDE_INT bit
= tree_low_cst (bitpos
, 0);
6495 HOST_WIDE_INT sz
= tree_low_cst (DECL_SIZE (field
), 0);
6496 HOST_WIDE_INT shift
;
6497 if (bit
>= istart
&& bit
+ sz
<= istart
+ isize
)
6499 fldval
= fold_convert (utype
, value
);
6500 mask
= build_int_cst_type (utype
, -1);
6501 mask
= fold_build2 (LSHIFT_EXPR
, utype
, mask
,
6502 size_int (TYPE_PRECISION (utype
) - sz
));
6503 mask
= fold_build2 (RSHIFT_EXPR
, utype
, mask
,
6504 size_int (TYPE_PRECISION (utype
) - sz
));
6505 fldval
= fold_build2 (BIT_AND_EXPR
, utype
, fldval
, mask
);
6506 shift
= bit
- istart
;
6507 if (BYTES_BIG_ENDIAN
)
6508 shift
= TYPE_PRECISION (utype
) - shift
- sz
;
6509 fldval
= fold_build2 (LSHIFT_EXPR
, utype
, fldval
,
6511 retval
= fold_build2 (BIT_IOR_EXPR
, utype
, retval
, fldval
);
6517 return fold_convert (TREE_TYPE (t
), retval
);
6519 return error_mark_node
;
6522 /* Subroutine of cxx_eval_constant_expression.
6523 Evaluate a short-circuited logical expression T in the context
6524 of a given constexpr CALL. BAILOUT_VALUE is the value for
6525 early return. CONTINUE_VALUE is used here purely for
6526 sanity check purposes. */
6529 cxx_eval_logical_expression (const constexpr_call
*call
, tree t
,
6530 tree bailout_value
, tree continue_value
,
6531 bool allow_non_constant
, bool addr
,
6532 bool *non_constant_p
)
6535 tree lhs
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 0),
6536 allow_non_constant
, addr
,
6538 VERIFY_CONSTANT (lhs
);
6539 if (lhs
== bailout_value
)
6541 gcc_assert (lhs
== continue_value
);
6542 r
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 1),
6543 allow_non_constant
, addr
, non_constant_p
);
6544 VERIFY_CONSTANT (r
);
6548 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
6549 CONSTRUCTOR elements to initialize (part of) an object containing that
6550 field. Return a pointer to the constructor_elt corresponding to the
6551 initialization of the field. */
6553 static constructor_elt
*
6554 base_field_constructor_elt (VEC(constructor_elt
,gc
) *v
, tree ref
)
6556 tree aggr
= TREE_OPERAND (ref
, 0);
6557 tree field
= TREE_OPERAND (ref
, 1);
6559 constructor_elt
*ce
;
6561 gcc_assert (TREE_CODE (ref
) == COMPONENT_REF
);
6563 if (TREE_CODE (aggr
) == COMPONENT_REF
)
6565 constructor_elt
*base_ce
6566 = base_field_constructor_elt (v
, aggr
);
6567 v
= CONSTRUCTOR_ELTS (base_ce
->value
);
6570 for (i
= 0; VEC_iterate (constructor_elt
, v
, i
, ce
); ++i
)
6571 if (ce
->index
== field
)
6578 /* Subroutine of cxx_eval_constant_expression.
6579 The expression tree T denotes a C-style array or a C-style
6580 aggregate. Reduce it to a constant expression. */
6583 cxx_eval_bare_aggregate (const constexpr_call
*call
, tree t
,
6584 bool allow_non_constant
, bool addr
,
6585 bool *non_constant_p
)
6587 VEC(constructor_elt
,gc
) *v
= CONSTRUCTOR_ELTS (t
);
6588 VEC(constructor_elt
,gc
) *n
= VEC_alloc (constructor_elt
, gc
,
6589 VEC_length (constructor_elt
, v
));
6590 constructor_elt
*ce
;
6592 bool changed
= false;
6593 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t
));
6594 for (i
= 0; VEC_iterate (constructor_elt
, v
, i
, ce
); ++i
)
6596 tree elt
= cxx_eval_constant_expression (call
, ce
->value
,
6597 allow_non_constant
, addr
,
6599 /* Don't VERIFY_CONSTANT here. */
6600 if (allow_non_constant
&& *non_constant_p
)
6602 if (elt
!= ce
->value
)
6604 if (TREE_CODE (ce
->index
) == COMPONENT_REF
)
6606 /* This is an initialization of a vfield inside a base
6607 subaggregate that we already initialized; push this
6608 initialization into the previous initialization. */
6609 constructor_elt
*inner
= base_field_constructor_elt (n
, ce
->index
);
6613 CONSTRUCTOR_APPEND_ELT (n
, ce
->index
, elt
);
6615 if (*non_constant_p
|| !changed
)
6618 VEC_free (constructor_elt
, gc
, n
);
6621 t
= build_constructor (TREE_TYPE (t
), n
);
6622 TREE_CONSTANT (t
) = true;
6626 /* Subroutine of cxx_eval_constant_expression.
6627 The expression tree T is a VEC_INIT_EXPR which denotes the desired
6628 initialization of a non-static data member of array type. Reduce it to a
6631 Note that apart from value-initialization (when VALUE_INIT is true),
6632 this is only intended to support value-initialization and the
6633 initializations done by defaulted constructors for classes with
6634 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
6635 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
6636 for the copy/move constructor. */
6639 cxx_eval_vec_init_1 (const constexpr_call
*call
, tree atype
, tree init
,
6640 bool value_init
, bool allow_non_constant
, bool addr
,
6641 bool *non_constant_p
)
6643 tree elttype
= TREE_TYPE (atype
);
6644 int max
= tree_low_cst (array_type_nelts (atype
), 0);
6645 VEC(constructor_elt
,gc
) *n
= VEC_alloc (constructor_elt
, gc
, max
+ 1);
6648 /* For the default constructor, build up a call to the default
6649 constructor of the element type. We only need to handle class types
6650 here, as for a constructor to be constexpr, all members must be
6651 initialized, which for a defaulted default constructor means they must
6652 be of a class type with a constexpr default constructor. */
6657 VEC(tree
,gc
) *argvec
= make_tree_vector ();
6658 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
6659 &argvec
, elttype
, LOOKUP_NORMAL
,
6660 tf_warning_or_error
);
6661 release_tree_vector (argvec
);
6662 init
= cxx_eval_constant_expression (call
, init
, allow_non_constant
,
6663 addr
, non_constant_p
);
6666 if (*non_constant_p
&& !allow_non_constant
)
6669 for (i
= 0; i
<= max
; ++i
)
6671 tree idx
= build_int_cst (size_type_node
, i
);
6673 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
6675 /* A multidimensional array; recurse. */
6677 eltinit
= NULL_TREE
;
6679 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
6680 tf_warning_or_error
);
6681 eltinit
= cxx_eval_vec_init_1 (call
, elttype
, eltinit
, value_init
,
6682 allow_non_constant
, addr
,
6685 else if (value_init
)
6687 eltinit
= build_value_init (elttype
, tf_warning_or_error
);
6688 eltinit
= cxx_eval_constant_expression
6689 (call
, eltinit
, allow_non_constant
, addr
, non_constant_p
);
6691 else if (TREE_CODE (init
) == CONSTRUCTOR
)
6693 /* Initializing an element using the call to the default
6694 constructor we just built above. */
6695 eltinit
= unshare_expr (init
);
6699 /* Copying an element. */
6700 VEC(tree
,gc
) *argvec
;
6701 gcc_assert (same_type_ignoring_top_level_qualifiers_p
6702 (atype
, TREE_TYPE (init
)));
6703 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
6704 tf_warning_or_error
);
6705 if (!real_lvalue_p (init
))
6706 eltinit
= move (eltinit
);
6707 argvec
= make_tree_vector ();
6708 VEC_quick_push (tree
, argvec
, eltinit
);
6709 eltinit
= (build_special_member_call
6710 (NULL_TREE
, complete_ctor_identifier
, &argvec
,
6711 elttype
, LOOKUP_NORMAL
, tf_warning_or_error
));
6712 release_tree_vector (argvec
);
6713 eltinit
= cxx_eval_constant_expression
6714 (call
, eltinit
, allow_non_constant
, addr
, non_constant_p
);
6716 if (*non_constant_p
&& !allow_non_constant
)
6718 CONSTRUCTOR_APPEND_ELT (n
, idx
, eltinit
);
6721 if (!*non_constant_p
)
6723 init
= build_constructor (TREE_TYPE (atype
), n
);
6724 TREE_CONSTANT (init
) = true;
6729 VEC_free (constructor_elt
, gc
, n
);
6734 cxx_eval_vec_init (const constexpr_call
*call
, tree t
,
6735 bool allow_non_constant
, bool addr
,
6736 bool *non_constant_p
)
6738 tree atype
= TREE_TYPE (t
);
6739 tree init
= VEC_INIT_EXPR_INIT (t
);
6740 tree r
= cxx_eval_vec_init_1 (call
, atype
, init
,
6741 VEC_INIT_EXPR_VALUE_INIT (t
),
6742 allow_non_constant
, addr
, non_constant_p
);
6743 if (*non_constant_p
)
6749 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
6750 match. We want to be less strict for simple *& folding; if we have a
6751 non-const temporary that we access through a const pointer, that should
6752 work. We handle this here rather than change fold_indirect_ref_1
6753 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
6754 don't really make sense outside of constant expression evaluation. Also
6755 we want to allow folding to COMPONENT_REF, which could cause trouble
6756 with TBAA in fold_indirect_ref_1. */
6759 cxx_eval_indirect_ref (const constexpr_call
*call
, tree t
,
6760 bool allow_non_constant
, bool addr
,
6761 bool *non_constant_p
)
6763 tree orig_op0
= TREE_OPERAND (t
, 0);
6764 tree op0
= cxx_eval_constant_expression (call
, orig_op0
, allow_non_constant
,
6765 /*addr*/false, non_constant_p
);
6766 tree type
, sub
, subtype
, r
;
6769 /* Don't VERIFY_CONSTANT here. */
6770 if (*non_constant_p
)
6773 type
= TREE_TYPE (t
);
6779 subtype
= TREE_TYPE (sub
);
6780 gcc_assert (POINTER_TYPE_P (subtype
));
6782 if (TREE_CODE (sub
) == ADDR_EXPR
)
6784 tree op
= TREE_OPERAND (sub
, 0);
6785 tree optype
= TREE_TYPE (op
);
6787 if (same_type_ignoring_top_level_qualifiers_p (optype
, type
))
6789 /* Also handle conversion to an empty base class, which
6790 is represented with a NOP_EXPR. */
6791 else if (!addr
&& is_empty_class (type
)
6792 && CLASS_TYPE_P (optype
)
6793 && DERIVED_FROM_P (type
, optype
))
6798 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
6799 else if (RECORD_OR_UNION_TYPE_P (optype
))
6801 tree field
= TYPE_FIELDS (optype
);
6802 for (; field
; field
= DECL_CHAIN (field
))
6803 if (TREE_CODE (field
) == FIELD_DECL
6804 && integer_zerop (byte_position (field
))
6805 && (same_type_ignoring_top_level_qualifiers_p
6806 (TREE_TYPE (field
), type
)))
6808 r
= fold_build3 (COMPONENT_REF
, type
, op
, field
, NULL_TREE
);
6813 else if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
6814 && TREE_CODE (TREE_OPERAND (sub
, 1)) == INTEGER_CST
)
6816 tree op00
= TREE_OPERAND (sub
, 0);
6817 tree op01
= TREE_OPERAND (sub
, 1);
6820 if (TREE_CODE (op00
) == ADDR_EXPR
)
6823 op00
= TREE_OPERAND (op00
, 0);
6824 op00type
= TREE_TYPE (op00
);
6826 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
6827 if (RECORD_OR_UNION_TYPE_P (op00type
))
6829 tree field
= TYPE_FIELDS (op00type
);
6830 for (; field
; field
= DECL_CHAIN (field
))
6831 if (TREE_CODE (field
) == FIELD_DECL
6832 && tree_int_cst_equal (byte_position (field
), op01
)
6833 && (same_type_ignoring_top_level_qualifiers_p
6834 (TREE_TYPE (field
), type
)))
6836 r
= fold_build3 (COMPONENT_REF
, type
, op00
,
6844 /* Let build_fold_indirect_ref handle the cases it does fine with. */
6846 r
= build_fold_indirect_ref (op0
);
6847 if (TREE_CODE (r
) != INDIRECT_REF
)
6848 r
= cxx_eval_constant_expression (call
, r
, allow_non_constant
,
6849 addr
, non_constant_p
);
6850 else if (TREE_CODE (sub
) == ADDR_EXPR
6851 || TREE_CODE (sub
) == POINTER_PLUS_EXPR
)
6853 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
6854 (TREE_TYPE (TREE_TYPE (sub
)), TREE_TYPE (t
)));
6855 /* FIXME Mike Miller wants this to be OK. */
6856 if (!allow_non_constant
)
6857 error ("accessing value of %qE through a %qT glvalue in a "
6858 "constant expression", build_fold_indirect_ref (sub
),
6860 *non_constant_p
= true;
6864 /* If we're pulling out the value of an empty base, make sure
6865 that the whole object is constant and then return an empty
6869 VERIFY_CONSTANT (r
);
6870 r
= build_constructor (TREE_TYPE (t
), NULL
);
6871 TREE_CONSTANT (r
) = true;
6874 if (TREE_CODE (r
) == INDIRECT_REF
&& TREE_OPERAND (r
, 0) == orig_op0
)
6879 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
6880 Shared between potential_constant_expression and
6881 cxx_eval_constant_expression. */
6884 non_const_var_error (tree r
)
6886 tree type
= TREE_TYPE (r
);
6887 error ("the value of %qD is not usable in a constant "
6889 /* Avoid error cascade. */
6890 if (DECL_INITIAL (r
) == error_mark_node
)
6892 if (DECL_DECLARED_CONSTEXPR_P (r
))
6893 inform (DECL_SOURCE_LOCATION (r
),
6894 "%qD used in its own initializer", r
);
6895 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
6897 if (!CP_TYPE_CONST_P (type
))
6898 inform (DECL_SOURCE_LOCATION (r
),
6899 "%q#D is not const", r
);
6900 else if (CP_TYPE_VOLATILE_P (type
))
6901 inform (DECL_SOURCE_LOCATION (r
),
6902 "%q#D is volatile", r
);
6903 else if (!DECL_INITIAL (r
))
6904 inform (DECL_SOURCE_LOCATION (r
),
6905 "%qD was not initialized with a constant "
6912 if (cxx_dialect
>= cxx0x
&& !DECL_DECLARED_CONSTEXPR_P (r
))
6913 inform (DECL_SOURCE_LOCATION (r
),
6914 "%qD was not declared %<constexpr%>", r
);
6916 inform (DECL_SOURCE_LOCATION (r
),
6917 "%qD does not have integral or enumeration type",
6922 /* Attempt to reduce the expression T to a constant value.
6923 On failure, issue diagnostic and return error_mark_node. */
6924 /* FIXME unify with c_fully_fold */
6927 cxx_eval_constant_expression (const constexpr_call
*call
, tree t
,
6928 bool allow_non_constant
, bool addr
,
6929 bool *non_constant_p
)
6933 if (t
== error_mark_node
)
6935 *non_constant_p
= true;
6938 if (CONSTANT_CLASS_P (t
))
6940 if (TREE_CODE (t
) == PTRMEM_CST
)
6941 t
= cplus_expand_constant (t
);
6944 if (TREE_CODE (t
) != NOP_EXPR
6945 && reduced_constant_expression_p (t
))
6948 switch (TREE_CODE (t
))
6953 /* else fall through. */
6955 r
= integral_constant_value (t
);
6956 if (TREE_CODE (r
) == TARGET_EXPR
6957 && TREE_CODE (TARGET_EXPR_INITIAL (r
)) == CONSTRUCTOR
)
6958 r
= TARGET_EXPR_INITIAL (r
);
6961 if (!allow_non_constant
)
6962 non_const_var_error (r
);
6963 *non_constant_p
= true;
6973 if (call
&& DECL_CONTEXT (t
) == call
->fundef
->decl
)
6974 r
= lookup_parameter_binding (call
, t
);
6976 /* Defer in case this is only used for its type. */;
6979 if (!allow_non_constant
)
6980 error ("%qE is not a constant expression", t
);
6981 *non_constant_p
= true;
6986 case AGGR_INIT_EXPR
:
6987 r
= cxx_eval_call_expression (call
, t
, allow_non_constant
, addr
,
6993 /* Pass false for 'addr' because these codes indicate
6994 initialization of a temporary. */
6995 r
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 1),
6996 allow_non_constant
, false,
6998 if (!*non_constant_p
)
6999 /* Adjust the type of the result to the type of the temporary. */
7000 r
= adjust_temp_type (TREE_TYPE (t
), r
);
7004 r
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 1),
7005 allow_non_constant
, addr
,
7010 case NON_LVALUE_EXPR
:
7011 case TRY_CATCH_EXPR
:
7012 case CLEANUP_POINT_EXPR
:
7013 case MUST_NOT_THROW_EXPR
:
7015 r
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 0),
7016 allow_non_constant
, addr
,
7020 /* These differ from cxx_eval_unary_expression in that this doesn't
7021 check for a constant operand or result; an address can be
7022 constant without its operand being, and vice versa. */
7024 r
= cxx_eval_indirect_ref (call
, t
, allow_non_constant
, addr
,
7030 tree oldop
= TREE_OPERAND (t
, 0);
7031 tree op
= cxx_eval_constant_expression (call
, oldop
,
7035 /* Don't VERIFY_CONSTANT here. */
7036 if (*non_constant_p
)
7038 /* This function does more aggressive folding than fold itself. */
7039 r
= build_fold_addr_expr_with_type (op
, TREE_TYPE (t
));
7040 if (TREE_CODE (r
) == ADDR_EXPR
&& TREE_OPERAND (r
, 0) == oldop
)
7048 case FIX_TRUNC_EXPR
:
7053 case TRUTH_NOT_EXPR
:
7054 case FIXED_CONVERT_EXPR
:
7055 r
= cxx_eval_unary_expression (call
, t
, allow_non_constant
, addr
,
7061 /* check_return_expr sometimes wraps a TARGET_EXPR in a
7062 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
7063 introduced by build_call_a. */
7064 tree op0
= TREE_OPERAND (t
, 0);
7065 tree op1
= TREE_OPERAND (t
, 1);
7067 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
7068 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
7069 r
= cxx_eval_constant_expression (call
, op0
, allow_non_constant
,
7070 addr
, non_constant_p
);
7073 /* Check that the LHS is constant and then discard it. */
7074 cxx_eval_constant_expression (call
, op0
, allow_non_constant
,
7075 false, non_constant_p
);
7076 r
= cxx_eval_constant_expression (call
, op1
, allow_non_constant
,
7077 addr
, non_constant_p
);
7082 case POINTER_PLUS_EXPR
:
7086 case TRUNC_DIV_EXPR
:
7088 case FLOOR_DIV_EXPR
:
7089 case ROUND_DIV_EXPR
:
7090 case TRUNC_MOD_EXPR
:
7092 case ROUND_MOD_EXPR
:
7094 case EXACT_DIV_EXPR
:
7104 case TRUTH_XOR_EXPR
:
7111 case UNORDERED_EXPR
:
7120 r
= cxx_eval_binary_expression (call
, t
, allow_non_constant
, addr
,
7124 /* fold can introduce non-IF versions of these; still treat them as
7125 short-circuiting. */
7126 case TRUTH_AND_EXPR
:
7127 case TRUTH_ANDIF_EXPR
:
7128 r
= cxx_eval_logical_expression (call
, t
, boolean_false_node
,
7130 allow_non_constant
, addr
,
7135 case TRUTH_ORIF_EXPR
:
7136 r
= cxx_eval_logical_expression (call
, t
, boolean_true_node
,
7138 allow_non_constant
, addr
,
7143 r
= cxx_eval_array_reference (call
, t
, allow_non_constant
, addr
,
7148 r
= cxx_eval_component_reference (call
, t
, allow_non_constant
, addr
,
7153 r
= cxx_eval_bit_field_ref (call
, t
, allow_non_constant
, addr
,
7159 r
= cxx_eval_conditional_expression (call
, t
, allow_non_constant
, addr
,
7164 r
= cxx_eval_bare_aggregate (call
, t
, allow_non_constant
, addr
,
7169 /* We can get this in a defaulted constructor for a class with a
7170 non-static data member of array type. Either the initializer will
7171 be NULL, meaning default-initialization, or it will be an lvalue
7172 or xvalue of the same type, meaning direct-initialization from the
7173 corresponding member. */
7174 r
= cxx_eval_vec_init (call
, t
, allow_non_constant
, addr
,
7179 case VIEW_CONVERT_EXPR
:
7182 tree oldop
= TREE_OPERAND (t
, 0);
7184 tree to
= TREE_TYPE (t
);
7185 tree source
= TREE_TYPE (op
);
7186 if (TYPE_PTR_P (source
) && ARITHMETIC_TYPE_P (to
)
7187 && !(TREE_CODE (op
) == COMPONENT_REF
7188 && TYPE_PTRMEMFUNC_P (TREE_TYPE (TREE_OPERAND (op
, 0)))))
7190 if (!allow_non_constant
)
7191 error ("conversion of expression %qE of pointer type "
7192 "cannot yield a constant expression", op
);
7193 *non_constant_p
= true;
7196 op
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 0),
7197 allow_non_constant
, addr
,
7199 if (*non_constant_p
)
7202 /* We didn't fold at the top so we could check for ptr-int
7205 r
= fold_build1 (TREE_CODE (t
), to
, op
);
7206 /* Conversion of an out-of-range value has implementation-defined
7207 behavior; the language considers it different from arithmetic
7208 overflow, which is undefined. */
7209 if (TREE_OVERFLOW_P (r
) && !TREE_OVERFLOW_P (op
))
7210 TREE_OVERFLOW (r
) = false;
7214 case EMPTY_CLASS_EXPR
:
7215 /* This is good enough for a function argument that might not get
7216 used, and they can't do anything with it, so just return it. */
7220 case DYNAMIC_CAST_EXPR
:
7221 case PSEUDO_DTOR_EXPR
:
7222 case PREINCREMENT_EXPR
:
7223 case POSTINCREMENT_EXPR
:
7224 case PREDECREMENT_EXPR
:
7225 case POSTDECREMENT_EXPR
:
7229 case VEC_DELETE_EXPR
:
7233 /* GCC internal stuff. */
7236 case WITH_CLEANUP_EXPR
:
7237 case STATEMENT_LIST
:
7239 case NON_DEPENDENT_EXPR
:
7243 if (!allow_non_constant
)
7244 error_at (EXPR_LOC_OR_HERE (t
),
7245 "expression %qE is not a constant-expression", t
);
7246 *non_constant_p
= true;
7250 internal_error ("unexpected expression %qE of kind %s", t
,
7251 tree_code_name
[TREE_CODE (t
)]);
7252 *non_constant_p
= true;
7256 if (r
== error_mark_node
)
7257 *non_constant_p
= true;
7259 if (*non_constant_p
)
7266 cxx_eval_outermost_constant_expr (tree t
, bool allow_non_constant
)
7268 bool non_constant_p
= false;
7269 tree r
= cxx_eval_constant_expression (NULL
, t
, allow_non_constant
,
7270 false, &non_constant_p
);
7272 verify_constant (r
, allow_non_constant
, &non_constant_p
);
7274 if (non_constant_p
&& !allow_non_constant
)
7275 return error_mark_node
;
7276 else if (non_constant_p
&& TREE_CONSTANT (t
))
7278 /* This isn't actually constant, so unset TREE_CONSTANT. */
7279 if (EXPR_P (t
) || TREE_CODE (t
) == CONSTRUCTOR
)
7282 r
= build_nop (TREE_TYPE (t
), t
);
7283 TREE_CONSTANT (r
) = false;
7286 else if (non_constant_p
|| r
== t
)
7288 else if (TREE_CODE (r
) == CONSTRUCTOR
&& CLASS_TYPE_P (TREE_TYPE (r
)))
7290 if (TREE_CODE (t
) == TARGET_EXPR
7291 && TARGET_EXPR_INITIAL (t
) == r
)
7295 r
= get_target_expr (r
);
7296 TREE_CONSTANT (r
) = true;
7304 /* Returns true if T is a valid subexpression of a constant expression,
7305 even if it isn't itself a constant expression. */
7308 is_sub_constant_expr (tree t
)
7310 bool non_constant_p
= false;
7311 cxx_eval_constant_expression (NULL
, t
, true, false, &non_constant_p
);
7312 return !non_constant_p
;
7315 /* If T represents a constant expression returns its reduced value.
7316 Otherwise return error_mark_node. If T is dependent, then
7320 cxx_constant_value (tree t
)
7322 return cxx_eval_outermost_constant_expr (t
, false);
7325 /* If T is a constant expression, returns its reduced value.
7326 Otherwise, if T does not have TREE_CONSTANT set, returns T.
7327 Otherwise, returns a version of T without TREE_CONSTANT. */
7330 maybe_constant_value (tree t
)
7334 if (type_dependent_expression_p (t
)
7335 || type_unknown_p (t
)
7336 || !potential_constant_expression (t
)
7337 || value_dependent_expression_p (t
))
7340 r
= cxx_eval_outermost_constant_expr (t
, true);
7341 #ifdef ENABLE_CHECKING
7342 /* cp_tree_equal looks through NOPs, so allow them. */
7344 || CONVERT_EXPR_P (t
)
7345 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
7346 || !cp_tree_equal (r
, t
));
7351 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
7352 than wrapped in a TARGET_EXPR. */
7355 maybe_constant_init (tree t
)
7357 t
= maybe_constant_value (t
);
7358 if (TREE_CODE (t
) == TARGET_EXPR
)
7360 tree init
= TARGET_EXPR_INITIAL (t
);
7361 if (TREE_CODE (init
) == CONSTRUCTOR
7362 && TREE_CONSTANT (init
))
7369 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
7370 /* Return true if the object referred to by REF has automatic or thread
7373 enum { ck_ok
, ck_bad
, ck_unknown
};
7375 check_automatic_or_tls (tree ref
)
7377 enum machine_mode mode
;
7378 HOST_WIDE_INT bitsize
, bitpos
;
7380 int volatilep
= 0, unsignedp
= 0;
7381 tree decl
= get_inner_reference (ref
, &bitsize
, &bitpos
, &offset
,
7382 &mode
, &unsignedp
, &volatilep
, false);
7385 /* If there isn't a decl in the middle, we don't know the linkage here,
7386 and this isn't a constant expression anyway. */
7389 dk
= decl_storage_duration (decl
);
7390 return (dk
== dk_auto
|| dk
== dk_thread
) ? ck_bad
: ck_ok
;
7394 /* Return true if the DECL designates a builtin function that is
7395 morally constexpr, in the sense that its parameter types and
7396 return type are literal types and the compiler is allowed to
7397 fold its invocations. */
7400 morally_constexpr_builtin_function_p (tree decl
)
7402 tree funtype
= TREE_TYPE (decl
);
7405 if (!is_builtin_fn (decl
))
7407 if (!literal_type_p (TREE_TYPE (funtype
)))
7409 for (t
= TYPE_ARG_TYPES (funtype
); t
!= NULL
; t
= TREE_CHAIN (t
))
7411 if (t
== void_list_node
)
7413 if (!literal_type_p (TREE_VALUE (t
)))
7416 /* We assume no varargs builtins are suitable. */
7420 /* Return true if T denotes a potentially constant expression. Issue
7421 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
7422 an lvalue-rvalue conversion is implied.
7424 C++0x [expr.const] used to say
7426 6 An expression is a potential constant expression if it is
7427 a constant expression where all occurences of function
7428 parameters are replaced by arbitrary constant expressions
7429 of the appropriate type.
7431 2 A conditional expression is a constant expression unless it
7432 involves one of the following as a potentially evaluated
7433 subexpression (3.2), but subexpressions of logical AND (5.14),
7434 logical OR (5.15), and conditional (5.16) operations that are
7435 not evaluated are not considered. */
7438 potential_constant_expression_1 (tree t
, bool want_rval
, tsubst_flags_t flags
)
7440 enum { any
= false, rval
= true };
7444 /* C++98 has different rules for the form of a constant expression that
7445 are enforced in the parser, so we can assume that anything that gets
7446 this far is suitable. */
7447 if (cxx_dialect
< cxx0x
)
7450 if (t
== error_mark_node
)
7454 if (TREE_THIS_VOLATILE (t
))
7456 if (flags
& tf_error
)
7457 error ("expression %qE has side-effects", t
);
7460 if (CONSTANT_CLASS_P (t
))
7462 if (TREE_OVERFLOW (t
))
7464 if (flags
& tf_error
)
7466 permerror (EXPR_LOC_OR_HERE (t
),
7467 "overflow in constant expression");
7468 if (flag_permissive
)
7476 switch (TREE_CODE (t
))
7482 case TEMPLATE_ID_EXPR
:
7489 case TEMPLATE_PARM_INDEX
:
7491 case IDENTIFIER_NODE
:
7495 /* -- this (5.1) unless it appears as the postfix-expression in a
7496 class member access expression, including the result of the
7497 implicit transformation in the body of the non-static
7498 member function (9.3.1); */
7499 /* FIXME this restriction seems pointless since the standard dropped
7500 "potential constant expression". */
7501 if (is_this_parameter (t
))
7503 if (flags
& tf_error
)
7504 error ("%qE is not a potential constant expression", t
);
7509 case AGGR_INIT_EXPR
:
7511 /* -- an invocation of a function other than a constexpr function
7512 or a constexpr constructor. */
7514 tree fun
= get_function_named_in_call (t
);
7515 const int nargs
= call_expr_nargs (t
);
7518 if (is_overloaded_fn (fun
))
7520 if (TREE_CODE (fun
) == FUNCTION_DECL
)
7522 if (builtin_valid_in_constant_expr_p (fun
))
7524 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
7525 && !morally_constexpr_builtin_function_p (fun
))
7527 if (flags
& tf_error
)
7528 error ("%qD is not %<constexpr%>", fun
);
7531 /* A call to a non-static member function takes the address
7532 of the object as the first argument. But in a constant
7533 expression the address will be folded away, so look
7535 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
7536 && !DECL_CONSTRUCTOR_P (fun
))
7538 tree x
= get_nth_callarg (t
, 0);
7539 if (is_this_parameter (x
))
7541 else if (!potential_constant_expression_1 (x
, rval
, flags
))
7543 if (flags
& tf_error
)
7544 error ("object argument is not a potential "
7545 "constant expression");
7552 fun
= get_first_fn (fun
);
7553 /* Skip initial arguments to base constructors. */
7554 if (DECL_BASE_CONSTRUCTOR_P (fun
))
7555 i
= num_artificial_parms_for (fun
);
7556 fun
= DECL_ORIGIN (fun
);
7560 if (potential_constant_expression_1 (fun
, rval
, flags
))
7561 /* Might end up being a constant function pointer. */;
7564 if (flags
& tf_error
)
7565 error ("%qE is not a function name", fun
);
7569 for (; i
< nargs
; ++i
)
7571 tree x
= get_nth_callarg (t
, i
);
7572 if (!potential_constant_expression_1 (x
, rval
, flags
))
7574 if (flags
& tf_error
)
7575 error ("argument in position %qP is not a "
7576 "potential constant expression", i
);
7583 case NON_LVALUE_EXPR
:
7584 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
7585 -- an lvalue of integral type that refers to a non-volatile
7586 const variable or static data member initialized with
7587 constant expressions, or
7589 -- an lvalue of literal type that refers to non-volatile
7590 object defined with constexpr, or that refers to a
7591 sub-object of such an object; */
7592 return potential_constant_expression_1 (TREE_OPERAND (t
, 0), rval
, flags
);
7595 if (want_rval
&& !decl_constant_var_p (t
)
7596 && !dependent_type_p (TREE_TYPE (t
)))
7598 if (flags
& tf_error
)
7599 non_const_var_error (t
);
7606 case VIEW_CONVERT_EXPR
:
7607 /* -- an array-to-pointer conversion that is applied to an lvalue
7608 that designates an object with thread or automatic storage
7609 duration; FIXME not implemented as it breaks constexpr arrays;
7610 need to fix the standard
7611 -- a type conversion from a pointer or pointer-to-member type
7612 to a literal type. */
7614 tree from
= TREE_OPERAND (t
, 0);
7615 tree source
= TREE_TYPE (from
);
7616 tree target
= TREE_TYPE (t
);
7617 if (TYPE_PTR_P (source
) && ARITHMETIC_TYPE_P (target
)
7618 && !(TREE_CODE (from
) == COMPONENT_REF
7619 && TYPE_PTRMEMFUNC_P (TREE_TYPE (TREE_OPERAND (from
, 0)))))
7621 if (flags
& tf_error
)
7622 error ("conversion of expression %qE of pointer type "
7623 "cannot yield a constant expression", from
);
7626 return (potential_constant_expression_1
7627 (from
, TREE_CODE (t
) != VIEW_CONVERT_EXPR
, flags
));
7631 /* -- a unary operator & that is applied to an lvalue that
7632 designates an object with thread or automatic storage
7634 t
= TREE_OPERAND (t
, 0);
7636 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
7637 any checking here, as we might dereference the pointer later. If
7638 we remove this code, also remove check_automatic_or_tls. */
7639 i
= check_automatic_or_tls (t
);
7644 if (flags
& tf_error
)
7645 error ("address-of an object %qE with thread local or "
7646 "automatic storage is not a constant expression", t
);
7650 return potential_constant_expression_1 (t
, any
, flags
);
7656 /* -- a class member access unless its postfix-expression is
7657 of literal type or of pointer to literal type. */
7658 /* This test would be redundant, as it follows from the
7659 postfix-expression being a potential constant expression. */
7660 return potential_constant_expression_1 (TREE_OPERAND (t
, 0),
7663 case EXPR_PACK_EXPANSION
:
7664 return potential_constant_expression_1 (PACK_EXPANSION_PATTERN (t
),
7669 tree x
= TREE_OPERAND (t
, 0);
7671 if (is_this_parameter (x
))
7673 if (DECL_CONSTRUCTOR_P (DECL_CONTEXT (x
)) && want_rval
)
7675 if (flags
& tf_error
)
7676 sorry ("use of the value of the object being constructed "
7677 "in a constant expression");
7682 return potential_constant_expression_1 (x
, rval
, flags
);
7686 case DYNAMIC_CAST_EXPR
:
7687 case PSEUDO_DTOR_EXPR
:
7688 case PREINCREMENT_EXPR
:
7689 case POSTINCREMENT_EXPR
:
7690 case PREDECREMENT_EXPR
:
7691 case POSTDECREMENT_EXPR
:
7695 case VEC_DELETE_EXPR
:
7699 /* GCC internal stuff. */
7702 case WITH_CLEANUP_EXPR
:
7703 case CLEANUP_POINT_EXPR
:
7704 case MUST_NOT_THROW_EXPR
:
7705 case TRY_CATCH_EXPR
:
7706 case STATEMENT_LIST
:
7707 /* Don't bother trying to define a subset of statement-expressions to
7708 be constant-expressions, at least for now. */
7712 if (flags
& tf_error
)
7713 error ("expression %qE is not a constant-expression", t
);
7717 /* -- a typeid expression whose operand is of polymorphic
7720 tree e
= TREE_OPERAND (t
, 0);
7721 if (!TYPE_P (e
) && !type_dependent_expression_p (e
)
7722 && TYPE_POLYMORPHIC_P (TREE_TYPE (e
)))
7724 if (flags
& tf_error
)
7725 error ("typeid-expression is not a constant expression "
7726 "because %qE is of polymorphic type", e
);
7733 /* -- a subtraction where both operands are pointers. */
7734 if (TYPE_PTR_P (TREE_OPERAND (t
, 0))
7735 && TYPE_PTR_P (TREE_OPERAND (t
, 1)))
7737 if (flags
& tf_error
)
7738 error ("difference of two pointer expressions is not "
7739 "a constant expression");
7751 /* -- a relational or equality operator where at least
7752 one of the operands is a pointer. */
7753 if (TYPE_PTR_P (TREE_OPERAND (t
, 0))
7754 || TYPE_PTR_P (TREE_OPERAND (t
, 1)))
7756 if (flags
& tf_error
)
7757 error ("pointer comparison expression is not a "
7758 "constant expression");
7768 case FIX_TRUNC_EXPR
:
7773 case TRUTH_NOT_EXPR
:
7774 case FIXED_CONVERT_EXPR
:
7775 case UNARY_PLUS_EXPR
:
7776 return potential_constant_expression_1 (TREE_OPERAND (t
, 0), rval
,
7780 case CONST_CAST_EXPR
:
7781 case STATIC_CAST_EXPR
:
7782 case REINTERPRET_CAST_EXPR
:
7783 return (potential_constant_expression_1
7784 (TREE_OPERAND (t
, 0),
7785 TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
, flags
));
7788 case NON_DEPENDENT_EXPR
:
7789 /* For convenience. */
7791 return potential_constant_expression_1 (TREE_OPERAND (t
, 0),
7795 return potential_constant_expression_1 (TREE_OPERAND (t
, 1),
7800 return potential_constant_expression_1 (TREE_OPERAND (t
, 1),
7805 VEC(constructor_elt
, gc
) *v
= CONSTRUCTOR_ELTS (t
);
7806 constructor_elt
*ce
;
7807 for (i
= 0; VEC_iterate (constructor_elt
, v
, i
, ce
); ++i
)
7808 if (!potential_constant_expression_1 (ce
->value
, want_rval
, flags
))
7815 gcc_assert (TREE_PURPOSE (t
) == NULL_TREE
7816 || DECL_P (TREE_PURPOSE (t
)));
7817 if (!potential_constant_expression_1 (TREE_VALUE (t
), want_rval
,
7820 if (TREE_CHAIN (t
) == NULL_TREE
)
7822 return potential_constant_expression_1 (TREE_CHAIN (t
), want_rval
,
7826 case TRUNC_DIV_EXPR
:
7828 case FLOOR_DIV_EXPR
:
7829 case ROUND_DIV_EXPR
:
7830 case TRUNC_MOD_EXPR
:
7832 case ROUND_MOD_EXPR
:
7834 tree denom
= TREE_OPERAND (t
, 1);
7835 /* We can't call maybe_constant_value on an expression
7836 that hasn't been through fold_non_dependent_expr yet. */
7837 if (!processing_template_decl
)
7838 denom
= maybe_constant_value (denom
);
7839 if (integer_zerop (denom
))
7841 if (flags
& tf_error
)
7842 error ("division by zero is not a constant-expression");
7854 /* check_return_expr sometimes wraps a TARGET_EXPR in a
7855 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
7856 introduced by build_call_a. */
7857 tree op0
= TREE_OPERAND (t
, 0);
7858 tree op1
= TREE_OPERAND (t
, 1);
7860 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
7861 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
7862 return potential_constant_expression_1 (op0
, want_rval
, flags
);
7867 /* If the first operand is the non-short-circuit constant, look at
7868 the second operand; otherwise we only care about the first one for
7870 case TRUTH_AND_EXPR
:
7871 case TRUTH_ANDIF_EXPR
:
7872 tmp
= boolean_true_node
;
7875 case TRUTH_ORIF_EXPR
:
7876 tmp
= boolean_false_node
;
7878 if (TREE_OPERAND (t
, 0) == tmp
)
7879 return potential_constant_expression_1 (TREE_OPERAND (t
, 1), rval
, flags
);
7881 return potential_constant_expression_1 (TREE_OPERAND (t
, 0), rval
, flags
);
7885 case POINTER_PLUS_EXPR
:
7887 case EXACT_DIV_EXPR
:
7897 case TRUTH_XOR_EXPR
:
7898 case UNORDERED_EXPR
:
7910 case ARRAY_RANGE_REF
:
7914 for (i
= 0; i
< 2; ++i
)
7915 if (!potential_constant_expression_1 (TREE_OPERAND (t
, i
),
7922 /* If the condition is a known constant, we know which of the legs we
7923 care about; otherwise we only require that the condition and
7924 either of the legs be potentially constant. */
7925 tmp
= TREE_OPERAND (t
, 0);
7926 if (!potential_constant_expression_1 (tmp
, rval
, flags
))
7928 else if (integer_zerop (tmp
))
7929 return potential_constant_expression_1 (TREE_OPERAND (t
, 2),
7931 else if (TREE_CODE (tmp
) == INTEGER_CST
)
7932 return potential_constant_expression_1 (TREE_OPERAND (t
, 1),
7934 for (i
= 1; i
< 3; ++i
)
7935 if (potential_constant_expression_1 (TREE_OPERAND (t
, i
),
7936 want_rval
, tf_none
))
7938 if (flags
& tf_error
)
7939 error ("expression %qE is not a constant-expression", t
);
7943 if (VEC_INIT_EXPR_IS_CONSTEXPR (t
))
7945 if (flags
& tf_error
)
7947 error ("non-constant array initialization");
7948 diagnose_non_constexpr_vec_init (t
);
7953 sorry ("unexpected ast of kind %s", tree_code_name
[TREE_CODE (t
)]);
7959 /* The main entry point to the above. */
7962 potential_constant_expression (tree t
)
7964 return potential_constant_expression_1 (t
, false, tf_none
);
7967 /* As above, but require a constant rvalue. */
7970 potential_rvalue_constant_expression (tree t
)
7972 return potential_constant_expression_1 (t
, true, tf_none
);
7975 /* Like above, but complain about non-constant expressions. */
7978 require_potential_constant_expression (tree t
)
7980 return potential_constant_expression_1 (t
, false, tf_warning_or_error
);
7983 /* Cross product of the above. */
7986 require_potential_rvalue_constant_expression (tree t
)
7988 return potential_constant_expression_1 (t
, true, tf_warning_or_error
);
7991 /* Constructor for a lambda expression. */
7994 build_lambda_expr (void)
7996 tree lambda
= make_node (LAMBDA_EXPR
);
7997 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda
) = CPLD_NONE
;
7998 LAMBDA_EXPR_CAPTURE_LIST (lambda
) = NULL_TREE
;
7999 LAMBDA_EXPR_THIS_CAPTURE (lambda
) = NULL_TREE
;
8000 LAMBDA_EXPR_RETURN_TYPE (lambda
) = NULL_TREE
;
8001 LAMBDA_EXPR_MUTABLE_P (lambda
) = false;
8005 /* Create the closure object for a LAMBDA_EXPR. */
8008 build_lambda_object (tree lambda_expr
)
8010 /* Build aggregate constructor call.
8011 - cp_parser_braced_list
8012 - cp_parser_functional_cast */
8013 VEC(constructor_elt
,gc
) *elts
= NULL
;
8014 tree node
, expr
, type
;
8015 location_t saved_loc
;
8017 if (processing_template_decl
)
8020 /* Make sure any error messages refer to the lambda-introducer. */
8021 saved_loc
= input_location
;
8022 input_location
= LAMBDA_EXPR_LOCATION (lambda_expr
);
8024 for (node
= LAMBDA_EXPR_CAPTURE_LIST (lambda_expr
);
8026 node
= TREE_CHAIN (node
))
8028 tree field
= TREE_PURPOSE (node
);
8029 tree val
= TREE_VALUE (node
);
8031 if (field
== error_mark_node
)
8033 expr
= error_mark_node
;
8040 /* Mere mortals can't copy arrays with aggregate initialization, so
8041 do some magic to make it work here. */
8042 if (TREE_CODE (TREE_TYPE (field
)) == ARRAY_TYPE
)
8043 val
= build_array_copy (val
);
8044 else if (DECL_NORMAL_CAPTURE_P (field
)
8045 && TREE_CODE (TREE_TYPE (field
)) != REFERENCE_TYPE
)
8047 /* "the entities that are captured by copy are used to
8048 direct-initialize each corresponding non-static data
8049 member of the resulting closure object."
8051 There's normally no way to express direct-initialization
8052 from an element of a CONSTRUCTOR, so we build up a special
8053 TARGET_EXPR to bypass the usual copy-initialization. */
8054 val
= force_rvalue (val
, tf_warning_or_error
);
8055 if (TREE_CODE (val
) == TARGET_EXPR
)
8056 TARGET_EXPR_DIRECT_INIT_P (val
) = true;
8059 CONSTRUCTOR_APPEND_ELT (elts
, DECL_NAME (field
), val
);
8062 expr
= build_constructor (init_list_type_node
, elts
);
8063 CONSTRUCTOR_IS_DIRECT_INIT (expr
) = 1;
8065 /* N2927: "[The closure] class type is not an aggregate."
8066 But we briefly treat it as an aggregate to make this simpler. */
8067 type
= TREE_TYPE (lambda_expr
);
8068 CLASSTYPE_NON_AGGREGATE (type
) = 0;
8069 expr
= finish_compound_literal (type
, expr
, tf_warning_or_error
);
8070 CLASSTYPE_NON_AGGREGATE (type
) = 1;
8073 input_location
= saved_loc
;
8077 /* Return an initialized RECORD_TYPE for LAMBDA.
8078 LAMBDA must have its explicit captures already. */
8081 begin_lambda_type (tree lambda
)
8086 /* Unique name. This is just like an unnamed class, but we cannot use
8087 make_anon_name because of certain checks against TYPE_ANONYMOUS_P. */
8089 name
= make_lambda_name ();
8091 /* Create the new RECORD_TYPE for this lambda. */
8092 type
= xref_tag (/*tag_code=*/record_type
,
8094 /*scope=*/ts_within_enclosing_non_class
,
8095 /*template_header_p=*/false);
8098 /* Designate it as a struct so that we can use aggregate initialization. */
8099 CLASSTYPE_DECLARED_CLASS (type
) = false;
8101 /* Clear base types. */
8102 xref_basetypes (type
, /*bases=*/NULL_TREE
);
8104 /* Start the class. */
8105 type
= begin_class_definition (type
, /*attributes=*/NULL_TREE
);
8107 /* Cross-reference the expression and the type. */
8108 TREE_TYPE (lambda
) = type
;
8109 CLASSTYPE_LAMBDA_EXPR (type
) = lambda
;
8114 /* Returns the type to use for the return type of the operator() of a
8118 lambda_return_type (tree expr
)
8121 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
8123 warning (0, "cannot deduce lambda return type from a braced-init-list");
8124 return void_type_node
;
8126 if (type_dependent_expression_p (expr
))
8128 type
= cxx_make_type (DECLTYPE_TYPE
);
8129 DECLTYPE_TYPE_EXPR (type
) = expr
;
8130 DECLTYPE_FOR_LAMBDA_RETURN (type
) = true;
8131 SET_TYPE_STRUCTURAL_EQUALITY (type
);
8134 type
= type_decays_to (unlowered_expr_type (expr
));
8138 /* Given a LAMBDA_EXPR or closure type LAMBDA, return the op() of the
8142 lambda_function (tree lambda
)
8145 if (TREE_CODE (lambda
) == LAMBDA_EXPR
)
8146 type
= TREE_TYPE (lambda
);
8149 gcc_assert (LAMBDA_TYPE_P (type
));
8150 /* Don't let debug_tree cause instantiation. */
8151 if (CLASSTYPE_TEMPLATE_INSTANTIATION (type
)
8152 && !COMPLETE_OR_OPEN_TYPE_P (type
))
8154 lambda
= lookup_member (type
, ansi_opname (CALL_EXPR
),
8155 /*protect=*/0, /*want_type=*/false);
8157 lambda
= BASELINK_FUNCTIONS (lambda
);
8161 /* Returns the type to use for the FIELD_DECL corresponding to the
8163 The caller should add REFERENCE_TYPE for capture by reference. */
8166 lambda_capture_field_type (tree expr
)
8169 if (type_dependent_expression_p (expr
))
8171 type
= cxx_make_type (DECLTYPE_TYPE
);
8172 DECLTYPE_TYPE_EXPR (type
) = expr
;
8173 DECLTYPE_FOR_LAMBDA_CAPTURE (type
) = true;
8174 SET_TYPE_STRUCTURAL_EQUALITY (type
);
8177 type
= non_reference (unlowered_expr_type (expr
));
8181 /* Recompute the return type for LAMBDA with body of the form:
8182 { return EXPR ; } */
8185 apply_lambda_return_type (tree lambda
, tree return_type
)
8187 tree fco
= lambda_function (lambda
);
8190 LAMBDA_EXPR_RETURN_TYPE (lambda
) = return_type
;
8192 /* If we got a DECLTYPE_TYPE, don't stick it in the function yet,
8193 it would interfere with instantiating the closure type. */
8194 if (dependent_type_p (return_type
))
8196 if (return_type
== error_mark_node
)
8199 /* TREE_TYPE (FUNCTION_DECL) == METHOD_TYPE
8200 TREE_TYPE (METHOD_TYPE) == return-type */
8201 TREE_TYPE (fco
) = change_return_type (return_type
, TREE_TYPE (fco
));
8203 result
= DECL_RESULT (fco
);
8204 if (result
== NULL_TREE
)
8207 /* We already have a DECL_RESULT from start_preparsed_function.
8208 Now we need to redo the work it and allocate_struct_function
8209 did to reflect the new type. */
8210 result
= build_decl (input_location
, RESULT_DECL
, NULL_TREE
,
8211 TYPE_MAIN_VARIANT (return_type
));
8212 DECL_ARTIFICIAL (result
) = 1;
8213 DECL_IGNORED_P (result
) = 1;
8214 cp_apply_type_quals_to_decl (cp_type_quals (return_type
),
8217 DECL_RESULT (fco
) = result
;
8219 if (!processing_template_decl
&& aggregate_value_p (result
, fco
))
8221 #ifdef PCC_STATIC_STRUCT_RETURN
8222 cfun
->returns_pcc_struct
= 1;
8224 cfun
->returns_struct
= 1;
8229 /* DECL is a local variable or parameter from the surrounding scope of a
8230 lambda-expression. Returns the decltype for a use of the capture field
8231 for DECL even if it hasn't been captured yet. */
8234 capture_decltype (tree decl
)
8236 tree lam
= CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (current_function_decl
));
8237 /* FIXME do lookup instead of list walk? */
8238 tree cap
= value_member (decl
, LAMBDA_EXPR_CAPTURE_LIST (lam
));
8242 type
= TREE_TYPE (TREE_PURPOSE (cap
));
8244 switch (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lam
))
8247 error ("%qD is not captured", decl
);
8248 return error_mark_node
;
8251 type
= TREE_TYPE (decl
);
8252 if (TREE_CODE (type
) == REFERENCE_TYPE
8253 && TREE_CODE (TREE_TYPE (type
)) != FUNCTION_TYPE
)
8254 type
= TREE_TYPE (type
);
8257 case CPLD_REFERENCE
:
8258 type
= TREE_TYPE (decl
);
8259 if (TREE_CODE (type
) != REFERENCE_TYPE
)
8260 type
= build_reference_type (TREE_TYPE (decl
));
8267 if (TREE_CODE (type
) != REFERENCE_TYPE
)
8269 if (!LAMBDA_EXPR_MUTABLE_P (lam
))
8270 type
= cp_build_qualified_type (type
, (cp_type_quals (type
)
8272 type
= build_reference_type (type
);
8277 /* From an ID and INITIALIZER, create a capture (by reference if
8278 BY_REFERENCE_P is true), add it to the capture-list for LAMBDA,
8282 add_capture (tree lambda
, tree id
, tree initializer
, bool by_reference_p
,
8283 bool explicit_init_p
)
8288 type
= lambda_capture_field_type (initializer
);
8291 type
= build_reference_type (type
);
8292 if (!real_lvalue_p (initializer
))
8293 error ("cannot capture %qE by reference", initializer
);
8296 /* Make member variable. */
8297 member
= build_lang_decl (FIELD_DECL
, id
, type
);
8298 if (!explicit_init_p
)
8299 /* Normal captures are invisible to name lookup but uses are replaced
8300 with references to the capture field; we implement this by only
8301 really making them invisible in unevaluated context; see
8302 qualify_lookup. For now, let's make explicitly initialized captures
8304 DECL_NORMAL_CAPTURE_P (member
) = true;
8306 /* Add it to the appropriate closure class if we've started it. */
8307 if (current_class_type
&& current_class_type
== TREE_TYPE (lambda
))
8308 finish_member_declaration (member
);
8310 LAMBDA_EXPR_CAPTURE_LIST (lambda
)
8311 = tree_cons (member
, initializer
, LAMBDA_EXPR_CAPTURE_LIST (lambda
));
8313 if (id
== get_identifier ("__this"))
8315 if (LAMBDA_EXPR_CAPTURES_THIS_P (lambda
))
8316 error ("already captured %<this%> in lambda expression");
8317 LAMBDA_EXPR_THIS_CAPTURE (lambda
) = member
;
8323 /* Register all the capture members on the list CAPTURES, which is the
8324 LAMBDA_EXPR_CAPTURE_LIST for the lambda after the introducer. */
8326 void register_capture_members (tree captures
)
8330 register_capture_members (TREE_CHAIN (captures
));
8331 finish_member_declaration (TREE_PURPOSE (captures
));
8335 /* Given a FIELD_DECL decl belonging to a closure type, return a
8336 COMPONENT_REF of it relative to the 'this' parameter of the op() for
8340 thisify_lambda_field (tree decl
)
8342 tree context
= lambda_function (DECL_CONTEXT (decl
));
8343 tree object
= cp_build_indirect_ref (DECL_ARGUMENTS (context
),
8345 tf_warning_or_error
);
8346 return finish_non_static_data_member (decl
, object
,
8347 /*qualifying_scope*/NULL_TREE
);
8350 /* Similar to add_capture, except this works on a stack of nested lambdas.
8351 BY_REFERENCE_P in this case is derived from the default capture mode.
8352 Returns the capture for the lambda at the bottom of the stack. */
8355 add_default_capture (tree lambda_stack
, tree id
, tree initializer
)
8357 bool this_capture_p
= (id
== get_identifier ("__this"));
8359 tree member
= NULL_TREE
;
8361 tree saved_class_type
= current_class_type
;
8365 for (node
= lambda_stack
;
8367 node
= TREE_CHAIN (node
))
8369 tree lambda
= TREE_VALUE (node
);
8371 current_class_type
= TREE_TYPE (lambda
);
8372 member
= add_capture (lambda
,
8377 && (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda
)
8378 == CPLD_REFERENCE
)),
8379 /*explicit_init_p=*/false);
8380 initializer
= thisify_lambda_field (member
);
8383 current_class_type
= saved_class_type
;
8388 /* Return the capture pertaining to a use of 'this' in LAMBDA, in the form of an
8389 INDIRECT_REF, possibly adding it through default capturing. */
8392 lambda_expr_this_capture (tree lambda
)
8396 tree this_capture
= LAMBDA_EXPR_THIS_CAPTURE (lambda
);
8398 /* Try to default capture 'this' if we can. */
8400 && LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda
) != CPLD_NONE
)
8402 tree containing_function
= TYPE_CONTEXT (TREE_TYPE (lambda
));
8403 tree lambda_stack
= tree_cons (NULL_TREE
, lambda
, NULL_TREE
);
8404 tree init
= NULL_TREE
;
8406 /* If we are in a lambda function, we can move out until we hit:
8407 1. a non-lambda function,
8408 2. a lambda function capturing 'this', or
8409 3. a non-default capturing lambda function. */
8410 while (LAMBDA_FUNCTION_P (containing_function
))
8413 = CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (containing_function
));
8415 if (LAMBDA_EXPR_THIS_CAPTURE (lambda
))
8417 /* An outer lambda has already captured 'this'. */
8418 tree cap
= LAMBDA_EXPR_THIS_CAPTURE (lambda
);
8419 init
= thisify_lambda_field (cap
);
8423 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda
) == CPLD_NONE
)
8424 /* An outer lambda won't let us capture 'this'. */
8427 lambda_stack
= tree_cons (NULL_TREE
,
8431 containing_function
= decl_function_context (containing_function
);
8434 if (!init
&& DECL_NONSTATIC_MEMBER_FUNCTION_P (containing_function
)
8435 && !LAMBDA_FUNCTION_P (containing_function
))
8436 /* First parameter is 'this'. */
8437 init
= DECL_ARGUMENTS (containing_function
);
8440 this_capture
= add_default_capture (lambda_stack
,
8441 /*id=*/get_identifier ("__this"),
8447 error ("%<this%> was not captured for this lambda function");
8448 result
= error_mark_node
;
8452 /* To make sure that current_class_ref is for the lambda. */
8453 gcc_assert (TYPE_MAIN_VARIANT (TREE_TYPE (current_class_ref
)) == TREE_TYPE (lambda
));
8455 result
= finish_non_static_data_member (this_capture
,
8457 /*qualifying_scope=*/NULL_TREE
);
8459 /* If 'this' is captured, each use of 'this' is transformed into an
8460 access to the corresponding unnamed data member of the closure
8461 type cast (_expr.cast_ 5.4) to the type of 'this'. [ The cast
8462 ensures that the transformed expression is an rvalue. ] */
8463 result
= rvalue (result
);
8469 /* Returns the method basetype of the innermost non-lambda function, or
8470 NULL_TREE if none. */
8473 nonlambda_method_basetype (void)
8476 if (!current_class_ref
)
8479 type
= current_class_type
;
8480 if (!LAMBDA_TYPE_P (type
))
8483 /* Find the nearest enclosing non-lambda function. */
8484 fn
= TYPE_NAME (type
);
8486 fn
= decl_function_context (fn
);
8487 while (fn
&& LAMBDA_FUNCTION_P (fn
));
8489 if (!fn
|| !DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
8492 return TYPE_METHOD_BASETYPE (TREE_TYPE (fn
));
8495 /* If the closure TYPE has a static op(), also add a conversion to function
8499 maybe_add_lambda_conv_op (tree type
)
8501 bool nested
= (current_function_decl
!= NULL_TREE
);
8502 tree callop
= lambda_function (type
);
8503 tree rettype
, name
, fntype
, fn
, body
, compound_stmt
;
8504 tree thistype
, stattype
, statfn
, convfn
, call
, arg
;
8505 VEC (tree
, gc
) *argvec
;
8507 if (LAMBDA_EXPR_CAPTURE_LIST (CLASSTYPE_LAMBDA_EXPR (type
)) != NULL_TREE
)
8510 stattype
= build_function_type (TREE_TYPE (TREE_TYPE (callop
)),
8511 FUNCTION_ARG_CHAIN (callop
));
8513 /* First build up the conversion op. */
8515 rettype
= build_pointer_type (stattype
);
8516 name
= mangle_conv_op_name_for_type (rettype
);
8517 thistype
= cp_build_qualified_type (type
, TYPE_QUAL_CONST
);
8518 fntype
= build_method_type_directly (thistype
, rettype
, void_list_node
);
8519 fn
= convfn
= build_lang_decl (FUNCTION_DECL
, name
, fntype
);
8520 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (callop
);
8522 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
8523 && DECL_ALIGN (fn
) < 2 * BITS_PER_UNIT
)
8524 DECL_ALIGN (fn
) = 2 * BITS_PER_UNIT
;
8526 SET_OVERLOADED_OPERATOR_CODE (fn
, TYPE_EXPR
);
8527 grokclassfn (type
, fn
, NO_SPECIAL
);
8528 set_linkage_according_to_type (type
, fn
);
8529 rest_of_decl_compilation (fn
, toplevel_bindings_p (), at_eof
);
8530 DECL_IN_AGGR_P (fn
) = 1;
8531 DECL_ARTIFICIAL (fn
) = 1;
8532 DECL_NOT_REALLY_EXTERN (fn
) = 1;
8533 DECL_DECLARED_INLINE_P (fn
) = 1;
8534 DECL_ARGUMENTS (fn
) = build_this_parm (fntype
, TYPE_QUAL_CONST
);
8536 DECL_INTERFACE_KNOWN (fn
) = 1;
8538 add_method (type
, fn
, NULL_TREE
);
8540 /* Generic thunk code fails for varargs; we'll complain in mark_used if
8541 the conversion op is used. */
8542 if (varargs_function_p (callop
))
8544 DECL_DELETED_FN (fn
) = 1;
8548 /* Now build up the thunk to be returned. */
8550 name
= get_identifier ("_FUN");
8551 fn
= statfn
= build_lang_decl (FUNCTION_DECL
, name
, stattype
);
8552 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (callop
);
8553 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
8554 && DECL_ALIGN (fn
) < 2 * BITS_PER_UNIT
)
8555 DECL_ALIGN (fn
) = 2 * BITS_PER_UNIT
;
8556 grokclassfn (type
, fn
, NO_SPECIAL
);
8557 set_linkage_according_to_type (type
, fn
);
8558 rest_of_decl_compilation (fn
, toplevel_bindings_p (), at_eof
);
8559 DECL_IN_AGGR_P (fn
) = 1;
8560 DECL_ARTIFICIAL (fn
) = 1;
8561 DECL_NOT_REALLY_EXTERN (fn
) = 1;
8562 DECL_DECLARED_INLINE_P (fn
) = 1;
8563 DECL_STATIC_FUNCTION_P (fn
) = 1;
8564 DECL_ARGUMENTS (fn
) = copy_list (DECL_CHAIN (DECL_ARGUMENTS (callop
)));
8565 for (arg
= DECL_ARGUMENTS (fn
); arg
; arg
= DECL_CHAIN (arg
))
8566 DECL_CONTEXT (arg
) = fn
;
8568 DECL_INTERFACE_KNOWN (fn
) = 1;
8570 add_method (type
, fn
, NULL_TREE
);
8573 push_function_context ();
8575 /* Generate the body of the thunk. */
8577 start_preparsed_function (statfn
, NULL_TREE
,
8578 SF_PRE_PARSED
| SF_INCLASS_INLINE
);
8579 if (DECL_ONE_ONLY (statfn
))
8581 /* Put the thunk in the same comdat group as the call op. */
8582 struct cgraph_node
*callop_node
, *thunk_node
;
8583 DECL_COMDAT_GROUP (statfn
) = cxx_comdat_group (callop
);
8584 callop_node
= cgraph_get_create_node (callop
);
8585 thunk_node
= cgraph_get_create_node (statfn
);
8586 gcc_assert (callop_node
->same_comdat_group
== NULL
);
8587 gcc_assert (thunk_node
->same_comdat_group
== NULL
);
8588 callop_node
->same_comdat_group
= thunk_node
;
8589 thunk_node
->same_comdat_group
= callop_node
;
8591 body
= begin_function_body ();
8592 compound_stmt
= begin_compound_stmt (0);
8594 arg
= build1 (NOP_EXPR
, TREE_TYPE (DECL_ARGUMENTS (callop
)),
8596 argvec
= make_tree_vector ();
8597 VEC_quick_push (tree
, argvec
, arg
);
8598 for (arg
= DECL_ARGUMENTS (statfn
); arg
; arg
= DECL_CHAIN (arg
))
8599 VEC_safe_push (tree
, gc
, argvec
, arg
);
8600 call
= build_call_a (callop
, VEC_length (tree
, argvec
),
8601 VEC_address (tree
, argvec
));
8602 CALL_FROM_THUNK_P (call
) = 1;
8603 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (call
)))
8604 call
= build_cplus_new (TREE_TYPE (call
), call
, tf_warning_or_error
);
8605 call
= convert_from_reference (call
);
8606 finish_return_stmt (call
);
8608 finish_compound_stmt (compound_stmt
);
8609 finish_function_body (body
);
8611 expand_or_defer_fn (finish_function (2));
8613 /* Generate the body of the conversion op. */
8615 start_preparsed_function (convfn
, NULL_TREE
,
8616 SF_PRE_PARSED
| SF_INCLASS_INLINE
);
8617 body
= begin_function_body ();
8618 compound_stmt
= begin_compound_stmt (0);
8620 finish_return_stmt (decay_conversion (statfn
));
8622 finish_compound_stmt (compound_stmt
);
8623 finish_function_body (body
);
8625 expand_or_defer_fn (finish_function (2));
8628 pop_function_context ();
8630 #include "gt-cp-semantics.h"