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, 2012 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"
40 #include "diagnostic.h"
42 #include "tree-iterator.h"
48 /* There routines provide a modular interface to perform many parsing
49 operations. They may therefore be used during actual parsing, or
50 during template instantiation, which may be regarded as a
51 degenerate form of parsing. */
53 static tree
maybe_convert_cond (tree
);
54 static tree
finalize_nrv_r (tree
*, int *, void *);
55 static tree
capture_decltype (tree
);
58 /* Deferred Access Checking Overview
59 ---------------------------------
61 Most C++ expressions and declarations require access checking
62 to be performed during parsing. However, in several cases,
63 this has to be treated differently.
65 For member declarations, access checking has to be deferred
66 until more information about the declaration is known. For
78 When we are parsing the function return type `A::X', we don't
79 really know if this is allowed until we parse the function name.
81 Furthermore, some contexts require that access checking is
82 never performed at all. These include class heads, and template
85 Typical use of access checking functions is described here:
87 1. When we enter a context that requires certain access checking
88 mode, the function `push_deferring_access_checks' is called with
89 DEFERRING argument specifying the desired mode. Access checking
90 may be performed immediately (dk_no_deferred), deferred
91 (dk_deferred), or not performed (dk_no_check).
93 2. When a declaration such as a type, or a variable, is encountered,
94 the function `perform_or_defer_access_check' is called. It
95 maintains a VEC of all deferred checks.
97 3. The global `current_class_type' or `current_function_decl' is then
98 setup by the parser. `enforce_access' relies on these information
101 4. Upon exiting the context mentioned in step 1,
102 `perform_deferred_access_checks' is called to check all declaration
103 stored in the VEC. `pop_deferring_access_checks' is then
104 called to restore the previous access checking mode.
106 In case of parsing error, we simply call `pop_deferring_access_checks'
107 without `perform_deferred_access_checks'. */
109 typedef struct GTY(()) deferred_access
{
110 /* A VEC representing name-lookups for which we have deferred
111 checking access controls. We cannot check the accessibility of
112 names used in a decl-specifier-seq until we know what is being
113 declared because code like:
120 A::B* A::f() { return 0; }
122 is valid, even though `A::B' is not generally accessible. */
123 VEC (deferred_access_check
,gc
)* GTY(()) deferred_access_checks
;
125 /* The current mode of access checks. */
126 enum deferring_kind deferring_access_checks_kind
;
129 DEF_VEC_O (deferred_access
);
130 DEF_VEC_ALLOC_O (deferred_access
,gc
);
132 /* Data for deferred access checking. */
133 static GTY(()) VEC(deferred_access
,gc
) *deferred_access_stack
;
134 static GTY(()) unsigned deferred_access_no_check
;
136 /* Save the current deferred access states and start deferred
137 access checking iff DEFER_P is true. */
140 push_deferring_access_checks (deferring_kind deferring
)
142 /* For context like template instantiation, access checking
143 disabling applies to all nested context. */
144 if (deferred_access_no_check
|| deferring
== dk_no_check
)
145 deferred_access_no_check
++;
148 deferred_access
*ptr
;
150 ptr
= VEC_safe_push (deferred_access
, gc
, deferred_access_stack
, NULL
);
151 ptr
->deferred_access_checks
= NULL
;
152 ptr
->deferring_access_checks_kind
= deferring
;
156 /* Resume deferring access checks again after we stopped doing
160 resume_deferring_access_checks (void)
162 if (!deferred_access_no_check
)
163 VEC_last (deferred_access
, deferred_access_stack
)
164 ->deferring_access_checks_kind
= dk_deferred
;
167 /* Stop deferring access checks. */
170 stop_deferring_access_checks (void)
172 if (!deferred_access_no_check
)
173 VEC_last (deferred_access
, deferred_access_stack
)
174 ->deferring_access_checks_kind
= dk_no_deferred
;
177 /* Discard the current deferred access checks and restore the
181 pop_deferring_access_checks (void)
183 if (deferred_access_no_check
)
184 deferred_access_no_check
--;
186 VEC_pop (deferred_access
, deferred_access_stack
);
189 /* Returns a TREE_LIST representing the deferred checks.
190 The TREE_PURPOSE of each node is the type through which the
191 access occurred; the TREE_VALUE is the declaration named.
194 VEC (deferred_access_check
,gc
)*
195 get_deferred_access_checks (void)
197 if (deferred_access_no_check
)
200 return (VEC_last (deferred_access
, deferred_access_stack
)
201 ->deferred_access_checks
);
204 /* Take current deferred checks and combine with the
205 previous states if we also defer checks previously.
206 Otherwise perform checks now. */
209 pop_to_parent_deferring_access_checks (void)
211 if (deferred_access_no_check
)
212 deferred_access_no_check
--;
215 VEC (deferred_access_check
,gc
) *checks
;
216 deferred_access
*ptr
;
218 checks
= (VEC_last (deferred_access
, deferred_access_stack
)
219 ->deferred_access_checks
);
221 VEC_pop (deferred_access
, deferred_access_stack
);
222 ptr
= VEC_last (deferred_access
, deferred_access_stack
);
223 if (ptr
->deferring_access_checks_kind
== dk_no_deferred
)
226 perform_access_checks (checks
);
230 /* Merge with parent. */
232 deferred_access_check
*chk
, *probe
;
234 FOR_EACH_VEC_ELT (deferred_access_check
, checks
, i
, chk
)
236 FOR_EACH_VEC_ELT (deferred_access_check
,
237 ptr
->deferred_access_checks
, j
, probe
)
239 if (probe
->binfo
== chk
->binfo
&&
240 probe
->decl
== chk
->decl
&&
241 probe
->diag_decl
== chk
->diag_decl
)
244 /* Insert into parent's checks. */
245 VEC_safe_push (deferred_access_check
, gc
,
246 ptr
->deferred_access_checks
, chk
);
253 /* Perform the access checks in CHECKS. The TREE_PURPOSE of each node
254 is the BINFO indicating the qualifying scope used to access the
255 DECL node stored in the TREE_VALUE of the node. */
258 perform_access_checks (VEC (deferred_access_check
,gc
)* checks
)
261 deferred_access_check
*chk
;
262 location_t loc
= input_location
;
267 FOR_EACH_VEC_ELT (deferred_access_check
, checks
, i
, chk
)
269 input_location
= chk
->loc
;
270 enforce_access (chk
->binfo
, chk
->decl
, chk
->diag_decl
);
273 input_location
= loc
;
276 /* Perform the deferred access checks.
278 After performing the checks, we still have to keep the list
279 `deferred_access_stack->deferred_access_checks' since we may want
280 to check access for them again later in a different context.
287 A::X A::a, x; // No error for `A::a', error for `x'
289 We have to perform deferred access of `A::X', first with `A::a',
293 perform_deferred_access_checks (void)
295 perform_access_checks (get_deferred_access_checks ());
298 /* Defer checking the accessibility of DECL, when looked up in
299 BINFO. DIAG_DECL is the declaration to use to print diagnostics. */
302 perform_or_defer_access_check (tree binfo
, tree decl
, tree diag_decl
)
305 deferred_access
*ptr
;
306 deferred_access_check
*chk
;
307 deferred_access_check
*new_access
;
310 /* Exit if we are in a context that no access checking is performed.
312 if (deferred_access_no_check
)
315 gcc_assert (TREE_CODE (binfo
) == TREE_BINFO
);
317 ptr
= VEC_last (deferred_access
, deferred_access_stack
);
319 /* If we are not supposed to defer access checks, just check now. */
320 if (ptr
->deferring_access_checks_kind
== dk_no_deferred
)
322 enforce_access (binfo
, decl
, diag_decl
);
326 /* See if we are already going to perform this check. */
327 FOR_EACH_VEC_ELT (deferred_access_check
,
328 ptr
->deferred_access_checks
, i
, chk
)
330 if (chk
->decl
== decl
&& chk
->binfo
== binfo
&&
331 chk
->diag_decl
== diag_decl
)
336 /* If not, record the check. */
338 VEC_safe_push (deferred_access_check
, gc
,
339 ptr
->deferred_access_checks
, 0);
340 new_access
->binfo
= binfo
;
341 new_access
->decl
= decl
;
342 new_access
->diag_decl
= diag_decl
;
343 new_access
->loc
= input_location
;
346 /* Used by build_over_call in LOOKUP_SPECULATIVE mode: return whether DECL
347 is accessible in BINFO, and possibly complain if not. If we're not
348 checking access, everything is accessible. */
351 speculative_access_check (tree binfo
, tree decl
, tree diag_decl
,
354 if (deferred_access_no_check
)
357 /* If we're checking for implicit delete, we don't want access
359 if (!accessible_p (binfo
, decl
, true))
361 /* Unless we're under maybe_explain_implicit_delete. */
363 enforce_access (binfo
, decl
, diag_decl
);
370 /* Returns nonzero if the current statement is a full expression,
371 i.e. temporaries created during that statement should be destroyed
372 at the end of the statement. */
375 stmts_are_full_exprs_p (void)
377 return current_stmt_tree ()->stmts_are_full_exprs_p
;
380 /* T is a statement. Add it to the statement-tree. This is the C++
381 version. The C/ObjC frontends have a slightly different version of
387 enum tree_code code
= TREE_CODE (t
);
389 if (EXPR_P (t
) && code
!= LABEL_EXPR
)
391 if (!EXPR_HAS_LOCATION (t
))
392 SET_EXPR_LOCATION (t
, input_location
);
394 /* When we expand a statement-tree, we must know whether or not the
395 statements are full-expressions. We record that fact here. */
396 STMT_IS_FULL_EXPR_P (t
) = stmts_are_full_exprs_p ();
399 /* Add T to the statement-tree. Non-side-effect statements need to be
400 recorded during statement expressions. */
401 gcc_checking_assert (!VEC_empty (tree
, stmt_list_stack
));
402 append_to_statement_list_force (t
, &cur_stmt_list
);
407 /* Returns the stmt_tree to which statements are currently being added. */
410 current_stmt_tree (void)
413 ? &cfun
->language
->base
.x_stmt_tree
414 : &scope_chain
->x_stmt_tree
);
417 /* If statements are full expressions, wrap STMT in a CLEANUP_POINT_EXPR. */
420 maybe_cleanup_point_expr (tree expr
)
422 if (!processing_template_decl
&& stmts_are_full_exprs_p ())
423 expr
= fold_build_cleanup_point_expr (TREE_TYPE (expr
), expr
);
427 /* Like maybe_cleanup_point_expr except have the type of the new expression be
428 void so we don't need to create a temporary variable to hold the inner
429 expression. The reason why we do this is because the original type might be
430 an aggregate and we cannot create a temporary variable for that type. */
433 maybe_cleanup_point_expr_void (tree expr
)
435 if (!processing_template_decl
&& stmts_are_full_exprs_p ())
436 expr
= fold_build_cleanup_point_expr (void_type_node
, expr
);
442 /* Create a declaration statement for the declaration given by the DECL. */
445 add_decl_expr (tree decl
)
447 tree r
= build_stmt (input_location
, DECL_EXPR
, decl
);
448 if (DECL_INITIAL (decl
)
449 || (DECL_SIZE (decl
) && TREE_SIDE_EFFECTS (DECL_SIZE (decl
))))
450 r
= maybe_cleanup_point_expr_void (r
);
454 /* Finish a scope. */
457 do_poplevel (tree stmt_list
)
461 if (stmts_are_full_exprs_p ())
462 block
= poplevel (kept_level_p (), 1, 0);
464 stmt_list
= pop_stmt_list (stmt_list
);
466 if (!processing_template_decl
)
468 stmt_list
= c_build_bind_expr (input_location
, block
, stmt_list
);
469 /* ??? See c_end_compound_stmt re statement expressions. */
475 /* Begin a new scope. */
478 do_pushlevel (scope_kind sk
)
480 tree ret
= push_stmt_list ();
481 if (stmts_are_full_exprs_p ())
482 begin_scope (sk
, NULL
);
486 /* Queue a cleanup. CLEANUP is an expression/statement to be executed
487 when the current scope is exited. EH_ONLY is true when this is not
488 meant to apply to normal control flow transfer. */
491 push_cleanup (tree decl
, tree cleanup
, bool eh_only
)
493 tree stmt
= build_stmt (input_location
, CLEANUP_STMT
, NULL
, cleanup
, decl
);
494 CLEANUP_EH_ONLY (stmt
) = eh_only
;
496 CLEANUP_BODY (stmt
) = push_stmt_list ();
499 /* Begin a conditional that might contain a declaration. When generating
500 normal code, we want the declaration to appear before the statement
501 containing the conditional. When generating template code, we want the
502 conditional to be rendered as the raw DECL_EXPR. */
505 begin_cond (tree
*cond_p
)
507 if (processing_template_decl
)
508 *cond_p
= push_stmt_list ();
511 /* Finish such a conditional. */
514 finish_cond (tree
*cond_p
, tree expr
)
516 if (processing_template_decl
)
518 tree cond
= pop_stmt_list (*cond_p
);
520 if (expr
== NULL_TREE
)
521 /* Empty condition in 'for'. */
522 gcc_assert (empty_expr_stmt_p (cond
));
523 else if (check_for_bare_parameter_packs (expr
))
524 expr
= error_mark_node
;
525 else if (!empty_expr_stmt_p (cond
))
526 expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (expr
), cond
, expr
);
531 /* If *COND_P specifies a conditional with a declaration, transform the
534 for (; A x = 42;) { }
536 while (true) { A x = 42; if (!x) break; }
537 for (;;) { A x = 42; if (!x) break; }
538 The statement list for BODY will be empty if the conditional did
539 not declare anything. */
542 simplify_loop_decl_cond (tree
*cond_p
, tree body
)
546 if (!TREE_SIDE_EFFECTS (body
))
550 *cond_p
= boolean_true_node
;
552 if_stmt
= begin_if_stmt ();
553 cond
= cp_build_unary_op (TRUTH_NOT_EXPR
, cond
, 0, tf_warning_or_error
);
554 finish_if_stmt_cond (cond
, if_stmt
);
555 finish_break_stmt ();
556 finish_then_clause (if_stmt
);
557 finish_if_stmt (if_stmt
);
560 /* Finish a goto-statement. */
563 finish_goto_stmt (tree destination
)
565 if (TREE_CODE (destination
) == IDENTIFIER_NODE
)
566 destination
= lookup_label (destination
);
568 /* We warn about unused labels with -Wunused. That means we have to
569 mark the used labels as used. */
570 if (TREE_CODE (destination
) == LABEL_DECL
)
571 TREE_USED (destination
) = 1;
574 destination
= mark_rvalue_use (destination
);
575 if (!processing_template_decl
)
577 destination
= cp_convert (ptr_type_node
, destination
,
578 tf_warning_or_error
);
579 if (error_operand_p (destination
))
582 = fold_build_cleanup_point_expr (TREE_TYPE (destination
),
587 check_goto (destination
);
589 return add_stmt (build_stmt (input_location
, GOTO_EXPR
, destination
));
592 /* COND is the condition-expression for an if, while, etc.,
593 statement. Convert it to a boolean value, if appropriate.
594 In addition, verify sequence points if -Wsequence-point is enabled. */
597 maybe_convert_cond (tree cond
)
599 /* Empty conditions remain empty. */
603 /* Wait until we instantiate templates before doing conversion. */
604 if (processing_template_decl
)
607 if (warn_sequence_point
)
608 verify_sequence_points (cond
);
610 /* Do the conversion. */
611 cond
= convert_from_reference (cond
);
613 if (TREE_CODE (cond
) == MODIFY_EXPR
614 && !TREE_NO_WARNING (cond
)
617 warning (OPT_Wparentheses
,
618 "suggest parentheses around assignment used as truth value");
619 TREE_NO_WARNING (cond
) = 1;
622 return condition_conversion (cond
);
625 /* Finish an expression-statement, whose EXPRESSION is as indicated. */
628 finish_expr_stmt (tree expr
)
632 if (expr
!= NULL_TREE
)
634 if (!processing_template_decl
)
636 if (warn_sequence_point
)
637 verify_sequence_points (expr
);
638 expr
= convert_to_void (expr
, ICV_STATEMENT
, tf_warning_or_error
);
640 else if (!type_dependent_expression_p (expr
))
641 convert_to_void (build_non_dependent_expr (expr
), ICV_STATEMENT
,
642 tf_warning_or_error
);
644 if (check_for_bare_parameter_packs (expr
))
645 expr
= error_mark_node
;
647 /* Simplification of inner statement expressions, compound exprs,
648 etc can result in us already having an EXPR_STMT. */
649 if (TREE_CODE (expr
) != CLEANUP_POINT_EXPR
)
651 if (TREE_CODE (expr
) != EXPR_STMT
)
652 expr
= build_stmt (input_location
, EXPR_STMT
, expr
);
653 expr
= maybe_cleanup_point_expr_void (expr
);
665 /* Begin an if-statement. Returns a newly created IF_STMT if
672 scope
= do_pushlevel (sk_cond
);
673 r
= build_stmt (input_location
, IF_STMT
, NULL_TREE
,
674 NULL_TREE
, NULL_TREE
, scope
);
675 begin_cond (&IF_COND (r
));
679 /* Process the COND of an if-statement, which may be given by
683 finish_if_stmt_cond (tree cond
, tree if_stmt
)
685 finish_cond (&IF_COND (if_stmt
), maybe_convert_cond (cond
));
687 THEN_CLAUSE (if_stmt
) = push_stmt_list ();
690 /* Finish the then-clause of an if-statement, which may be given by
694 finish_then_clause (tree if_stmt
)
696 THEN_CLAUSE (if_stmt
) = pop_stmt_list (THEN_CLAUSE (if_stmt
));
700 /* Begin the else-clause of an if-statement. */
703 begin_else_clause (tree if_stmt
)
705 ELSE_CLAUSE (if_stmt
) = push_stmt_list ();
708 /* Finish the else-clause of an if-statement, which may be given by
712 finish_else_clause (tree if_stmt
)
714 ELSE_CLAUSE (if_stmt
) = pop_stmt_list (ELSE_CLAUSE (if_stmt
));
717 /* Finish an if-statement. */
720 finish_if_stmt (tree if_stmt
)
722 tree scope
= IF_SCOPE (if_stmt
);
723 IF_SCOPE (if_stmt
) = NULL
;
724 add_stmt (do_poplevel (scope
));
728 /* Begin a while-statement. Returns a newly created WHILE_STMT if
732 begin_while_stmt (void)
735 r
= build_stmt (input_location
, WHILE_STMT
, NULL_TREE
, NULL_TREE
);
737 WHILE_BODY (r
) = do_pushlevel (sk_block
);
738 begin_cond (&WHILE_COND (r
));
742 /* Process the COND of a while-statement, which may be given by
746 finish_while_stmt_cond (tree cond
, tree while_stmt
)
748 finish_cond (&WHILE_COND (while_stmt
), maybe_convert_cond (cond
));
749 simplify_loop_decl_cond (&WHILE_COND (while_stmt
), WHILE_BODY (while_stmt
));
752 /* Finish a while-statement, which may be given by WHILE_STMT. */
755 finish_while_stmt (tree while_stmt
)
757 WHILE_BODY (while_stmt
) = do_poplevel (WHILE_BODY (while_stmt
));
761 /* Begin a do-statement. Returns a newly created DO_STMT if
767 tree r
= build_stmt (input_location
, DO_STMT
, NULL_TREE
, NULL_TREE
);
769 DO_BODY (r
) = push_stmt_list ();
773 /* Finish the body of a do-statement, which may be given by DO_STMT. */
776 finish_do_body (tree do_stmt
)
778 tree body
= DO_BODY (do_stmt
) = pop_stmt_list (DO_BODY (do_stmt
));
780 if (TREE_CODE (body
) == STATEMENT_LIST
&& STATEMENT_LIST_TAIL (body
))
781 body
= STATEMENT_LIST_TAIL (body
)->stmt
;
783 if (IS_EMPTY_STMT (body
))
784 warning (OPT_Wempty_body
,
785 "suggest explicit braces around empty body in %<do%> statement");
788 /* Finish a do-statement, which may be given by DO_STMT, and whose
789 COND is as indicated. */
792 finish_do_stmt (tree cond
, tree do_stmt
)
794 cond
= maybe_convert_cond (cond
);
795 DO_COND (do_stmt
) = cond
;
799 /* Finish a return-statement. The EXPRESSION returned, if any, is as
803 finish_return_stmt (tree expr
)
808 expr
= check_return_expr (expr
, &no_warning
);
810 if (flag_openmp
&& !check_omp_return ())
811 return error_mark_node
;
812 if (!processing_template_decl
)
814 if (warn_sequence_point
)
815 verify_sequence_points (expr
);
817 if (DECL_DESTRUCTOR_P (current_function_decl
)
818 || (DECL_CONSTRUCTOR_P (current_function_decl
)
819 && targetm
.cxx
.cdtor_returns_this ()))
821 /* Similarly, all destructors must run destructors for
822 base-classes before returning. So, all returns in a
823 destructor get sent to the DTOR_LABEL; finish_function emits
824 code to return a value there. */
825 return finish_goto_stmt (cdtor_label
);
829 r
= build_stmt (input_location
, RETURN_EXPR
, expr
);
830 TREE_NO_WARNING (r
) |= no_warning
;
831 r
= maybe_cleanup_point_expr_void (r
);
838 /* Begin the scope of a for-statement or a range-for-statement.
839 Both the returned trees are to be used in a call to
840 begin_for_stmt or begin_range_for_stmt. */
843 begin_for_scope (tree
*init
)
845 tree scope
= NULL_TREE
;
846 if (flag_new_for_scope
> 0)
847 scope
= do_pushlevel (sk_for
);
849 if (processing_template_decl
)
850 *init
= push_stmt_list ();
857 /* Begin a for-statement. Returns a new FOR_STMT.
858 SCOPE and INIT should be the return of begin_for_scope,
862 begin_for_stmt (tree scope
, tree init
)
866 r
= build_stmt (input_location
, FOR_STMT
, NULL_TREE
, NULL_TREE
,
867 NULL_TREE
, NULL_TREE
, NULL_TREE
);
869 if (scope
== NULL_TREE
)
871 gcc_assert (!init
|| !(flag_new_for_scope
> 0));
873 scope
= begin_for_scope (&init
);
875 FOR_INIT_STMT (r
) = init
;
876 FOR_SCOPE (r
) = scope
;
881 /* Finish the for-init-statement of a for-statement, which may be
882 given by FOR_STMT. */
885 finish_for_init_stmt (tree for_stmt
)
887 if (processing_template_decl
)
888 FOR_INIT_STMT (for_stmt
) = pop_stmt_list (FOR_INIT_STMT (for_stmt
));
890 FOR_BODY (for_stmt
) = do_pushlevel (sk_block
);
891 begin_cond (&FOR_COND (for_stmt
));
894 /* Finish the COND of a for-statement, which may be given by
898 finish_for_cond (tree cond
, tree for_stmt
)
900 finish_cond (&FOR_COND (for_stmt
), maybe_convert_cond (cond
));
901 simplify_loop_decl_cond (&FOR_COND (for_stmt
), FOR_BODY (for_stmt
));
904 /* Finish the increment-EXPRESSION in a for-statement, which may be
905 given by FOR_STMT. */
908 finish_for_expr (tree expr
, tree for_stmt
)
912 /* If EXPR is an overloaded function, issue an error; there is no
913 context available to use to perform overload resolution. */
914 if (type_unknown_p (expr
))
916 cxx_incomplete_type_error (expr
, TREE_TYPE (expr
));
917 expr
= error_mark_node
;
919 if (!processing_template_decl
)
921 if (warn_sequence_point
)
922 verify_sequence_points (expr
);
923 expr
= convert_to_void (expr
, ICV_THIRD_IN_FOR
,
924 tf_warning_or_error
);
926 else if (!type_dependent_expression_p (expr
))
927 convert_to_void (build_non_dependent_expr (expr
), ICV_THIRD_IN_FOR
,
928 tf_warning_or_error
);
929 expr
= maybe_cleanup_point_expr_void (expr
);
930 if (check_for_bare_parameter_packs (expr
))
931 expr
= error_mark_node
;
932 FOR_EXPR (for_stmt
) = expr
;
935 /* Finish the body of a for-statement, which may be given by
936 FOR_STMT. The increment-EXPR for the loop must be
938 It can also finish RANGE_FOR_STMT. */
941 finish_for_stmt (tree for_stmt
)
943 if (TREE_CODE (for_stmt
) == RANGE_FOR_STMT
)
944 RANGE_FOR_BODY (for_stmt
) = do_poplevel (RANGE_FOR_BODY (for_stmt
));
946 FOR_BODY (for_stmt
) = do_poplevel (FOR_BODY (for_stmt
));
948 /* Pop the scope for the body of the loop. */
949 if (flag_new_for_scope
> 0)
952 tree
*scope_ptr
= (TREE_CODE (for_stmt
) == RANGE_FOR_STMT
953 ? &RANGE_FOR_SCOPE (for_stmt
)
954 : &FOR_SCOPE (for_stmt
));
957 add_stmt (do_poplevel (scope
));
963 /* Begin a range-for-statement. Returns a new RANGE_FOR_STMT.
964 SCOPE and INIT should be the return of begin_for_scope,
966 To finish it call finish_for_stmt(). */
969 begin_range_for_stmt (tree scope
, tree init
)
973 r
= build_stmt (input_location
, RANGE_FOR_STMT
,
974 NULL_TREE
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
976 if (scope
== NULL_TREE
)
978 gcc_assert (!init
|| !(flag_new_for_scope
> 0));
980 scope
= begin_for_scope (&init
);
983 /* RANGE_FOR_STMTs do not use nor save the init tree, so we
986 pop_stmt_list (init
);
987 RANGE_FOR_SCOPE (r
) = scope
;
992 /* Finish the head of a range-based for statement, which may
993 be given by RANGE_FOR_STMT. DECL must be the declaration
994 and EXPR must be the loop expression. */
997 finish_range_for_decl (tree range_for_stmt
, tree decl
, tree expr
)
999 RANGE_FOR_DECL (range_for_stmt
) = decl
;
1000 RANGE_FOR_EXPR (range_for_stmt
) = expr
;
1001 add_stmt (range_for_stmt
);
1002 RANGE_FOR_BODY (range_for_stmt
) = do_pushlevel (sk_block
);
1005 /* Finish a break-statement. */
1008 finish_break_stmt (void)
1010 /* In switch statements break is sometimes stylistically used after
1011 a return statement. This can lead to spurious warnings about
1012 control reaching the end of a non-void function when it is
1013 inlined. Note that we are calling block_may_fallthru with
1014 language specific tree nodes; this works because
1015 block_may_fallthru returns true when given something it does not
1017 if (!block_may_fallthru (cur_stmt_list
))
1018 return void_zero_node
;
1019 return add_stmt (build_stmt (input_location
, BREAK_STMT
));
1022 /* Finish a continue-statement. */
1025 finish_continue_stmt (void)
1027 return add_stmt (build_stmt (input_location
, CONTINUE_STMT
));
1030 /* Begin a switch-statement. Returns a new SWITCH_STMT if
1034 begin_switch_stmt (void)
1038 scope
= do_pushlevel (sk_cond
);
1039 r
= build_stmt (input_location
, SWITCH_STMT
, NULL_TREE
, NULL_TREE
, NULL_TREE
, scope
);
1041 begin_cond (&SWITCH_STMT_COND (r
));
1046 /* Finish the cond of a switch-statement. */
1049 finish_switch_cond (tree cond
, tree switch_stmt
)
1051 tree orig_type
= NULL
;
1052 if (!processing_template_decl
)
1054 /* Convert the condition to an integer or enumeration type. */
1055 cond
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
, cond
, true);
1056 if (cond
== NULL_TREE
)
1058 error ("switch quantity not an integer");
1059 cond
= error_mark_node
;
1061 orig_type
= TREE_TYPE (cond
);
1062 if (cond
!= error_mark_node
)
1066 Integral promotions are performed. */
1067 cond
= perform_integral_promotions (cond
);
1068 cond
= maybe_cleanup_point_expr (cond
);
1071 if (check_for_bare_parameter_packs (cond
))
1072 cond
= error_mark_node
;
1073 else if (!processing_template_decl
&& warn_sequence_point
)
1074 verify_sequence_points (cond
);
1076 finish_cond (&SWITCH_STMT_COND (switch_stmt
), cond
);
1077 SWITCH_STMT_TYPE (switch_stmt
) = orig_type
;
1078 add_stmt (switch_stmt
);
1079 push_switch (switch_stmt
);
1080 SWITCH_STMT_BODY (switch_stmt
) = push_stmt_list ();
1083 /* Finish the body of a switch-statement, which may be given by
1084 SWITCH_STMT. The COND to switch on is indicated. */
1087 finish_switch_stmt (tree switch_stmt
)
1091 SWITCH_STMT_BODY (switch_stmt
) =
1092 pop_stmt_list (SWITCH_STMT_BODY (switch_stmt
));
1096 scope
= SWITCH_STMT_SCOPE (switch_stmt
);
1097 SWITCH_STMT_SCOPE (switch_stmt
) = NULL
;
1098 add_stmt (do_poplevel (scope
));
1101 /* Begin a try-block. Returns a newly-created TRY_BLOCK if
1105 begin_try_block (void)
1107 tree r
= build_stmt (input_location
, TRY_BLOCK
, NULL_TREE
, NULL_TREE
);
1109 TRY_STMTS (r
) = push_stmt_list ();
1113 /* Likewise, for a function-try-block. The block returned in
1114 *COMPOUND_STMT is an artificial outer scope, containing the
1115 function-try-block. */
1118 begin_function_try_block (tree
*compound_stmt
)
1121 /* This outer scope does not exist in the C++ standard, but we need
1122 a place to put __FUNCTION__ and similar variables. */
1123 *compound_stmt
= begin_compound_stmt (0);
1124 r
= begin_try_block ();
1125 FN_TRY_BLOCK_P (r
) = 1;
1129 /* Finish a try-block, which may be given by TRY_BLOCK. */
1132 finish_try_block (tree try_block
)
1134 TRY_STMTS (try_block
) = pop_stmt_list (TRY_STMTS (try_block
));
1135 TRY_HANDLERS (try_block
) = push_stmt_list ();
1138 /* Finish the body of a cleanup try-block, which may be given by
1142 finish_cleanup_try_block (tree try_block
)
1144 TRY_STMTS (try_block
) = pop_stmt_list (TRY_STMTS (try_block
));
1147 /* Finish an implicitly generated try-block, with a cleanup is given
1151 finish_cleanup (tree cleanup
, tree try_block
)
1153 TRY_HANDLERS (try_block
) = cleanup
;
1154 CLEANUP_P (try_block
) = 1;
1157 /* Likewise, for a function-try-block. */
1160 finish_function_try_block (tree try_block
)
1162 finish_try_block (try_block
);
1163 /* FIXME : something queer about CTOR_INITIALIZER somehow following
1164 the try block, but moving it inside. */
1165 in_function_try_handler
= 1;
1168 /* Finish a handler-sequence for a try-block, which may be given by
1172 finish_handler_sequence (tree try_block
)
1174 TRY_HANDLERS (try_block
) = pop_stmt_list (TRY_HANDLERS (try_block
));
1175 check_handlers (TRY_HANDLERS (try_block
));
1178 /* Finish the handler-seq for a function-try-block, given by
1179 TRY_BLOCK. COMPOUND_STMT is the outer block created by
1180 begin_function_try_block. */
1183 finish_function_handler_sequence (tree try_block
, tree compound_stmt
)
1185 in_function_try_handler
= 0;
1186 finish_handler_sequence (try_block
);
1187 finish_compound_stmt (compound_stmt
);
1190 /* Begin a handler. Returns a HANDLER if appropriate. */
1193 begin_handler (void)
1197 r
= build_stmt (input_location
, HANDLER
, NULL_TREE
, NULL_TREE
);
1200 /* Create a binding level for the eh_info and the exception object
1202 HANDLER_BODY (r
) = do_pushlevel (sk_catch
);
1207 /* Finish the handler-parameters for a handler, which may be given by
1208 HANDLER. DECL is the declaration for the catch parameter, or NULL
1209 if this is a `catch (...)' clause. */
1212 finish_handler_parms (tree decl
, tree handler
)
1214 tree type
= NULL_TREE
;
1215 if (processing_template_decl
)
1219 decl
= pushdecl (decl
);
1220 decl
= push_template_decl (decl
);
1221 HANDLER_PARMS (handler
) = decl
;
1222 type
= TREE_TYPE (decl
);
1226 type
= expand_start_catch_block (decl
);
1227 HANDLER_TYPE (handler
) = type
;
1228 if (!processing_template_decl
&& type
)
1229 mark_used (eh_type_info (type
));
1232 /* Finish a handler, which may be given by HANDLER. The BLOCKs are
1233 the return value from the matching call to finish_handler_parms. */
1236 finish_handler (tree handler
)
1238 if (!processing_template_decl
)
1239 expand_end_catch_block ();
1240 HANDLER_BODY (handler
) = do_poplevel (HANDLER_BODY (handler
));
1243 /* Begin a compound statement. FLAGS contains some bits that control the
1244 behavior and context. If BCS_NO_SCOPE is set, the compound statement
1245 does not define a scope. If BCS_FN_BODY is set, this is the outermost
1246 block of a function. If BCS_TRY_BLOCK is set, this is the block
1247 created on behalf of a TRY statement. Returns a token to be passed to
1248 finish_compound_stmt. */
1251 begin_compound_stmt (unsigned int flags
)
1255 if (flags
& BCS_NO_SCOPE
)
1257 r
= push_stmt_list ();
1258 STATEMENT_LIST_NO_SCOPE (r
) = 1;
1260 /* Normally, we try hard to keep the BLOCK for a statement-expression.
1261 But, if it's a statement-expression with a scopeless block, there's
1262 nothing to keep, and we don't want to accidentally keep a block
1263 *inside* the scopeless block. */
1264 keep_next_level (false);
1267 r
= do_pushlevel (flags
& BCS_TRY_BLOCK
? sk_try
: sk_block
);
1269 /* When processing a template, we need to remember where the braces were,
1270 so that we can set up identical scopes when instantiating the template
1271 later. BIND_EXPR is a handy candidate for this.
1272 Note that do_poplevel won't create a BIND_EXPR itself here (and thus
1273 result in nested BIND_EXPRs), since we don't build BLOCK nodes when
1274 processing templates. */
1275 if (processing_template_decl
)
1277 r
= build3 (BIND_EXPR
, NULL
, NULL
, r
, NULL
);
1278 BIND_EXPR_TRY_BLOCK (r
) = (flags
& BCS_TRY_BLOCK
) != 0;
1279 BIND_EXPR_BODY_BLOCK (r
) = (flags
& BCS_FN_BODY
) != 0;
1280 TREE_SIDE_EFFECTS (r
) = 1;
1286 /* Finish a compound-statement, which is given by STMT. */
1289 finish_compound_stmt (tree stmt
)
1291 if (TREE_CODE (stmt
) == BIND_EXPR
)
1293 tree body
= do_poplevel (BIND_EXPR_BODY (stmt
));
1294 /* If the STATEMENT_LIST is empty and this BIND_EXPR isn't special,
1295 discard the BIND_EXPR so it can be merged with the containing
1297 if (TREE_CODE (body
) == STATEMENT_LIST
1298 && STATEMENT_LIST_HEAD (body
) == NULL
1299 && !BIND_EXPR_BODY_BLOCK (stmt
)
1300 && !BIND_EXPR_TRY_BLOCK (stmt
))
1303 BIND_EXPR_BODY (stmt
) = body
;
1305 else if (STATEMENT_LIST_NO_SCOPE (stmt
))
1306 stmt
= pop_stmt_list (stmt
);
1309 /* Destroy any ObjC "super" receivers that may have been
1311 objc_clear_super_receiver ();
1313 stmt
= do_poplevel (stmt
);
1316 /* ??? See c_end_compound_stmt wrt statement expressions. */
1321 /* Finish an asm-statement, whose components are a STRING, some
1322 OUTPUT_OPERANDS, some INPUT_OPERANDS, some CLOBBERS and some
1323 LABELS. Also note whether the asm-statement should be
1324 considered volatile. */
1327 finish_asm_stmt (int volatile_p
, tree string
, tree output_operands
,
1328 tree input_operands
, tree clobbers
, tree labels
)
1332 int ninputs
= list_length (input_operands
);
1333 int noutputs
= list_length (output_operands
);
1335 if (!processing_template_decl
)
1337 const char *constraint
;
1338 const char **oconstraints
;
1339 bool allows_mem
, allows_reg
, is_inout
;
1343 oconstraints
= XALLOCAVEC (const char *, noutputs
);
1345 string
= resolve_asm_operand_names (string
, output_operands
,
1346 input_operands
, labels
);
1348 for (i
= 0, t
= output_operands
; t
; t
= TREE_CHAIN (t
), ++i
)
1350 operand
= TREE_VALUE (t
);
1352 /* ??? Really, this should not be here. Users should be using a
1353 proper lvalue, dammit. But there's a long history of using
1354 casts in the output operands. In cases like longlong.h, this
1355 becomes a primitive form of typechecking -- if the cast can be
1356 removed, then the output operand had a type of the proper width;
1357 otherwise we'll get an error. Gross, but ... */
1358 STRIP_NOPS (operand
);
1360 operand
= mark_lvalue_use (operand
);
1362 if (!lvalue_or_else (operand
, lv_asm
, tf_warning_or_error
))
1363 operand
= error_mark_node
;
1365 if (operand
!= error_mark_node
1366 && (TREE_READONLY (operand
)
1367 || CP_TYPE_CONST_P (TREE_TYPE (operand
))
1368 /* Functions are not modifiable, even though they are
1370 || TREE_CODE (TREE_TYPE (operand
)) == FUNCTION_TYPE
1371 || TREE_CODE (TREE_TYPE (operand
)) == METHOD_TYPE
1372 /* If it's an aggregate and any field is const, then it is
1373 effectively const. */
1374 || (CLASS_TYPE_P (TREE_TYPE (operand
))
1375 && C_TYPE_FIELDS_READONLY (TREE_TYPE (operand
)))))
1376 cxx_readonly_error (operand
, lv_asm
);
1378 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
1379 oconstraints
[i
] = constraint
;
1381 if (parse_output_constraint (&constraint
, i
, ninputs
, noutputs
,
1382 &allows_mem
, &allows_reg
, &is_inout
))
1384 /* If the operand is going to end up in memory,
1385 mark it addressable. */
1386 if (!allows_reg
&& !cxx_mark_addressable (operand
))
1387 operand
= error_mark_node
;
1390 operand
= error_mark_node
;
1392 TREE_VALUE (t
) = operand
;
1395 for (i
= 0, t
= input_operands
; t
; ++i
, t
= TREE_CHAIN (t
))
1397 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
1398 operand
= decay_conversion (TREE_VALUE (t
), tf_warning_or_error
);
1400 /* If the type of the operand hasn't been determined (e.g.,
1401 because it involves an overloaded function), then issue
1402 an error message. There's no context available to
1403 resolve the overloading. */
1404 if (TREE_TYPE (operand
) == unknown_type_node
)
1406 error ("type of asm operand %qE could not be determined",
1408 operand
= error_mark_node
;
1411 if (parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, 0,
1412 oconstraints
, &allows_mem
, &allows_reg
))
1414 /* If the operand is going to end up in memory,
1415 mark it addressable. */
1416 if (!allows_reg
&& allows_mem
)
1418 /* Strip the nops as we allow this case. FIXME, this really
1419 should be rejected or made deprecated. */
1420 STRIP_NOPS (operand
);
1421 if (!cxx_mark_addressable (operand
))
1422 operand
= error_mark_node
;
1426 operand
= error_mark_node
;
1428 TREE_VALUE (t
) = operand
;
1432 r
= build_stmt (input_location
, ASM_EXPR
, string
,
1433 output_operands
, input_operands
,
1435 ASM_VOLATILE_P (r
) = volatile_p
|| noutputs
== 0;
1436 r
= maybe_cleanup_point_expr_void (r
);
1437 return add_stmt (r
);
1440 /* Finish a label with the indicated NAME. Returns the new label. */
1443 finish_label_stmt (tree name
)
1445 tree decl
= define_label (input_location
, name
);
1447 if (decl
== error_mark_node
)
1448 return error_mark_node
;
1450 add_stmt (build_stmt (input_location
, LABEL_EXPR
, decl
));
1455 /* Finish a series of declarations for local labels. G++ allows users
1456 to declare "local" labels, i.e., labels with scope. This extension
1457 is useful when writing code involving statement-expressions. */
1460 finish_label_decl (tree name
)
1462 if (!at_function_scope_p ())
1464 error ("__label__ declarations are only allowed in function scopes");
1468 add_decl_expr (declare_local_label (name
));
1471 /* When DECL goes out of scope, make sure that CLEANUP is executed. */
1474 finish_decl_cleanup (tree decl
, tree cleanup
)
1476 push_cleanup (decl
, cleanup
, false);
1479 /* If the current scope exits with an exception, run CLEANUP. */
1482 finish_eh_cleanup (tree cleanup
)
1484 push_cleanup (NULL
, cleanup
, true);
1487 /* The MEM_INITS is a list of mem-initializers, in reverse of the
1488 order they were written by the user. Each node is as for
1489 emit_mem_initializers. */
1492 finish_mem_initializers (tree mem_inits
)
1494 /* Reorder the MEM_INITS so that they are in the order they appeared
1495 in the source program. */
1496 mem_inits
= nreverse (mem_inits
);
1498 if (processing_template_decl
)
1502 for (mem
= mem_inits
; mem
; mem
= TREE_CHAIN (mem
))
1504 /* If the TREE_PURPOSE is a TYPE_PACK_EXPANSION, skip the
1505 check for bare parameter packs in the TREE_VALUE, because
1506 any parameter packs in the TREE_VALUE have already been
1507 bound as part of the TREE_PURPOSE. See
1508 make_pack_expansion for more information. */
1509 if (TREE_CODE (TREE_PURPOSE (mem
)) != TYPE_PACK_EXPANSION
1510 && check_for_bare_parameter_packs (TREE_VALUE (mem
)))
1511 TREE_VALUE (mem
) = error_mark_node
;
1514 add_stmt (build_min_nt_loc (UNKNOWN_LOCATION
,
1515 CTOR_INITIALIZER
, mem_inits
));
1518 emit_mem_initializers (mem_inits
);
1521 /* Finish a parenthesized expression EXPR. */
1524 finish_parenthesized_expr (tree expr
)
1527 /* This inhibits warnings in c_common_truthvalue_conversion. */
1528 TREE_NO_WARNING (expr
) = 1;
1530 if (TREE_CODE (expr
) == OFFSET_REF
1531 || TREE_CODE (expr
) == SCOPE_REF
)
1532 /* [expr.unary.op]/3 The qualified id of a pointer-to-member must not be
1533 enclosed in parentheses. */
1534 PTRMEM_OK_P (expr
) = 0;
1536 if (TREE_CODE (expr
) == STRING_CST
)
1537 PAREN_STRING_LITERAL_P (expr
) = 1;
1542 /* Finish a reference to a non-static data member (DECL) that is not
1543 preceded by `.' or `->'. */
1546 finish_non_static_data_member (tree decl
, tree object
, tree qualifying_scope
)
1548 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
);
1552 tree scope
= qualifying_scope
;
1553 if (scope
== NULL_TREE
)
1554 scope
= context_for_name_lookup (decl
);
1555 object
= maybe_dummy_object (scope
, NULL
);
1558 if (object
== error_mark_node
)
1559 return error_mark_node
;
1561 /* DR 613: Can use non-static data members without an associated
1562 object in sizeof/decltype/alignof. */
1563 if (is_dummy_object (object
) && cp_unevaluated_operand
== 0
1564 && (!processing_template_decl
|| !current_class_ref
))
1566 if (current_function_decl
1567 && DECL_STATIC_FUNCTION_P (current_function_decl
))
1568 error ("invalid use of member %q+D in static member function", decl
);
1570 error ("invalid use of non-static data member %q+D", decl
);
1571 error ("from this location");
1573 return error_mark_node
;
1576 if (current_class_ptr
)
1577 TREE_USED (current_class_ptr
) = 1;
1578 if (processing_template_decl
&& !qualifying_scope
)
1580 tree type
= TREE_TYPE (decl
);
1582 if (TREE_CODE (type
) == REFERENCE_TYPE
)
1583 /* Quals on the object don't matter. */;
1586 /* Set the cv qualifiers. */
1587 int quals
= (current_class_ref
1588 ? cp_type_quals (TREE_TYPE (current_class_ref
))
1589 : TYPE_UNQUALIFIED
);
1591 if (DECL_MUTABLE_P (decl
))
1592 quals
&= ~TYPE_QUAL_CONST
;
1594 quals
|= cp_type_quals (TREE_TYPE (decl
));
1595 type
= cp_build_qualified_type (type
, quals
);
1598 return (convert_from_reference
1599 (build_min (COMPONENT_REF
, type
, object
, decl
, NULL_TREE
)));
1601 /* If PROCESSING_TEMPLATE_DECL is nonzero here, then
1602 QUALIFYING_SCOPE is also non-null. Wrap this in a SCOPE_REF
1604 else if (processing_template_decl
)
1605 return build_qualified_name (TREE_TYPE (decl
),
1608 /*template_p=*/false);
1611 tree access_type
= TREE_TYPE (object
);
1613 perform_or_defer_access_check (TYPE_BINFO (access_type
), decl
,
1616 /* If the data member was named `C::M', convert `*this' to `C'
1618 if (qualifying_scope
)
1620 tree binfo
= NULL_TREE
;
1621 object
= build_scoped_ref (object
, qualifying_scope
,
1625 return build_class_member_access_expr (object
, decl
,
1626 /*access_path=*/NULL_TREE
,
1627 /*preserve_reference=*/false,
1628 tf_warning_or_error
);
1632 /* If we are currently parsing a template and we encountered a typedef
1633 TYPEDEF_DECL that is being accessed though CONTEXT, this function
1634 adds the typedef to a list tied to the current template.
1635 At template instantiation time, that list is walked and access check
1636 performed for each typedef.
1637 LOCATION is the location of the usage point of TYPEDEF_DECL. */
1640 add_typedef_to_current_template_for_access_check (tree typedef_decl
,
1642 location_t location
)
1644 tree template_info
= NULL
;
1645 tree cs
= current_scope ();
1647 if (!is_typedef_decl (typedef_decl
)
1649 || !CLASS_TYPE_P (context
)
1653 if (CLASS_TYPE_P (cs
) || TREE_CODE (cs
) == FUNCTION_DECL
)
1654 template_info
= get_template_info (cs
);
1657 && TI_TEMPLATE (template_info
)
1658 && !currently_open_class (context
))
1659 append_type_to_template_for_access_check (cs
, typedef_decl
,
1663 /* DECL was the declaration to which a qualified-id resolved. Issue
1664 an error message if it is not accessible. If OBJECT_TYPE is
1665 non-NULL, we have just seen `x->' or `x.' and OBJECT_TYPE is the
1666 type of `*x', or `x', respectively. If the DECL was named as
1667 `A::B' then NESTED_NAME_SPECIFIER is `A'. */
1670 check_accessibility_of_qualified_id (tree decl
,
1672 tree nested_name_specifier
)
1675 tree qualifying_type
= NULL_TREE
;
1677 /* If we are parsing a template declaration and if decl is a typedef,
1678 add it to a list tied to the template.
1679 At template instantiation time, that list will be walked and
1680 access check performed. */
1681 add_typedef_to_current_template_for_access_check (decl
,
1682 nested_name_specifier
1683 ? nested_name_specifier
1684 : DECL_CONTEXT (decl
),
1687 /* If we're not checking, return immediately. */
1688 if (deferred_access_no_check
)
1691 /* Determine the SCOPE of DECL. */
1692 scope
= context_for_name_lookup (decl
);
1693 /* If the SCOPE is not a type, then DECL is not a member. */
1694 if (!TYPE_P (scope
))
1696 /* Compute the scope through which DECL is being accessed. */
1698 /* OBJECT_TYPE might not be a class type; consider:
1700 class A { typedef int I; };
1704 In this case, we will have "A::I" as the DECL, but "I" as the
1706 && CLASS_TYPE_P (object_type
)
1707 && DERIVED_FROM_P (scope
, object_type
))
1708 /* If we are processing a `->' or `.' expression, use the type of the
1710 qualifying_type
= object_type
;
1711 else if (nested_name_specifier
)
1713 /* If the reference is to a non-static member of the
1714 current class, treat it as if it were referenced through
1716 if (DECL_NONSTATIC_MEMBER_P (decl
)
1717 && current_class_ptr
1718 && DERIVED_FROM_P (scope
, current_class_type
))
1719 qualifying_type
= current_class_type
;
1720 /* Otherwise, use the type indicated by the
1721 nested-name-specifier. */
1723 qualifying_type
= nested_name_specifier
;
1726 /* Otherwise, the name must be from the current class or one of
1728 qualifying_type
= currently_open_derived_class (scope
);
1731 /* It is possible for qualifying type to be a TEMPLATE_TYPE_PARM
1732 or similar in a default argument value. */
1733 && CLASS_TYPE_P (qualifying_type
)
1734 && !dependent_type_p (qualifying_type
))
1735 perform_or_defer_access_check (TYPE_BINFO (qualifying_type
), decl
,
1739 /* EXPR is the result of a qualified-id. The QUALIFYING_CLASS was the
1740 class named to the left of the "::" operator. DONE is true if this
1741 expression is a complete postfix-expression; it is false if this
1742 expression is followed by '->', '[', '(', etc. ADDRESS_P is true
1743 iff this expression is the operand of '&'. TEMPLATE_P is true iff
1744 the qualified-id was of the form "A::template B". TEMPLATE_ARG_P
1745 is true iff this qualified name appears as a template argument. */
1748 finish_qualified_id_expr (tree qualifying_class
,
1753 bool template_arg_p
)
1755 gcc_assert (TYPE_P (qualifying_class
));
1757 if (error_operand_p (expr
))
1758 return error_mark_node
;
1760 if (DECL_P (expr
) || BASELINK_P (expr
))
1764 check_template_keyword (expr
);
1766 /* If EXPR occurs as the operand of '&', use special handling that
1767 permits a pointer-to-member. */
1768 if (address_p
&& done
)
1770 if (TREE_CODE (expr
) == SCOPE_REF
)
1771 expr
= TREE_OPERAND (expr
, 1);
1772 expr
= build_offset_ref (qualifying_class
, expr
,
1773 /*address_p=*/true);
1777 /* Within the scope of a class, turn references to non-static
1778 members into expression of the form "this->...". */
1780 /* But, within a template argument, we do not want make the
1781 transformation, as there is no "this" pointer. */
1783 else if (TREE_CODE (expr
) == FIELD_DECL
)
1785 push_deferring_access_checks (dk_no_check
);
1786 expr
= finish_non_static_data_member (expr
, NULL_TREE
,
1788 pop_deferring_access_checks ();
1790 else if (BASELINK_P (expr
) && !processing_template_decl
)
1794 /* See if any of the functions are non-static members. */
1795 /* If so, the expression may be relative to 'this'. */
1796 if (!shared_member_p (expr
)
1797 && (ob
= maybe_dummy_object (qualifying_class
, NULL
),
1798 !is_dummy_object (ob
)))
1799 expr
= (build_class_member_access_expr
1802 BASELINK_ACCESS_BINFO (expr
),
1803 /*preserve_reference=*/false,
1804 tf_warning_or_error
));
1806 /* The expression is a qualified name whose address is not
1808 expr
= build_offset_ref (qualifying_class
, expr
, /*address_p=*/false);
1814 /* Begin a statement-expression. The value returned must be passed to
1815 finish_stmt_expr. */
1818 begin_stmt_expr (void)
1820 return push_stmt_list ();
1823 /* Process the final expression of a statement expression. EXPR can be
1824 NULL, if the final expression is empty. Return a STATEMENT_LIST
1825 containing all the statements in the statement-expression, or
1826 ERROR_MARK_NODE if there was an error. */
1829 finish_stmt_expr_expr (tree expr
, tree stmt_expr
)
1831 if (error_operand_p (expr
))
1833 /* The type of the statement-expression is the type of the last
1835 TREE_TYPE (stmt_expr
) = error_mark_node
;
1836 return error_mark_node
;
1839 /* If the last statement does not have "void" type, then the value
1840 of the last statement is the value of the entire expression. */
1843 tree type
= TREE_TYPE (expr
);
1845 if (processing_template_decl
)
1847 expr
= build_stmt (input_location
, EXPR_STMT
, expr
);
1848 expr
= add_stmt (expr
);
1849 /* Mark the last statement so that we can recognize it as such at
1850 template-instantiation time. */
1851 EXPR_STMT_STMT_EXPR_RESULT (expr
) = 1;
1853 else if (VOID_TYPE_P (type
))
1855 /* Just treat this like an ordinary statement. */
1856 expr
= finish_expr_stmt (expr
);
1860 /* It actually has a value we need to deal with. First, force it
1861 to be an rvalue so that we won't need to build up a copy
1862 constructor call later when we try to assign it to something. */
1863 expr
= force_rvalue (expr
, tf_warning_or_error
);
1864 if (error_operand_p (expr
))
1865 return error_mark_node
;
1867 /* Update for array-to-pointer decay. */
1868 type
= TREE_TYPE (expr
);
1870 /* Wrap it in a CLEANUP_POINT_EXPR and add it to the list like a
1871 normal statement, but don't convert to void or actually add
1873 if (TREE_CODE (expr
) != CLEANUP_POINT_EXPR
)
1874 expr
= maybe_cleanup_point_expr (expr
);
1878 /* The type of the statement-expression is the type of the last
1880 TREE_TYPE (stmt_expr
) = type
;
1886 /* Finish a statement-expression. EXPR should be the value returned
1887 by the previous begin_stmt_expr. Returns an expression
1888 representing the statement-expression. */
1891 finish_stmt_expr (tree stmt_expr
, bool has_no_scope
)
1896 if (error_operand_p (stmt_expr
))
1898 pop_stmt_list (stmt_expr
);
1899 return error_mark_node
;
1902 gcc_assert (TREE_CODE (stmt_expr
) == STATEMENT_LIST
);
1904 type
= TREE_TYPE (stmt_expr
);
1905 result
= pop_stmt_list (stmt_expr
);
1906 TREE_TYPE (result
) = type
;
1908 if (processing_template_decl
)
1910 result
= build_min (STMT_EXPR
, type
, result
);
1911 TREE_SIDE_EFFECTS (result
) = 1;
1912 STMT_EXPR_NO_SCOPE (result
) = has_no_scope
;
1914 else if (CLASS_TYPE_P (type
))
1916 /* Wrap the statement-expression in a TARGET_EXPR so that the
1917 temporary object created by the final expression is destroyed at
1918 the end of the full-expression containing the
1919 statement-expression. */
1920 result
= force_target_expr (type
, result
, tf_warning_or_error
);
1926 /* Returns the expression which provides the value of STMT_EXPR. */
1929 stmt_expr_value_expr (tree stmt_expr
)
1931 tree t
= STMT_EXPR_STMT (stmt_expr
);
1933 if (TREE_CODE (t
) == BIND_EXPR
)
1934 t
= BIND_EXPR_BODY (t
);
1936 if (TREE_CODE (t
) == STATEMENT_LIST
&& STATEMENT_LIST_TAIL (t
))
1937 t
= STATEMENT_LIST_TAIL (t
)->stmt
;
1939 if (TREE_CODE (t
) == EXPR_STMT
)
1940 t
= EXPR_STMT_EXPR (t
);
1945 /* Return TRUE iff EXPR_STMT is an empty list of
1946 expression statements. */
1949 empty_expr_stmt_p (tree expr_stmt
)
1951 tree body
= NULL_TREE
;
1953 if (expr_stmt
== void_zero_node
)
1958 if (TREE_CODE (expr_stmt
) == EXPR_STMT
)
1959 body
= EXPR_STMT_EXPR (expr_stmt
);
1960 else if (TREE_CODE (expr_stmt
) == STATEMENT_LIST
)
1966 if (TREE_CODE (body
) == STATEMENT_LIST
)
1967 return tsi_end_p (tsi_start (body
));
1969 return empty_expr_stmt_p (body
);
1974 /* Perform Koenig lookup. FN is the postfix-expression representing
1975 the function (or functions) to call; ARGS are the arguments to the
1976 call; if INCLUDE_STD then the `std' namespace is automatically
1977 considered an associated namespace (used in range-based for loops).
1978 Returns the functions to be considered by overload resolution. */
1981 perform_koenig_lookup (tree fn
, VEC(tree
,gc
) *args
, bool include_std
,
1982 tsubst_flags_t complain
)
1984 tree identifier
= NULL_TREE
;
1985 tree functions
= NULL_TREE
;
1986 tree tmpl_args
= NULL_TREE
;
1987 bool template_id
= false;
1989 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
1991 /* Use a separate flag to handle null args. */
1993 tmpl_args
= TREE_OPERAND (fn
, 1);
1994 fn
= TREE_OPERAND (fn
, 0);
1997 /* Find the name of the overloaded function. */
1998 if (TREE_CODE (fn
) == IDENTIFIER_NODE
)
2000 else if (is_overloaded_fn (fn
))
2003 identifier
= DECL_NAME (get_first_fn (functions
));
2005 else if (DECL_P (fn
))
2008 identifier
= DECL_NAME (fn
);
2011 /* A call to a namespace-scope function using an unqualified name.
2013 Do Koenig lookup -- unless any of the arguments are
2015 if (!any_type_dependent_arguments_p (args
)
2016 && !any_dependent_template_arguments_p (tmpl_args
))
2018 fn
= lookup_arg_dependent (identifier
, functions
, args
, include_std
);
2021 /* The unqualified name could not be resolved. */
2023 fn
= unqualified_fn_lookup_error (identifier
);
2029 if (fn
&& template_id
)
2030 fn
= build2 (TEMPLATE_ID_EXPR
, unknown_type_node
, fn
, tmpl_args
);
2035 /* Generate an expression for `FN (ARGS)'. This may change the
2038 If DISALLOW_VIRTUAL is true, the call to FN will be not generated
2039 as a virtual call, even if FN is virtual. (This flag is set when
2040 encountering an expression where the function name is explicitly
2041 qualified. For example a call to `X::f' never generates a virtual
2044 Returns code for the call. */
2047 finish_call_expr (tree fn
, VEC(tree
,gc
) **args
, bool disallow_virtual
,
2048 bool koenig_p
, tsubst_flags_t complain
)
2052 VEC(tree
,gc
) *orig_args
= NULL
;
2054 if (fn
== error_mark_node
)
2055 return error_mark_node
;
2057 gcc_assert (!TYPE_P (fn
));
2061 if (processing_template_decl
)
2063 /* If the call expression is dependent, build a CALL_EXPR node
2064 with no type; type_dependent_expression_p recognizes
2065 expressions with no type as being dependent. */
2066 if (type_dependent_expression_p (fn
)
2067 || any_type_dependent_arguments_p (*args
)
2068 /* For a non-static member function that doesn't have an
2069 explicit object argument, we need to specifically
2070 test the type dependency of the "this" pointer because it
2071 is not included in *ARGS even though it is considered to
2072 be part of the list of arguments. Note that this is
2073 related to CWG issues 515 and 1005. */
2074 || (TREE_CODE (fn
) != COMPONENT_REF
2075 && non_static_member_function_p (fn
)
2076 && current_class_ref
2077 && type_dependent_expression_p (current_class_ref
)))
2079 result
= build_nt_call_vec (fn
, *args
);
2080 KOENIG_LOOKUP_P (result
) = koenig_p
;
2085 tree fndecl
= OVL_CURRENT (fn
);
2086 if (TREE_CODE (fndecl
) != FUNCTION_DECL
2087 || !TREE_THIS_VOLATILE (fndecl
))
2093 current_function_returns_abnormally
= 1;
2097 orig_args
= make_tree_vector_copy (*args
);
2098 if (!BASELINK_P (fn
)
2099 && TREE_CODE (fn
) != PSEUDO_DTOR_EXPR
2100 && TREE_TYPE (fn
) != unknown_type_node
)
2101 fn
= build_non_dependent_expr (fn
);
2102 make_args_non_dependent (*args
);
2105 if (TREE_CODE (fn
) == COMPONENT_REF
)
2107 tree member
= TREE_OPERAND (fn
, 1);
2108 if (BASELINK_P (member
))
2110 tree object
= TREE_OPERAND (fn
, 0);
2111 return build_new_method_call (object
, member
,
2114 ? LOOKUP_NORMAL
| LOOKUP_NONVIRTUAL
2121 if (is_overloaded_fn (fn
))
2122 fn
= baselink_for_fns (fn
);
2125 if (BASELINK_P (fn
))
2129 /* A call to a member function. From [over.call.func]:
2131 If the keyword this is in scope and refers to the class of
2132 that member function, or a derived class thereof, then the
2133 function call is transformed into a qualified function call
2134 using (*this) as the postfix-expression to the left of the
2135 . operator.... [Otherwise] a contrived object of type T
2136 becomes the implied object argument.
2140 struct A { void f(); };
2141 struct B : public A {};
2142 struct C : public A { void g() { B::f(); }};
2144 "the class of that member function" refers to `A'. But 11.2
2145 [class.access.base] says that we need to convert 'this' to B* as
2146 part of the access, so we pass 'B' to maybe_dummy_object. */
2148 object
= maybe_dummy_object (BINFO_TYPE (BASELINK_ACCESS_BINFO (fn
)),
2151 if (processing_template_decl
)
2153 if (type_dependent_expression_p (object
))
2155 tree ret
= build_nt_call_vec (orig_fn
, orig_args
);
2156 release_tree_vector (orig_args
);
2159 object
= build_non_dependent_expr (object
);
2162 result
= build_new_method_call (object
, fn
, args
, NULL_TREE
,
2164 ? LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
2169 else if (is_overloaded_fn (fn
))
2171 /* If the function is an overloaded builtin, resolve it. */
2172 if (TREE_CODE (fn
) == FUNCTION_DECL
2173 && (DECL_BUILT_IN_CLASS (fn
) == BUILT_IN_NORMAL
2174 || DECL_BUILT_IN_CLASS (fn
) == BUILT_IN_MD
))
2175 result
= resolve_overloaded_builtin (input_location
, fn
, *args
);
2178 /* A call to a namespace-scope function. */
2179 result
= build_new_function_call (fn
, args
, koenig_p
, complain
);
2181 else if (TREE_CODE (fn
) == PSEUDO_DTOR_EXPR
)
2183 if (!VEC_empty (tree
, *args
))
2184 error ("arguments to destructor are not allowed");
2185 /* Mark the pseudo-destructor call as having side-effects so
2186 that we do not issue warnings about its use. */
2187 result
= build1 (NOP_EXPR
,
2189 TREE_OPERAND (fn
, 0));
2190 TREE_SIDE_EFFECTS (result
) = 1;
2192 else if (CLASS_TYPE_P (TREE_TYPE (fn
)))
2193 /* If the "function" is really an object of class type, it might
2194 have an overloaded `operator ()'. */
2195 result
= build_op_call (fn
, args
, complain
);
2198 /* A call where the function is unknown. */
2199 result
= cp_build_function_call_vec (fn
, args
, complain
);
2201 if (processing_template_decl
&& result
!= error_mark_node
)
2203 if (TREE_CODE (result
) == INDIRECT_REF
)
2204 result
= TREE_OPERAND (result
, 0);
2205 result
= build_call_vec (TREE_TYPE (result
), orig_fn
, orig_args
);
2206 SET_EXPR_LOCATION (result
, input_location
);
2207 KOENIG_LOOKUP_P (result
) = koenig_p
;
2208 release_tree_vector (orig_args
);
2209 result
= convert_from_reference (result
);
2214 /* Free garbage OVERLOADs from arg-dependent lookup. */
2215 tree next
= NULL_TREE
;
2217 fn
&& TREE_CODE (fn
) == OVERLOAD
&& OVL_ARG_DEPENDENT (fn
);
2220 if (processing_template_decl
)
2221 /* In a template, we'll re-use them at instantiation time. */
2222 OVL_ARG_DEPENDENT (fn
) = false;
2225 next
= OVL_CHAIN (fn
);
2234 /* Finish a call to a postfix increment or decrement or EXPR. (Which
2235 is indicated by CODE, which should be POSTINCREMENT_EXPR or
2236 POSTDECREMENT_EXPR.) */
2239 finish_increment_expr (tree expr
, enum tree_code code
)
2241 return build_x_unary_op (input_location
, code
, expr
, tf_warning_or_error
);
2244 /* Finish a use of `this'. Returns an expression for `this'. */
2247 finish_this_expr (void)
2251 if (current_class_ptr
)
2253 tree type
= TREE_TYPE (current_class_ref
);
2255 /* In a lambda expression, 'this' refers to the captured 'this'. */
2256 if (LAMBDA_TYPE_P (type
))
2257 result
= lambda_expr_this_capture (CLASSTYPE_LAMBDA_EXPR (type
));
2259 result
= current_class_ptr
;
2262 else if (current_function_decl
2263 && DECL_STATIC_FUNCTION_P (current_function_decl
))
2265 error ("%<this%> is unavailable for static member functions");
2266 result
= error_mark_node
;
2270 if (current_function_decl
)
2271 error ("invalid use of %<this%> in non-member function");
2273 error ("invalid use of %<this%> at top level");
2274 result
= error_mark_node
;
2280 /* Finish a pseudo-destructor expression. If SCOPE is NULL, the
2281 expression was of the form `OBJECT.~DESTRUCTOR' where DESTRUCTOR is
2282 the TYPE for the type given. If SCOPE is non-NULL, the expression
2283 was of the form `OBJECT.SCOPE::~DESTRUCTOR'. */
2286 finish_pseudo_destructor_expr (tree object
, tree scope
, tree destructor
)
2288 if (object
== error_mark_node
|| destructor
== error_mark_node
)
2289 return error_mark_node
;
2291 gcc_assert (TYPE_P (destructor
));
2293 if (!processing_template_decl
)
2295 if (scope
== error_mark_node
)
2297 error ("invalid qualifying scope in pseudo-destructor name");
2298 return error_mark_node
;
2300 if (scope
&& TYPE_P (scope
) && !check_dtor_name (scope
, destructor
))
2302 error ("qualified type %qT does not match destructor name ~%qT",
2304 return error_mark_node
;
2308 /* [expr.pseudo] says both:
2310 The type designated by the pseudo-destructor-name shall be
2311 the same as the object type.
2315 The cv-unqualified versions of the object type and of the
2316 type designated by the pseudo-destructor-name shall be the
2319 We implement the more generous second sentence, since that is
2320 what most other compilers do. */
2321 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (object
),
2324 error ("%qE is not of type %qT", object
, destructor
);
2325 return error_mark_node
;
2329 return build3 (PSEUDO_DTOR_EXPR
, void_type_node
, object
, scope
, destructor
);
2332 /* Finish an expression of the form CODE EXPR. */
2335 finish_unary_op_expr (location_t loc
, enum tree_code code
, tree expr
)
2337 tree result
= build_x_unary_op (loc
, code
, expr
, tf_warning_or_error
);
2338 if (TREE_OVERFLOW_P (result
) && !TREE_OVERFLOW_P (expr
))
2339 overflow_warning (input_location
, result
);
2344 /* Finish a compound-literal expression. TYPE is the type to which
2345 the CONSTRUCTOR in COMPOUND_LITERAL is being cast. */
2348 finish_compound_literal (tree type
, tree compound_literal
,
2349 tsubst_flags_t complain
)
2351 if (type
== error_mark_node
)
2352 return error_mark_node
;
2354 if (TREE_CODE (type
) == REFERENCE_TYPE
)
2357 = finish_compound_literal (TREE_TYPE (type
), compound_literal
,
2359 return cp_build_c_cast (type
, compound_literal
, complain
);
2362 if (!TYPE_OBJ_P (type
))
2364 if (complain
& tf_error
)
2365 error ("compound literal of non-object type %qT", type
);
2366 return error_mark_node
;
2369 if (processing_template_decl
)
2371 TREE_TYPE (compound_literal
) = type
;
2372 /* Mark the expression as a compound literal. */
2373 TREE_HAS_CONSTRUCTOR (compound_literal
) = 1;
2374 return compound_literal
;
2377 type
= complete_type (type
);
2379 if (TYPE_NON_AGGREGATE_CLASS (type
))
2381 /* Trying to deal with a CONSTRUCTOR instead of a TREE_LIST
2382 everywhere that deals with function arguments would be a pain, so
2383 just wrap it in a TREE_LIST. The parser set a flag so we know
2384 that it came from T{} rather than T({}). */
2385 CONSTRUCTOR_IS_DIRECT_INIT (compound_literal
) = 1;
2386 compound_literal
= build_tree_list (NULL_TREE
, compound_literal
);
2387 return build_functional_cast (type
, compound_literal
, complain
);
2390 if (TREE_CODE (type
) == ARRAY_TYPE
2391 && check_array_initializer (NULL_TREE
, type
, compound_literal
))
2392 return error_mark_node
;
2393 compound_literal
= reshape_init (type
, compound_literal
, complain
);
2394 if (SCALAR_TYPE_P (type
)
2395 && !BRACE_ENCLOSED_INITIALIZER_P (compound_literal
)
2396 && (complain
& tf_warning_or_error
))
2397 check_narrowing (type
, compound_literal
);
2398 if (TREE_CODE (type
) == ARRAY_TYPE
2399 && TYPE_DOMAIN (type
) == NULL_TREE
)
2401 cp_complete_array_type_or_error (&type
, compound_literal
,
2403 if (type
== error_mark_node
)
2404 return error_mark_node
;
2406 compound_literal
= digest_init (type
, compound_literal
, complain
);
2407 if (TREE_CODE (compound_literal
) == CONSTRUCTOR
)
2408 TREE_HAS_CONSTRUCTOR (compound_literal
) = true;
2409 /* Put static/constant array temporaries in static variables, but always
2410 represent class temporaries with TARGET_EXPR so we elide copies. */
2411 if ((!at_function_scope_p () || CP_TYPE_CONST_P (type
))
2412 && TREE_CODE (type
) == ARRAY_TYPE
2413 && !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
2414 && initializer_constant_valid_p (compound_literal
, type
))
2416 tree decl
= create_temporary_var (type
);
2417 DECL_INITIAL (decl
) = compound_literal
;
2418 TREE_STATIC (decl
) = 1;
2419 if (literal_type_p (type
) && CP_TYPE_CONST_NON_VOLATILE_P (type
))
2421 /* 5.19 says that a constant expression can include an
2422 lvalue-rvalue conversion applied to "a glvalue of literal type
2423 that refers to a non-volatile temporary object initialized
2424 with a constant expression". Rather than try to communicate
2425 that this VAR_DECL is a temporary, just mark it constexpr. */
2426 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
2427 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = true;
2428 TREE_CONSTANT (decl
) = true;
2430 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
2431 decl
= pushdecl_top_level (decl
);
2432 DECL_NAME (decl
) = make_anon_name ();
2433 SET_DECL_ASSEMBLER_NAME (decl
, DECL_NAME (decl
));
2437 return get_target_expr_sfinae (compound_literal
, complain
);
2440 /* Return the declaration for the function-name variable indicated by
2444 finish_fname (tree id
)
2448 decl
= fname_decl (input_location
, C_RID_CODE (id
), id
);
2449 if (processing_template_decl
&& current_function_decl
)
2450 decl
= DECL_NAME (decl
);
2454 /* Finish a translation unit. */
2457 finish_translation_unit (void)
2459 /* In case there were missing closebraces,
2460 get us back to the global binding level. */
2462 while (current_namespace
!= global_namespace
)
2465 /* Do file scope __FUNCTION__ et al. */
2466 finish_fname_decls ();
2469 /* Finish a template type parameter, specified as AGGR IDENTIFIER.
2470 Returns the parameter. */
2473 finish_template_type_parm (tree aggr
, tree identifier
)
2475 if (aggr
!= class_type_node
)
2477 permerror (input_location
, "template type parameters must use the keyword %<class%> or %<typename%>");
2478 aggr
= class_type_node
;
2481 return build_tree_list (aggr
, identifier
);
2484 /* Finish a template template parameter, specified as AGGR IDENTIFIER.
2485 Returns the parameter. */
2488 finish_template_template_parm (tree aggr
, tree identifier
)
2490 tree decl
= build_decl (input_location
,
2491 TYPE_DECL
, identifier
, NULL_TREE
);
2492 tree tmpl
= build_lang_decl (TEMPLATE_DECL
, identifier
, NULL_TREE
);
2493 DECL_TEMPLATE_PARMS (tmpl
) = current_template_parms
;
2494 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
2495 DECL_ARTIFICIAL (decl
) = 1;
2496 end_template_decl ();
2498 gcc_assert (DECL_TEMPLATE_PARMS (tmpl
));
2500 check_default_tmpl_args (decl
, DECL_TEMPLATE_PARMS (tmpl
),
2501 /*is_primary=*/true, /*is_partial=*/false,
2504 return finish_template_type_parm (aggr
, tmpl
);
2507 /* ARGUMENT is the default-argument value for a template template
2508 parameter. If ARGUMENT is invalid, issue error messages and return
2509 the ERROR_MARK_NODE. Otherwise, ARGUMENT itself is returned. */
2512 check_template_template_default_arg (tree argument
)
2514 if (TREE_CODE (argument
) != TEMPLATE_DECL
2515 && TREE_CODE (argument
) != TEMPLATE_TEMPLATE_PARM
2516 && TREE_CODE (argument
) != UNBOUND_CLASS_TEMPLATE
)
2518 if (TREE_CODE (argument
) == TYPE_DECL
)
2519 error ("invalid use of type %qT as a default value for a template "
2520 "template-parameter", TREE_TYPE (argument
));
2522 error ("invalid default argument for a template template parameter");
2523 return error_mark_node
;
2529 /* Begin a class definition, as indicated by T. */
2532 begin_class_definition (tree t
)
2534 if (error_operand_p (t
) || error_operand_p (TYPE_MAIN_DECL (t
)))
2535 return error_mark_node
;
2537 if (processing_template_parmlist
)
2539 error ("definition of %q#T inside template parameter list", t
);
2540 return error_mark_node
;
2543 /* According to the C++ ABI, decimal classes defined in ISO/IEC TR 24733
2544 are passed the same as decimal scalar types. */
2545 if (TREE_CODE (t
) == RECORD_TYPE
2546 && !processing_template_decl
)
2548 tree ns
= TYPE_CONTEXT (t
);
2549 if (ns
&& TREE_CODE (ns
) == NAMESPACE_DECL
2550 && DECL_CONTEXT (ns
) == std_node
2552 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (ns
)), "decimal"))
2554 const char *n
= TYPE_NAME_STRING (t
);
2555 if ((strcmp (n
, "decimal32") == 0)
2556 || (strcmp (n
, "decimal64") == 0)
2557 || (strcmp (n
, "decimal128") == 0))
2558 TYPE_TRANSPARENT_AGGR (t
) = 1;
2562 /* A non-implicit typename comes from code like:
2564 template <typename T> struct A {
2565 template <typename U> struct A<T>::B ...
2567 This is erroneous. */
2568 else if (TREE_CODE (t
) == TYPENAME_TYPE
)
2570 error ("invalid definition of qualified type %qT", t
);
2571 t
= error_mark_node
;
2574 if (t
== error_mark_node
|| ! MAYBE_CLASS_TYPE_P (t
))
2576 t
= make_class_type (RECORD_TYPE
);
2577 pushtag (make_anon_name (), t
, /*tag_scope=*/ts_current
);
2580 if (TYPE_BEING_DEFINED (t
))
2582 t
= make_class_type (TREE_CODE (t
));
2583 pushtag (TYPE_IDENTIFIER (t
), t
, /*tag_scope=*/ts_current
);
2585 maybe_process_partial_specialization (t
);
2587 TYPE_BEING_DEFINED (t
) = 1;
2589 if (flag_pack_struct
)
2592 TYPE_PACKED (t
) = 1;
2593 /* Even though the type is being defined for the first time
2594 here, there might have been a forward declaration, so there
2595 might be cv-qualified variants of T. */
2596 for (v
= TYPE_NEXT_VARIANT (t
); v
; v
= TYPE_NEXT_VARIANT (v
))
2597 TYPE_PACKED (v
) = 1;
2599 /* Reset the interface data, at the earliest possible
2600 moment, as it might have been set via a class foo;
2602 if (! TYPE_ANONYMOUS_P (t
))
2604 struct c_fileinfo
*finfo
= get_fileinfo (input_filename
);
2605 CLASSTYPE_INTERFACE_ONLY (t
) = finfo
->interface_only
;
2606 SET_CLASSTYPE_INTERFACE_UNKNOWN_X
2607 (t
, finfo
->interface_unknown
);
2609 reset_specialization();
2611 /* Make a declaration for this class in its own scope. */
2612 build_self_reference ();
2617 /* Finish the member declaration given by DECL. */
2620 finish_member_declaration (tree decl
)
2622 if (decl
== error_mark_node
|| decl
== NULL_TREE
)
2625 if (decl
== void_type_node
)
2626 /* The COMPONENT was a friend, not a member, and so there's
2627 nothing for us to do. */
2630 /* We should see only one DECL at a time. */
2631 gcc_assert (DECL_CHAIN (decl
) == NULL_TREE
);
2633 /* Set up access control for DECL. */
2635 = (current_access_specifier
== access_private_node
);
2636 TREE_PROTECTED (decl
)
2637 = (current_access_specifier
== access_protected_node
);
2638 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
2640 TREE_PRIVATE (DECL_TEMPLATE_RESULT (decl
)) = TREE_PRIVATE (decl
);
2641 TREE_PROTECTED (DECL_TEMPLATE_RESULT (decl
)) = TREE_PROTECTED (decl
);
2644 /* Mark the DECL as a member of the current class, unless it's
2645 a member of an enumeration. */
2646 if (TREE_CODE (decl
) != CONST_DECL
)
2647 DECL_CONTEXT (decl
) = current_class_type
;
2649 /* Check for bare parameter packs in the member variable declaration. */
2650 if (TREE_CODE (decl
) == FIELD_DECL
)
2652 if (check_for_bare_parameter_packs (TREE_TYPE (decl
)))
2653 TREE_TYPE (decl
) = error_mark_node
;
2654 if (check_for_bare_parameter_packs (DECL_ATTRIBUTES (decl
)))
2655 DECL_ATTRIBUTES (decl
) = NULL_TREE
;
2660 A C language linkage is ignored for the names of class members
2661 and the member function type of class member functions. */
2662 if (DECL_LANG_SPECIFIC (decl
) && DECL_LANGUAGE (decl
) == lang_c
)
2663 SET_DECL_LANGUAGE (decl
, lang_cplusplus
);
2665 /* Put functions on the TYPE_METHODS list and everything else on the
2666 TYPE_FIELDS list. Note that these are built up in reverse order.
2667 We reverse them (to obtain declaration order) in finish_struct. */
2668 if (TREE_CODE (decl
) == FUNCTION_DECL
2669 || DECL_FUNCTION_TEMPLATE_P (decl
))
2671 /* We also need to add this function to the
2672 CLASSTYPE_METHOD_VEC. */
2673 if (add_method (current_class_type
, decl
, NULL_TREE
))
2675 DECL_CHAIN (decl
) = TYPE_METHODS (current_class_type
);
2676 TYPE_METHODS (current_class_type
) = decl
;
2678 maybe_add_class_template_decl_list (current_class_type
, decl
,
2682 /* Enter the DECL into the scope of the class. */
2683 else if (pushdecl_class_level (decl
))
2685 if (TREE_CODE (decl
) == USING_DECL
)
2687 /* For now, ignore class-scope USING_DECLS, so that
2688 debugging backends do not see them. */
2689 DECL_IGNORED_P (decl
) = 1;
2692 /* All TYPE_DECLs go at the end of TYPE_FIELDS. Ordinary fields
2693 go at the beginning. The reason is that lookup_field_1
2694 searches the list in order, and we want a field name to
2695 override a type name so that the "struct stat hack" will
2696 work. In particular:
2698 struct S { enum E { }; int E } s;
2701 is valid. In addition, the FIELD_DECLs must be maintained in
2702 declaration order so that class layout works as expected.
2703 However, we don't need that order until class layout, so we
2704 save a little time by putting FIELD_DECLs on in reverse order
2705 here, and then reversing them in finish_struct_1. (We could
2706 also keep a pointer to the correct insertion points in the
2709 if (TREE_CODE (decl
) == TYPE_DECL
)
2710 TYPE_FIELDS (current_class_type
)
2711 = chainon (TYPE_FIELDS (current_class_type
), decl
);
2714 DECL_CHAIN (decl
) = TYPE_FIELDS (current_class_type
);
2715 TYPE_FIELDS (current_class_type
) = decl
;
2718 maybe_add_class_template_decl_list (current_class_type
, decl
,
2723 note_decl_for_pch (decl
);
2726 /* DECL has been declared while we are building a PCH file. Perform
2727 actions that we might normally undertake lazily, but which can be
2728 performed now so that they do not have to be performed in
2729 translation units which include the PCH file. */
2732 note_decl_for_pch (tree decl
)
2734 gcc_assert (pch_file
);
2736 /* There's a good chance that we'll have to mangle names at some
2737 point, even if only for emission in debugging information. */
2738 if ((TREE_CODE (decl
) == VAR_DECL
2739 || TREE_CODE (decl
) == FUNCTION_DECL
)
2740 && !processing_template_decl
)
2744 /* Finish processing a complete template declaration. The PARMS are
2745 the template parameters. */
2748 finish_template_decl (tree parms
)
2751 end_template_decl ();
2753 end_specialization ();
2756 /* Finish processing a template-id (which names a type) of the form
2757 NAME < ARGS >. Return the TYPE_DECL for the type named by the
2758 template-id. If ENTERING_SCOPE is nonzero we are about to enter
2759 the scope of template-id indicated. */
2762 finish_template_type (tree name
, tree args
, int entering_scope
)
2766 type
= lookup_template_class (name
, args
,
2767 NULL_TREE
, NULL_TREE
, entering_scope
,
2768 tf_warning_or_error
| tf_user
);
2769 if (type
== error_mark_node
)
2771 else if (CLASS_TYPE_P (type
) && !alias_type_or_template_p (type
))
2772 return TYPE_STUB_DECL (type
);
2774 return TYPE_NAME (type
);
2777 /* Finish processing a BASE_CLASS with the indicated ACCESS_SPECIFIER.
2778 Return a TREE_LIST containing the ACCESS_SPECIFIER and the
2779 BASE_CLASS, or NULL_TREE if an error occurred. The
2780 ACCESS_SPECIFIER is one of
2781 access_{default,public,protected_private}_node. For a virtual base
2782 we set TREE_TYPE. */
2785 finish_base_specifier (tree base
, tree access
, bool virtual_p
)
2789 if (base
== error_mark_node
)
2791 error ("invalid base-class specification");
2794 else if (! MAYBE_CLASS_TYPE_P (base
))
2796 error ("%qT is not a class type", base
);
2801 if (cp_type_quals (base
) != 0)
2803 /* DR 484: Can a base-specifier name a cv-qualified
2805 base
= TYPE_MAIN_VARIANT (base
);
2807 result
= build_tree_list (access
, base
);
2809 TREE_TYPE (result
) = integer_type_node
;
2815 /* If FNS is a member function, a set of member functions, or a
2816 template-id referring to one or more member functions, return a
2817 BASELINK for FNS, incorporating the current access context.
2818 Otherwise, return FNS unchanged. */
2821 baselink_for_fns (tree fns
)
2826 if (BASELINK_P (fns
)
2827 || error_operand_p (fns
))
2830 scope
= ovl_scope (fns
);
2831 if (!CLASS_TYPE_P (scope
))
2834 cl
= currently_open_derived_class (scope
);
2837 cl
= TYPE_BINFO (cl
);
2838 return build_baselink (cl
, cl
, fns
, /*optype=*/NULL_TREE
);
2841 /* Returns true iff DECL is an automatic variable from a function outside
2845 outer_automatic_var_p (tree decl
)
2847 return ((TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == PARM_DECL
)
2848 && DECL_FUNCTION_SCOPE_P (decl
)
2849 && !TREE_STATIC (decl
)
2850 && DECL_CONTEXT (decl
) != current_function_decl
);
2853 /* ID_EXPRESSION is a representation of parsed, but unprocessed,
2854 id-expression. (See cp_parser_id_expression for details.) SCOPE,
2855 if non-NULL, is the type or namespace used to explicitly qualify
2856 ID_EXPRESSION. DECL is the entity to which that name has been
2859 *CONSTANT_EXPRESSION_P is true if we are presently parsing a
2860 constant-expression. In that case, *NON_CONSTANT_EXPRESSION_P will
2861 be set to true if this expression isn't permitted in a
2862 constant-expression, but it is otherwise not set by this function.
2863 *ALLOW_NON_CONSTANT_EXPRESSION_P is true if we are parsing a
2864 constant-expression, but a non-constant expression is also
2867 DONE is true if this expression is a complete postfix-expression;
2868 it is false if this expression is followed by '->', '[', '(', etc.
2869 ADDRESS_P is true iff this expression is the operand of '&'.
2870 TEMPLATE_P is true iff the qualified-id was of the form
2871 "A::template B". TEMPLATE_ARG_P is true iff this qualified name
2872 appears as a template argument.
2874 If an error occurs, and it is the kind of error that might cause
2875 the parser to abort a tentative parse, *ERROR_MSG is filled in. It
2876 is the caller's responsibility to issue the message. *ERROR_MSG
2877 will be a string with static storage duration, so the caller need
2880 Return an expression for the entity, after issuing appropriate
2881 diagnostics. This function is also responsible for transforming a
2882 reference to a non-static member into a COMPONENT_REF that makes
2883 the use of "this" explicit.
2885 Upon return, *IDK will be filled in appropriately. */
2887 finish_id_expression (tree id_expression
,
2891 bool integral_constant_expression_p
,
2892 bool allow_non_integral_constant_expression_p
,
2893 bool *non_integral_constant_expression_p
,
2897 bool template_arg_p
,
2898 const char **error_msg
,
2899 location_t location
)
2901 decl
= strip_using_decl (decl
);
2903 /* Initialize the output parameters. */
2904 *idk
= CP_ID_KIND_NONE
;
2907 if (id_expression
== error_mark_node
)
2908 return error_mark_node
;
2909 /* If we have a template-id, then no further lookup is
2910 required. If the template-id was for a template-class, we
2911 will sometimes have a TYPE_DECL at this point. */
2912 else if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
2913 || TREE_CODE (decl
) == TYPE_DECL
)
2915 /* Look up the name. */
2918 if (decl
== error_mark_node
)
2920 /* Name lookup failed. */
2923 || (!dependent_type_p (scope
)
2924 && !(TREE_CODE (id_expression
) == IDENTIFIER_NODE
2925 && IDENTIFIER_TYPENAME_P (id_expression
)
2926 && dependent_type_p (TREE_TYPE (id_expression
))))))
2928 /* If the qualifying type is non-dependent (and the name
2929 does not name a conversion operator to a dependent
2930 type), issue an error. */
2931 qualified_name_lookup_error (scope
, id_expression
, decl
, location
);
2932 return error_mark_node
;
2936 /* It may be resolved via Koenig lookup. */
2937 *idk
= CP_ID_KIND_UNQUALIFIED
;
2938 return id_expression
;
2941 decl
= id_expression
;
2943 /* If DECL is a variable that would be out of scope under
2944 ANSI/ISO rules, but in scope in the ARM, name lookup
2945 will succeed. Issue a diagnostic here. */
2947 decl
= check_for_out_of_scope_variable (decl
);
2949 /* Remember that the name was used in the definition of
2950 the current class so that we can check later to see if
2951 the meaning would have been different after the class
2952 was entirely defined. */
2953 if (!scope
&& decl
!= error_mark_node
2954 && TREE_CODE (id_expression
) == IDENTIFIER_NODE
)
2955 maybe_note_name_used_in_class (id_expression
, decl
);
2957 /* Disallow uses of local variables from containing functions, except
2958 within lambda-expressions. */
2959 if (outer_automatic_var_p (decl
)
2960 /* It's not a use (3.2) if we're in an unevaluated context. */
2961 && !cp_unevaluated_operand
)
2963 tree context
= DECL_CONTEXT (decl
);
2964 tree containing_function
= current_function_decl
;
2965 tree lambda_stack
= NULL_TREE
;
2966 tree lambda_expr
= NULL_TREE
;
2967 tree initializer
= convert_from_reference (decl
);
2969 /* Mark it as used now even if the use is ill-formed. */
2972 /* Core issue 696: "[At the July 2009 meeting] the CWG expressed
2973 support for an approach in which a reference to a local
2974 [constant] automatic variable in a nested class or lambda body
2975 would enter the expression as an rvalue, which would reduce
2976 the complexity of the problem"
2978 FIXME update for final resolution of core issue 696. */
2979 if (decl_constant_var_p (decl
))
2980 return integral_constant_value (decl
);
2982 /* If we are in a lambda function, we can move out until we hit
2984 2. a non-lambda function, or
2985 3. a non-default capturing lambda function. */
2986 while (context
!= containing_function
2987 && LAMBDA_FUNCTION_P (containing_function
))
2989 lambda_expr
= CLASSTYPE_LAMBDA_EXPR
2990 (DECL_CONTEXT (containing_function
));
2992 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr
)
2996 lambda_stack
= tree_cons (NULL_TREE
,
3001 = decl_function_context (containing_function
);
3004 if (context
== containing_function
)
3006 decl
= add_default_capture (lambda_stack
,
3007 /*id=*/DECL_NAME (decl
),
3010 else if (lambda_expr
)
3012 error ("%qD is not captured", decl
);
3013 return error_mark_node
;
3017 error (TREE_CODE (decl
) == VAR_DECL
3018 ? G_("use of %<auto%> variable from containing function")
3019 : G_("use of parameter from containing function"));
3020 error (" %q+#D declared here", decl
);
3021 return error_mark_node
;
3025 /* Also disallow uses of function parameters outside the function
3026 body, except inside an unevaluated context (i.e. decltype). */
3027 if (TREE_CODE (decl
) == PARM_DECL
3028 && DECL_CONTEXT (decl
) == NULL_TREE
3029 && !cp_unevaluated_operand
)
3031 error ("use of parameter %qD outside function body", decl
);
3032 return error_mark_node
;
3036 /* If we didn't find anything, or what we found was a type,
3037 then this wasn't really an id-expression. */
3038 if (TREE_CODE (decl
) == TEMPLATE_DECL
3039 && !DECL_FUNCTION_TEMPLATE_P (decl
))
3041 *error_msg
= "missing template arguments";
3042 return error_mark_node
;
3044 else if (TREE_CODE (decl
) == TYPE_DECL
3045 || TREE_CODE (decl
) == NAMESPACE_DECL
)
3047 *error_msg
= "expected primary-expression";
3048 return error_mark_node
;
3051 /* If the name resolved to a template parameter, there is no
3052 need to look it up again later. */
3053 if ((TREE_CODE (decl
) == CONST_DECL
&& DECL_TEMPLATE_PARM_P (decl
))
3054 || TREE_CODE (decl
) == TEMPLATE_PARM_INDEX
)
3058 *idk
= CP_ID_KIND_NONE
;
3059 if (TREE_CODE (decl
) == TEMPLATE_PARM_INDEX
)
3060 decl
= TEMPLATE_PARM_DECL (decl
);
3061 r
= convert_from_reference (DECL_INITIAL (decl
));
3063 if (integral_constant_expression_p
3064 && !dependent_type_p (TREE_TYPE (decl
))
3065 && !(INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (r
))))
3067 if (!allow_non_integral_constant_expression_p
)
3068 error ("template parameter %qD of type %qT is not allowed in "
3069 "an integral constant expression because it is not of "
3070 "integral or enumeration type", decl
, TREE_TYPE (decl
));
3071 *non_integral_constant_expression_p
= true;
3079 /* If the declaration was explicitly qualified indicate
3080 that. The semantics of `A::f(3)' are different than
3081 `f(3)' if `f' is virtual. */
3083 ? CP_ID_KIND_QUALIFIED
3084 : (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
3085 ? CP_ID_KIND_TEMPLATE_ID
3086 : CP_ID_KIND_UNQUALIFIED
));
3091 An id-expression is type-dependent if it contains an
3092 identifier that was declared with a dependent type.
3094 The standard is not very specific about an id-expression that
3095 names a set of overloaded functions. What if some of them
3096 have dependent types and some of them do not? Presumably,
3097 such a name should be treated as a dependent name. */
3098 /* Assume the name is not dependent. */
3099 dependent_p
= false;
3100 if (!processing_template_decl
)
3101 /* No names are dependent outside a template. */
3103 else if (TREE_CODE (decl
) == CONST_DECL
)
3104 /* We don't want to treat enumerators as dependent. */
3106 /* A template-id where the name of the template was not resolved
3107 is definitely dependent. */
3108 else if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
3109 && (TREE_CODE (TREE_OPERAND (decl
, 0))
3110 == IDENTIFIER_NODE
))
3112 /* For anything except an overloaded function, just check its
3114 else if (!is_overloaded_fn (decl
))
3116 = dependent_type_p (TREE_TYPE (decl
));
3117 /* For a set of overloaded functions, check each of the
3123 if (BASELINK_P (fns
))
3124 fns
= BASELINK_FUNCTIONS (fns
);
3126 /* For a template-id, check to see if the template
3127 arguments are dependent. */
3128 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
3130 tree args
= TREE_OPERAND (fns
, 1);
3131 dependent_p
= any_dependent_template_arguments_p (args
);
3132 /* The functions are those referred to by the
3134 fns
= TREE_OPERAND (fns
, 0);
3137 /* If there are no dependent template arguments, go through
3138 the overloaded functions. */
3139 while (fns
&& !dependent_p
)
3141 tree fn
= OVL_CURRENT (fns
);
3143 /* Member functions of dependent classes are
3145 if (TREE_CODE (fn
) == FUNCTION_DECL
3146 && type_dependent_expression_p (fn
))
3148 else if (TREE_CODE (fn
) == TEMPLATE_DECL
3149 && dependent_template_p (fn
))
3152 fns
= OVL_NEXT (fns
);
3156 /* If the name was dependent on a template parameter, we will
3157 resolve the name at instantiation time. */
3160 /* Create a SCOPE_REF for qualified names, if the scope is
3166 if (address_p
&& done
)
3167 decl
= finish_qualified_id_expr (scope
, decl
,
3173 tree type
= NULL_TREE
;
3174 if (DECL_P (decl
) && !dependent_scope_p (scope
))
3175 type
= TREE_TYPE (decl
);
3176 decl
= build_qualified_name (type
,
3182 if (TREE_TYPE (decl
))
3183 decl
= convert_from_reference (decl
);
3186 /* A TEMPLATE_ID already contains all the information we
3188 if (TREE_CODE (id_expression
) == TEMPLATE_ID_EXPR
)
3189 return id_expression
;
3190 *idk
= CP_ID_KIND_UNQUALIFIED_DEPENDENT
;
3191 /* If we found a variable, then name lookup during the
3192 instantiation will always resolve to the same VAR_DECL
3193 (or an instantiation thereof). */
3194 if (TREE_CODE (decl
) == VAR_DECL
3195 || TREE_CODE (decl
) == PARM_DECL
)
3198 return convert_from_reference (decl
);
3200 /* The same is true for FIELD_DECL, but we also need to
3201 make sure that the syntax is correct. */
3202 else if (TREE_CODE (decl
) == FIELD_DECL
)
3204 /* Since SCOPE is NULL here, this is an unqualified name.
3205 Access checking has been performed during name lookup
3206 already. Turn off checking to avoid duplicate errors. */
3207 push_deferring_access_checks (dk_no_check
);
3208 decl
= finish_non_static_data_member
3210 /*qualifying_scope=*/NULL_TREE
);
3211 pop_deferring_access_checks ();
3214 return id_expression
;
3217 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
3219 error ("use of namespace %qD as expression", decl
);
3220 return error_mark_node
;
3222 else if (DECL_CLASS_TEMPLATE_P (decl
))
3224 error ("use of class template %qT as expression", decl
);
3225 return error_mark_node
;
3227 else if (TREE_CODE (decl
) == TREE_LIST
)
3229 /* Ambiguous reference to base members. */
3230 error ("request for member %qD is ambiguous in "
3231 "multiple inheritance lattice", id_expression
);
3232 print_candidates (decl
);
3233 return error_mark_node
;
3236 /* Mark variable-like entities as used. Functions are similarly
3237 marked either below or after overload resolution. */
3238 if (TREE_CODE (decl
) == VAR_DECL
3239 || TREE_CODE (decl
) == PARM_DECL
3240 || TREE_CODE (decl
) == CONST_DECL
3241 || TREE_CODE (decl
) == RESULT_DECL
)
3244 /* Only certain kinds of names are allowed in constant
3245 expression. Template parameters have already
3246 been handled above. */
3247 if (! error_operand_p (decl
)
3248 && integral_constant_expression_p
3249 && ! decl_constant_var_p (decl
)
3250 && TREE_CODE (decl
) != CONST_DECL
3251 && ! builtin_valid_in_constant_expr_p (decl
))
3253 if (!allow_non_integral_constant_expression_p
)
3255 error ("%qD cannot appear in a constant-expression", decl
);
3256 return error_mark_node
;
3258 *non_integral_constant_expression_p
= true;
3263 decl
= (adjust_result_of_qualified_name_lookup
3264 (decl
, scope
, current_nonlambda_class_type()));
3266 if (TREE_CODE (decl
) == FUNCTION_DECL
)
3269 if (TREE_CODE (decl
) == FIELD_DECL
|| BASELINK_P (decl
))
3270 decl
= finish_qualified_id_expr (scope
,
3278 tree r
= convert_from_reference (decl
);
3280 /* In a template, return a SCOPE_REF for most qualified-ids
3281 so that we can check access at instantiation time. But if
3282 we're looking at a member of the current instantiation, we
3283 know we have access and building up the SCOPE_REF confuses
3284 non-type template argument handling. */
3285 if (processing_template_decl
&& TYPE_P (scope
)
3286 && !currently_open_class (scope
))
3287 r
= build_qualified_name (TREE_TYPE (r
),
3293 else if (TREE_CODE (decl
) == FIELD_DECL
)
3295 /* Since SCOPE is NULL here, this is an unqualified name.
3296 Access checking has been performed during name lookup
3297 already. Turn off checking to avoid duplicate errors. */
3298 push_deferring_access_checks (dk_no_check
);
3299 decl
= finish_non_static_data_member (decl
, NULL_TREE
,
3300 /*qualifying_scope=*/NULL_TREE
);
3301 pop_deferring_access_checks ();
3303 else if (is_overloaded_fn (decl
))
3307 first_fn
= get_first_fn (decl
);
3308 if (TREE_CODE (first_fn
) == TEMPLATE_DECL
)
3309 first_fn
= DECL_TEMPLATE_RESULT (first_fn
);
3311 if (!really_overloaded_fn (decl
)
3312 && !mark_used (first_fn
))
3313 return error_mark_node
;
3316 && TREE_CODE (first_fn
) == FUNCTION_DECL
3317 && DECL_FUNCTION_MEMBER_P (first_fn
)
3318 && !shared_member_p (decl
))
3320 /* A set of member functions. */
3321 decl
= maybe_dummy_object (DECL_CONTEXT (first_fn
), 0);
3322 return finish_class_member_access_expr (decl
, id_expression
,
3323 /*template_p=*/false,
3324 tf_warning_or_error
);
3327 decl
= baselink_for_fns (decl
);
3331 if (DECL_P (decl
) && DECL_NONLOCAL (decl
)
3332 && DECL_CLASS_SCOPE_P (decl
))
3334 tree context
= context_for_name_lookup (decl
);
3335 if (context
!= current_class_type
)
3337 tree path
= currently_open_derived_class (context
);
3338 perform_or_defer_access_check (TYPE_BINFO (path
),
3343 decl
= convert_from_reference (decl
);
3347 if (TREE_DEPRECATED (decl
))
3348 warn_deprecated_use (decl
, NULL_TREE
);
3353 /* Implement the __typeof keyword: Return the type of EXPR, suitable for
3354 use as a type-specifier. */
3357 finish_typeof (tree expr
)
3361 if (type_dependent_expression_p (expr
))
3363 type
= cxx_make_type (TYPEOF_TYPE
);
3364 TYPEOF_TYPE_EXPR (type
) = expr
;
3365 SET_TYPE_STRUCTURAL_EQUALITY (type
);
3370 expr
= mark_type_use (expr
);
3372 type
= unlowered_expr_type (expr
);
3374 if (!type
|| type
== unknown_type_node
)
3376 error ("type of %qE is unknown", expr
);
3377 return error_mark_node
;
3383 /* Implement the __underlying_type keyword: Return the underlying
3384 type of TYPE, suitable for use as a type-specifier. */
3387 finish_underlying_type (tree type
)
3389 tree underlying_type
;
3391 if (processing_template_decl
)
3393 underlying_type
= cxx_make_type (UNDERLYING_TYPE
);
3394 UNDERLYING_TYPE_TYPE (underlying_type
) = type
;
3395 SET_TYPE_STRUCTURAL_EQUALITY (underlying_type
);
3397 return underlying_type
;
3400 complete_type (type
);
3402 if (TREE_CODE (type
) != ENUMERAL_TYPE
)
3404 error ("%qT is not an enumeration type", type
);
3405 return error_mark_node
;
3408 underlying_type
= ENUM_UNDERLYING_TYPE (type
);
3410 /* Fixup necessary in this case because ENUM_UNDERLYING_TYPE
3411 includes TYPE_MIN_VALUE and TYPE_MAX_VALUE information.
3412 See finish_enum_value_list for details. */
3413 if (!ENUM_FIXED_UNDERLYING_TYPE_P (type
))
3415 = c_common_type_for_mode (TYPE_MODE (underlying_type
),
3416 TYPE_UNSIGNED (underlying_type
));
3418 return underlying_type
;
3421 /* Implement the __direct_bases keyword: Return the direct base classes
3425 calculate_direct_bases (tree type
)
3427 VEC(tree
, gc
) *vector
= make_tree_vector();
3428 tree bases_vec
= NULL_TREE
;
3429 VEC(tree
, none
) *base_binfos
;
3433 complete_type (type
);
3435 if (!NON_UNION_CLASS_TYPE_P (type
))
3436 return make_tree_vec (0);
3438 base_binfos
= BINFO_BASE_BINFOS (TYPE_BINFO (type
));
3440 /* Virtual bases are initialized first */
3441 for (i
= 0; VEC_iterate (tree
, base_binfos
, i
, binfo
); i
++)
3443 if (BINFO_VIRTUAL_P (binfo
))
3445 VEC_safe_push (tree
, gc
, vector
, binfo
);
3449 /* Now non-virtuals */
3450 for (i
= 0; VEC_iterate (tree
, base_binfos
, i
, binfo
); i
++)
3452 if (!BINFO_VIRTUAL_P (binfo
))
3454 VEC_safe_push (tree
, gc
, vector
, binfo
);
3459 bases_vec
= make_tree_vec (VEC_length (tree
, vector
));
3461 for (i
= 0; i
< VEC_length (tree
, vector
); ++i
)
3463 TREE_VEC_ELT (bases_vec
, i
) = BINFO_TYPE (VEC_index (tree
, vector
, i
));
3468 /* Implement the __bases keyword: Return the base classes
3471 /* Find morally non-virtual base classes by walking binfo hierarchy */
3472 /* Virtual base classes are handled separately in finish_bases */
3475 dfs_calculate_bases_pre (tree binfo
, ATTRIBUTE_UNUSED
void *data_
)
3477 /* Don't walk bases of virtual bases */
3478 return BINFO_VIRTUAL_P (binfo
) ? dfs_skip_bases
: NULL_TREE
;
3482 dfs_calculate_bases_post (tree binfo
, void *data_
)
3484 VEC(tree
, gc
) **data
= (VEC(tree
, gc
) **) data_
;
3485 if (!BINFO_VIRTUAL_P (binfo
))
3487 VEC_safe_push (tree
, gc
, *data
, BINFO_TYPE (binfo
));
3492 /* Calculates the morally non-virtual base classes of a class */
3493 static VEC(tree
, gc
) *
3494 calculate_bases_helper (tree type
)
3496 VEC(tree
, gc
) *vector
= make_tree_vector();
3498 /* Now add non-virtual base classes in order of construction */
3499 dfs_walk_all (TYPE_BINFO (type
),
3500 dfs_calculate_bases_pre
, dfs_calculate_bases_post
, &vector
);
3505 calculate_bases (tree type
)
3507 VEC(tree
, gc
) *vector
= make_tree_vector();
3508 tree bases_vec
= NULL_TREE
;
3510 VEC(tree
, gc
) *vbases
;
3511 VEC(tree
, gc
) *nonvbases
;
3514 complete_type (type
);
3516 if (!NON_UNION_CLASS_TYPE_P (type
))
3517 return make_tree_vec (0);
3519 /* First go through virtual base classes */
3520 for (vbases
= CLASSTYPE_VBASECLASSES (type
), i
= 0;
3521 VEC_iterate (tree
, vbases
, i
, binfo
); i
++)
3523 VEC(tree
, gc
) *vbase_bases
= calculate_bases_helper (BINFO_TYPE (binfo
));
3524 VEC_safe_splice (tree
, gc
, vector
, vbase_bases
);
3525 release_tree_vector (vbase_bases
);
3528 /* Now for the non-virtual bases */
3529 nonvbases
= calculate_bases_helper (type
);
3530 VEC_safe_splice (tree
, gc
, vector
, nonvbases
);
3531 release_tree_vector (nonvbases
);
3533 /* Last element is entire class, so don't copy */
3534 bases_vec
= make_tree_vec (VEC_length (tree
, vector
) - 1);
3536 for (i
= 0; i
< VEC_length (tree
, vector
) - 1; ++i
)
3538 TREE_VEC_ELT (bases_vec
, i
) = VEC_index (tree
, vector
, i
);
3540 release_tree_vector (vector
);
3545 finish_bases (tree type
, bool direct
)
3547 tree bases
= NULL_TREE
;
3549 if (!processing_template_decl
)
3551 /* Parameter packs can only be used in templates */
3552 error ("Parameter pack __bases only valid in template declaration");
3553 return error_mark_node
;
3556 bases
= cxx_make_type (BASES
);
3557 BASES_TYPE (bases
) = type
;
3558 BASES_DIRECT (bases
) = direct
;
3559 SET_TYPE_STRUCTURAL_EQUALITY (bases
);
3564 /* Perform C++-specific checks for __builtin_offsetof before calling
3568 finish_offsetof (tree expr
)
3570 if (TREE_CODE (expr
) == PSEUDO_DTOR_EXPR
)
3572 error ("cannot apply %<offsetof%> to destructor %<~%T%>",
3573 TREE_OPERAND (expr
, 2));
3574 return error_mark_node
;
3576 if (TREE_CODE (TREE_TYPE (expr
)) == FUNCTION_TYPE
3577 || TREE_CODE (TREE_TYPE (expr
)) == METHOD_TYPE
3578 || TREE_TYPE (expr
) == unknown_type_node
)
3580 if (TREE_CODE (expr
) == COMPONENT_REF
3581 || TREE_CODE (expr
) == COMPOUND_EXPR
)
3582 expr
= TREE_OPERAND (expr
, 1);
3583 error ("cannot apply %<offsetof%> to member function %qD", expr
);
3584 return error_mark_node
;
3586 if (REFERENCE_REF_P (expr
))
3587 expr
= TREE_OPERAND (expr
, 0);
3588 if (TREE_CODE (expr
) == COMPONENT_REF
)
3590 tree object
= TREE_OPERAND (expr
, 0);
3591 if (!complete_type_or_else (TREE_TYPE (object
), object
))
3592 return error_mark_node
;
3594 return fold_offsetof (expr
);
3597 /* Replace the AGGR_INIT_EXPR at *TP with an equivalent CALL_EXPR. This
3598 function is broken out from the above for the benefit of the tree-ssa
3602 simplify_aggr_init_expr (tree
*tp
)
3604 tree aggr_init_expr
= *tp
;
3606 /* Form an appropriate CALL_EXPR. */
3607 tree fn
= AGGR_INIT_EXPR_FN (aggr_init_expr
);
3608 tree slot
= AGGR_INIT_EXPR_SLOT (aggr_init_expr
);
3609 tree type
= TREE_TYPE (slot
);
3612 enum style_t
{ ctor
, arg
, pcc
} style
;
3614 if (AGGR_INIT_VIA_CTOR_P (aggr_init_expr
))
3616 #ifdef PCC_STATIC_STRUCT_RETURN
3622 gcc_assert (TREE_ADDRESSABLE (type
));
3626 call_expr
= build_call_array_loc (input_location
,
3627 TREE_TYPE (TREE_TYPE (TREE_TYPE (fn
))),
3629 aggr_init_expr_nargs (aggr_init_expr
),
3630 AGGR_INIT_EXPR_ARGP (aggr_init_expr
));
3631 TREE_NOTHROW (call_expr
) = TREE_NOTHROW (aggr_init_expr
);
3635 /* Replace the first argument to the ctor with the address of the
3637 cxx_mark_addressable (slot
);
3638 CALL_EXPR_ARG (call_expr
, 0) =
3639 build1 (ADDR_EXPR
, build_pointer_type (type
), slot
);
3641 else if (style
== arg
)
3643 /* Just mark it addressable here, and leave the rest to
3644 expand_call{,_inline}. */
3645 cxx_mark_addressable (slot
);
3646 CALL_EXPR_RETURN_SLOT_OPT (call_expr
) = true;
3647 call_expr
= build2 (INIT_EXPR
, TREE_TYPE (call_expr
), slot
, call_expr
);
3649 else if (style
== pcc
)
3651 /* If we're using the non-reentrant PCC calling convention, then we
3652 need to copy the returned value out of the static buffer into the
3654 push_deferring_access_checks (dk_no_check
);
3655 call_expr
= build_aggr_init (slot
, call_expr
,
3656 DIRECT_BIND
| LOOKUP_ONLYCONVERTING
,
3657 tf_warning_or_error
);
3658 pop_deferring_access_checks ();
3659 call_expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (slot
), call_expr
, slot
);
3662 if (AGGR_INIT_ZERO_FIRST (aggr_init_expr
))
3664 tree init
= build_zero_init (type
, NULL_TREE
,
3665 /*static_storage_p=*/false);
3666 init
= build2 (INIT_EXPR
, void_type_node
, slot
, init
);
3667 call_expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (call_expr
),
3674 /* Emit all thunks to FN that should be emitted when FN is emitted. */
3677 emit_associated_thunks (tree fn
)
3679 /* When we use vcall offsets, we emit thunks with the virtual
3680 functions to which they thunk. The whole point of vcall offsets
3681 is so that you can know statically the entire set of thunks that
3682 will ever be needed for a given virtual function, thereby
3683 enabling you to output all the thunks with the function itself. */
3684 if (DECL_VIRTUAL_P (fn
)
3685 /* Do not emit thunks for extern template instantiations. */
3686 && ! DECL_REALLY_EXTERN (fn
))
3690 for (thunk
= DECL_THUNKS (fn
); thunk
; thunk
= DECL_CHAIN (thunk
))
3692 if (!THUNK_ALIAS (thunk
))
3694 use_thunk (thunk
, /*emit_p=*/1);
3695 if (DECL_RESULT_THUNK_P (thunk
))
3699 for (probe
= DECL_THUNKS (thunk
);
3700 probe
; probe
= DECL_CHAIN (probe
))
3701 use_thunk (probe
, /*emit_p=*/1);
3705 gcc_assert (!DECL_THUNKS (thunk
));
3710 /* Returns true iff FUN is an instantiation of a constexpr function
3714 is_instantiation_of_constexpr (tree fun
)
3716 return (DECL_TEMPLOID_INSTANTIATION (fun
)
3717 && DECL_DECLARED_CONSTEXPR_P (DECL_TEMPLATE_RESULT
3718 (DECL_TI_TEMPLATE (fun
))));
3721 /* Generate RTL for FN. */
3724 expand_or_defer_fn_1 (tree fn
)
3726 /* When the parser calls us after finishing the body of a template
3727 function, we don't really want to expand the body. */
3728 if (processing_template_decl
)
3730 /* Normally, collection only occurs in rest_of_compilation. So,
3731 if we don't collect here, we never collect junk generated
3732 during the processing of templates until we hit a
3733 non-template function. It's not safe to do this inside a
3734 nested class, though, as the parser may have local state that
3735 is not a GC root. */
3736 if (!function_depth
)
3741 gcc_assert (DECL_SAVED_TREE (fn
));
3743 /* If this is a constructor or destructor body, we have to clone
3745 if (maybe_clone_body (fn
))
3747 /* We don't want to process FN again, so pretend we've written
3748 it out, even though we haven't. */
3749 TREE_ASM_WRITTEN (fn
) = 1;
3750 /* If this is an instantiation of a constexpr function, keep
3751 DECL_SAVED_TREE for explain_invalid_constexpr_fn. */
3752 if (!is_instantiation_of_constexpr (fn
))
3753 DECL_SAVED_TREE (fn
) = NULL_TREE
;
3757 /* We make a decision about linkage for these functions at the end
3758 of the compilation. Until that point, we do not want the back
3759 end to output them -- but we do want it to see the bodies of
3760 these functions so that it can inline them as appropriate. */
3761 if (DECL_DECLARED_INLINE_P (fn
) || DECL_IMPLICIT_INSTANTIATION (fn
))
3763 if (DECL_INTERFACE_KNOWN (fn
))
3764 /* We've already made a decision as to how this function will
3768 DECL_EXTERNAL (fn
) = 1;
3769 DECL_NOT_REALLY_EXTERN (fn
) = 1;
3770 note_vague_linkage_fn (fn
);
3771 /* A non-template inline function with external linkage will
3772 always be COMDAT. As we must eventually determine the
3773 linkage of all functions, and as that causes writes to
3774 the data mapped in from the PCH file, it's advantageous
3775 to mark the functions at this point. */
3776 if (!DECL_IMPLICIT_INSTANTIATION (fn
))
3778 /* This function must have external linkage, as
3779 otherwise DECL_INTERFACE_KNOWN would have been
3781 gcc_assert (TREE_PUBLIC (fn
));
3782 comdat_linkage (fn
);
3783 DECL_INTERFACE_KNOWN (fn
) = 1;
3787 import_export_decl (fn
);
3789 /* If the user wants us to keep all inline functions, then mark
3790 this function as needed so that finish_file will make sure to
3791 output it later. Similarly, all dllexport'd functions must
3792 be emitted; there may be callers in other DLLs. */
3793 if ((flag_keep_inline_functions
3794 && DECL_DECLARED_INLINE_P (fn
)
3795 && !DECL_REALLY_EXTERN (fn
))
3796 || (flag_keep_inline_dllexport
3797 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (fn
))))
3800 DECL_EXTERNAL (fn
) = 0;
3804 /* There's no reason to do any of the work here if we're only doing
3805 semantic analysis; this code just generates RTL. */
3806 if (flag_syntax_only
)
3813 expand_or_defer_fn (tree fn
)
3815 if (expand_or_defer_fn_1 (fn
))
3819 /* Expand or defer, at the whim of the compilation unit manager. */
3820 cgraph_finalize_function (fn
, function_depth
> 1);
3821 emit_associated_thunks (fn
);
3834 /* Helper function for walk_tree, used by finalize_nrv below. */
3837 finalize_nrv_r (tree
* tp
, int* walk_subtrees
, void* data
)
3839 struct nrv_data
*dp
= (struct nrv_data
*)data
;
3842 /* No need to walk into types. There wouldn't be any need to walk into
3843 non-statements, except that we have to consider STMT_EXPRs. */
3846 /* Change all returns to just refer to the RESULT_DECL; this is a nop,
3847 but differs from using NULL_TREE in that it indicates that we care
3848 about the value of the RESULT_DECL. */
3849 else if (TREE_CODE (*tp
) == RETURN_EXPR
)
3850 TREE_OPERAND (*tp
, 0) = dp
->result
;
3851 /* Change all cleanups for the NRV to only run when an exception is
3853 else if (TREE_CODE (*tp
) == CLEANUP_STMT
3854 && CLEANUP_DECL (*tp
) == dp
->var
)
3855 CLEANUP_EH_ONLY (*tp
) = 1;
3856 /* Replace the DECL_EXPR for the NRV with an initialization of the
3857 RESULT_DECL, if needed. */
3858 else if (TREE_CODE (*tp
) == DECL_EXPR
3859 && DECL_EXPR_DECL (*tp
) == dp
->var
)
3862 if (DECL_INITIAL (dp
->var
)
3863 && DECL_INITIAL (dp
->var
) != error_mark_node
)
3864 init
= build2 (INIT_EXPR
, void_type_node
, dp
->result
,
3865 DECL_INITIAL (dp
->var
));
3867 init
= build_empty_stmt (EXPR_LOCATION (*tp
));
3868 DECL_INITIAL (dp
->var
) = NULL_TREE
;
3869 SET_EXPR_LOCATION (init
, EXPR_LOCATION (*tp
));
3872 /* And replace all uses of the NRV with the RESULT_DECL. */
3873 else if (*tp
== dp
->var
)
3876 /* Avoid walking into the same tree more than once. Unfortunately, we
3877 can't just use walk_tree_without duplicates because it would only call
3878 us for the first occurrence of dp->var in the function body. */
3879 slot
= htab_find_slot (dp
->visited
, *tp
, INSERT
);
3885 /* Keep iterating. */
3889 /* Called from finish_function to implement the named return value
3890 optimization by overriding all the RETURN_EXPRs and pertinent
3891 CLEANUP_STMTs and replacing all occurrences of VAR with RESULT, the
3892 RESULT_DECL for the function. */
3895 finalize_nrv (tree
*tp
, tree var
, tree result
)
3897 struct nrv_data data
;
3899 /* Copy name from VAR to RESULT. */
3900 DECL_NAME (result
) = DECL_NAME (var
);
3901 /* Don't forget that we take its address. */
3902 TREE_ADDRESSABLE (result
) = TREE_ADDRESSABLE (var
);
3903 /* Finally set DECL_VALUE_EXPR to avoid assigning
3904 a stack slot at -O0 for the original var and debug info
3905 uses RESULT location for VAR. */
3906 SET_DECL_VALUE_EXPR (var
, result
);
3907 DECL_HAS_VALUE_EXPR_P (var
) = 1;
3910 data
.result
= result
;
3911 data
.visited
= htab_create (37, htab_hash_pointer
, htab_eq_pointer
, NULL
);
3912 cp_walk_tree (tp
, finalize_nrv_r
, &data
, 0);
3913 htab_delete (data
.visited
);
3916 /* Create CP_OMP_CLAUSE_INFO for clause C. Returns true if it is invalid. */
3919 cxx_omp_create_clause_info (tree c
, tree type
, bool need_default_ctor
,
3920 bool need_copy_ctor
, bool need_copy_assignment
)
3922 int save_errorcount
= errorcount
;
3925 /* Always allocate 3 elements for simplicity. These are the
3926 function decls for the ctor, dtor, and assignment op.
3927 This layout is known to the three lang hooks,
3928 cxx_omp_clause_default_init, cxx_omp_clause_copy_init,
3929 and cxx_omp_clause_assign_op. */
3930 info
= make_tree_vec (3);
3931 CP_OMP_CLAUSE_INFO (c
) = info
;
3933 if (need_default_ctor
|| need_copy_ctor
)
3935 if (need_default_ctor
)
3936 t
= get_default_ctor (type
);
3938 t
= get_copy_ctor (type
, tf_warning_or_error
);
3940 if (t
&& !trivial_fn_p (t
))
3941 TREE_VEC_ELT (info
, 0) = t
;
3944 if ((need_default_ctor
|| need_copy_ctor
)
3945 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
3946 TREE_VEC_ELT (info
, 1) = get_dtor (type
, tf_warning_or_error
);
3948 if (need_copy_assignment
)
3950 t
= get_copy_assign (type
);
3952 if (t
&& !trivial_fn_p (t
))
3953 TREE_VEC_ELT (info
, 2) = t
;
3956 return errorcount
!= save_errorcount
;
3959 /* For all elements of CLAUSES, validate them vs OpenMP constraints.
3960 Remove any elements from the list that are invalid. */
3963 finish_omp_clauses (tree clauses
)
3965 bitmap_head generic_head
, firstprivate_head
, lastprivate_head
;
3966 tree c
, t
, *pc
= &clauses
;
3969 bitmap_obstack_initialize (NULL
);
3970 bitmap_initialize (&generic_head
, &bitmap_default_obstack
);
3971 bitmap_initialize (&firstprivate_head
, &bitmap_default_obstack
);
3972 bitmap_initialize (&lastprivate_head
, &bitmap_default_obstack
);
3974 for (pc
= &clauses
, c
= clauses
; c
; c
= *pc
)
3976 bool remove
= false;
3978 switch (OMP_CLAUSE_CODE (c
))
3980 case OMP_CLAUSE_SHARED
:
3982 goto check_dup_generic
;
3983 case OMP_CLAUSE_PRIVATE
:
3985 goto check_dup_generic
;
3986 case OMP_CLAUSE_REDUCTION
:
3988 goto check_dup_generic
;
3989 case OMP_CLAUSE_COPYPRIVATE
:
3990 name
= "copyprivate";
3991 goto check_dup_generic
;
3992 case OMP_CLAUSE_COPYIN
:
3994 goto check_dup_generic
;
3996 t
= OMP_CLAUSE_DECL (c
);
3997 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
3999 if (processing_template_decl
)
4002 error ("%qD is not a variable in clause %qs", t
, name
);
4004 error ("%qE is not a variable in clause %qs", t
, name
);
4007 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
4008 || bitmap_bit_p (&firstprivate_head
, DECL_UID (t
))
4009 || bitmap_bit_p (&lastprivate_head
, DECL_UID (t
)))
4011 error ("%qD appears more than once in data clauses", t
);
4015 bitmap_set_bit (&generic_head
, DECL_UID (t
));
4018 case OMP_CLAUSE_FIRSTPRIVATE
:
4019 t
= OMP_CLAUSE_DECL (c
);
4020 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
4022 if (processing_template_decl
)
4025 error ("%qD is not a variable in clause %<firstprivate%>", t
);
4027 error ("%qE is not a variable in clause %<firstprivate%>", t
);
4030 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
4031 || bitmap_bit_p (&firstprivate_head
, DECL_UID (t
)))
4033 error ("%qD appears more than once in data clauses", t
);
4037 bitmap_set_bit (&firstprivate_head
, DECL_UID (t
));
4040 case OMP_CLAUSE_LASTPRIVATE
:
4041 t
= OMP_CLAUSE_DECL (c
);
4042 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
4044 if (processing_template_decl
)
4047 error ("%qD is not a variable in clause %<lastprivate%>", t
);
4049 error ("%qE is not a variable in clause %<lastprivate%>", t
);
4052 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
4053 || bitmap_bit_p (&lastprivate_head
, DECL_UID (t
)))
4055 error ("%qD appears more than once in data clauses", t
);
4059 bitmap_set_bit (&lastprivate_head
, DECL_UID (t
));
4063 t
= OMP_CLAUSE_IF_EXPR (c
);
4064 t
= maybe_convert_cond (t
);
4065 if (t
== error_mark_node
)
4067 else if (!processing_template_decl
)
4068 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4069 OMP_CLAUSE_IF_EXPR (c
) = t
;
4072 case OMP_CLAUSE_FINAL
:
4073 t
= OMP_CLAUSE_FINAL_EXPR (c
);
4074 t
= maybe_convert_cond (t
);
4075 if (t
== error_mark_node
)
4077 else if (!processing_template_decl
)
4078 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4079 OMP_CLAUSE_FINAL_EXPR (c
) = t
;
4082 case OMP_CLAUSE_NUM_THREADS
:
4083 t
= OMP_CLAUSE_NUM_THREADS_EXPR (c
);
4084 if (t
== error_mark_node
)
4086 else if (!type_dependent_expression_p (t
)
4087 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
4089 error ("num_threads expression must be integral");
4094 t
= mark_rvalue_use (t
);
4095 if (!processing_template_decl
)
4096 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4097 OMP_CLAUSE_NUM_THREADS_EXPR (c
) = t
;
4101 case OMP_CLAUSE_SCHEDULE
:
4102 t
= OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c
);
4105 else if (t
== error_mark_node
)
4107 else if (!type_dependent_expression_p (t
)
4108 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
4110 error ("schedule chunk size expression must be integral");
4115 t
= mark_rvalue_use (t
);
4116 if (!processing_template_decl
)
4117 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4118 OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c
) = t
;
4122 case OMP_CLAUSE_NOWAIT
:
4123 case OMP_CLAUSE_ORDERED
:
4124 case OMP_CLAUSE_DEFAULT
:
4125 case OMP_CLAUSE_UNTIED
:
4126 case OMP_CLAUSE_COLLAPSE
:
4127 case OMP_CLAUSE_MERGEABLE
:
4135 *pc
= OMP_CLAUSE_CHAIN (c
);
4137 pc
= &OMP_CLAUSE_CHAIN (c
);
4140 for (pc
= &clauses
, c
= clauses
; c
; c
= *pc
)
4142 enum omp_clause_code c_kind
= OMP_CLAUSE_CODE (c
);
4143 bool remove
= false;
4144 bool need_complete_non_reference
= false;
4145 bool need_default_ctor
= false;
4146 bool need_copy_ctor
= false;
4147 bool need_copy_assignment
= false;
4148 bool need_implicitly_determined
= false;
4149 tree type
, inner_type
;
4153 case OMP_CLAUSE_SHARED
:
4155 need_implicitly_determined
= true;
4157 case OMP_CLAUSE_PRIVATE
:
4159 need_complete_non_reference
= true;
4160 need_default_ctor
= true;
4161 need_implicitly_determined
= true;
4163 case OMP_CLAUSE_FIRSTPRIVATE
:
4164 name
= "firstprivate";
4165 need_complete_non_reference
= true;
4166 need_copy_ctor
= true;
4167 need_implicitly_determined
= true;
4169 case OMP_CLAUSE_LASTPRIVATE
:
4170 name
= "lastprivate";
4171 need_complete_non_reference
= true;
4172 need_copy_assignment
= true;
4173 need_implicitly_determined
= true;
4175 case OMP_CLAUSE_REDUCTION
:
4177 need_implicitly_determined
= true;
4179 case OMP_CLAUSE_COPYPRIVATE
:
4180 name
= "copyprivate";
4181 need_copy_assignment
= true;
4183 case OMP_CLAUSE_COPYIN
:
4185 need_copy_assignment
= true;
4188 pc
= &OMP_CLAUSE_CHAIN (c
);
4192 t
= OMP_CLAUSE_DECL (c
);
4193 if (processing_template_decl
4194 && TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
4196 pc
= &OMP_CLAUSE_CHAIN (c
);
4202 case OMP_CLAUSE_LASTPRIVATE
:
4203 if (!bitmap_bit_p (&firstprivate_head
, DECL_UID (t
)))
4204 need_default_ctor
= true;
4207 case OMP_CLAUSE_REDUCTION
:
4208 if (AGGREGATE_TYPE_P (TREE_TYPE (t
))
4209 || POINTER_TYPE_P (TREE_TYPE (t
)))
4211 error ("%qE has invalid type for %<reduction%>", t
);
4214 else if (FLOAT_TYPE_P (TREE_TYPE (t
)))
4216 enum tree_code r_code
= OMP_CLAUSE_REDUCTION_CODE (c
);
4226 error ("%qE has invalid type for %<reduction(%s)%>",
4227 t
, operator_name_info
[r_code
].name
);
4233 case OMP_CLAUSE_COPYIN
:
4234 if (TREE_CODE (t
) != VAR_DECL
|| !DECL_THREAD_LOCAL_P (t
))
4236 error ("%qE must be %<threadprivate%> for %<copyin%>", t
);
4245 if (need_complete_non_reference
|| need_copy_assignment
)
4247 t
= require_complete_type (t
);
4248 if (t
== error_mark_node
)
4250 else if (TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
4251 && need_complete_non_reference
)
4253 error ("%qE has reference type for %qs", t
, name
);
4257 if (need_implicitly_determined
)
4259 const char *share_name
= NULL
;
4261 if (TREE_CODE (t
) == VAR_DECL
&& DECL_THREAD_LOCAL_P (t
))
4262 share_name
= "threadprivate";
4263 else switch (cxx_omp_predetermined_sharing (t
))
4265 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
4267 case OMP_CLAUSE_DEFAULT_SHARED
:
4268 /* const vars may be specified in firstprivate clause. */
4269 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
4270 && cxx_omp_const_qual_no_mutable (t
))
4272 share_name
= "shared";
4274 case OMP_CLAUSE_DEFAULT_PRIVATE
:
4275 share_name
= "private";
4282 error ("%qE is predetermined %qs for %qs",
4283 t
, share_name
, name
);
4288 /* We're interested in the base element, not arrays. */
4289 inner_type
= type
= TREE_TYPE (t
);
4290 while (TREE_CODE (inner_type
) == ARRAY_TYPE
)
4291 inner_type
= TREE_TYPE (inner_type
);
4293 /* Check for special function availability by building a call to one.
4294 Save the results, because later we won't be in the right context
4295 for making these queries. */
4296 if (CLASS_TYPE_P (inner_type
)
4297 && COMPLETE_TYPE_P (inner_type
)
4298 && (need_default_ctor
|| need_copy_ctor
|| need_copy_assignment
)
4299 && !type_dependent_expression_p (t
)
4300 && cxx_omp_create_clause_info (c
, inner_type
, need_default_ctor
,
4301 need_copy_ctor
, need_copy_assignment
))
4305 *pc
= OMP_CLAUSE_CHAIN (c
);
4307 pc
= &OMP_CLAUSE_CHAIN (c
);
4310 bitmap_obstack_release (NULL
);
4314 /* For all variables in the tree_list VARS, mark them as thread local. */
4317 finish_omp_threadprivate (tree vars
)
4321 /* Mark every variable in VARS to be assigned thread local storage. */
4322 for (t
= vars
; t
; t
= TREE_CHAIN (t
))
4324 tree v
= TREE_PURPOSE (t
);
4326 if (error_operand_p (v
))
4328 else if (TREE_CODE (v
) != VAR_DECL
)
4329 error ("%<threadprivate%> %qD is not file, namespace "
4330 "or block scope variable", v
);
4331 /* If V had already been marked threadprivate, it doesn't matter
4332 whether it had been used prior to this point. */
4333 else if (TREE_USED (v
)
4334 && (DECL_LANG_SPECIFIC (v
) == NULL
4335 || !CP_DECL_THREADPRIVATE_P (v
)))
4336 error ("%qE declared %<threadprivate%> after first use", v
);
4337 else if (! TREE_STATIC (v
) && ! DECL_EXTERNAL (v
))
4338 error ("automatic variable %qE cannot be %<threadprivate%>", v
);
4339 else if (! COMPLETE_TYPE_P (TREE_TYPE (v
)))
4340 error ("%<threadprivate%> %qE has incomplete type", v
);
4341 else if (TREE_STATIC (v
) && TYPE_P (CP_DECL_CONTEXT (v
))
4342 && CP_DECL_CONTEXT (v
) != current_class_type
)
4343 error ("%<threadprivate%> %qE directive not "
4344 "in %qT definition", v
, CP_DECL_CONTEXT (v
));
4347 /* Allocate a LANG_SPECIFIC structure for V, if needed. */
4348 if (DECL_LANG_SPECIFIC (v
) == NULL
)
4350 retrofit_lang_decl (v
);
4352 /* Make sure that DECL_DISCRIMINATOR_P continues to be true
4353 after the allocation of the lang_decl structure. */
4354 if (DECL_DISCRIMINATOR_P (v
))
4355 DECL_LANG_SPECIFIC (v
)->u
.base
.u2sel
= 1;
4358 if (! DECL_THREAD_LOCAL_P (v
))
4360 DECL_TLS_MODEL (v
) = decl_default_tls_model (v
);
4361 /* If rtl has been already set for this var, call
4362 make_decl_rtl once again, so that encode_section_info
4363 has a chance to look at the new decl flags. */
4364 if (DECL_RTL_SET_P (v
))
4367 CP_DECL_THREADPRIVATE_P (v
) = 1;
4372 /* Build an OpenMP structured block. */
4375 begin_omp_structured_block (void)
4377 return do_pushlevel (sk_omp
);
4381 finish_omp_structured_block (tree block
)
4383 return do_poplevel (block
);
4386 /* Similarly, except force the retention of the BLOCK. */
4389 begin_omp_parallel (void)
4391 keep_next_level (true);
4392 return begin_omp_structured_block ();
4396 finish_omp_parallel (tree clauses
, tree body
)
4400 body
= finish_omp_structured_block (body
);
4402 stmt
= make_node (OMP_PARALLEL
);
4403 TREE_TYPE (stmt
) = void_type_node
;
4404 OMP_PARALLEL_CLAUSES (stmt
) = clauses
;
4405 OMP_PARALLEL_BODY (stmt
) = body
;
4407 return add_stmt (stmt
);
4411 begin_omp_task (void)
4413 keep_next_level (true);
4414 return begin_omp_structured_block ();
4418 finish_omp_task (tree clauses
, tree body
)
4422 body
= finish_omp_structured_block (body
);
4424 stmt
= make_node (OMP_TASK
);
4425 TREE_TYPE (stmt
) = void_type_node
;
4426 OMP_TASK_CLAUSES (stmt
) = clauses
;
4427 OMP_TASK_BODY (stmt
) = body
;
4429 return add_stmt (stmt
);
4432 /* Helper function for finish_omp_for. Convert Ith random access iterator
4433 into integral iterator. Return FALSE if successful. */
4436 handle_omp_for_class_iterator (int i
, location_t locus
, tree declv
, tree initv
,
4437 tree condv
, tree incrv
, tree
*body
,
4438 tree
*pre_body
, tree clauses
)
4440 tree diff
, iter_init
, iter_incr
= NULL
, last
;
4441 tree incr_var
= NULL
, orig_pre_body
, orig_body
, c
;
4442 tree decl
= TREE_VEC_ELT (declv
, i
);
4443 tree init
= TREE_VEC_ELT (initv
, i
);
4444 tree cond
= TREE_VEC_ELT (condv
, i
);
4445 tree incr
= TREE_VEC_ELT (incrv
, i
);
4447 location_t elocus
= locus
;
4449 if (init
&& EXPR_HAS_LOCATION (init
))
4450 elocus
= EXPR_LOCATION (init
);
4452 switch (TREE_CODE (cond
))
4458 if (TREE_OPERAND (cond
, 1) == iter
)
4459 cond
= build2 (swap_tree_comparison (TREE_CODE (cond
)),
4460 TREE_TYPE (cond
), iter
, TREE_OPERAND (cond
, 0));
4461 if (TREE_OPERAND (cond
, 0) != iter
)
4462 cond
= error_mark_node
;
4465 tree tem
= build_x_binary_op (EXPR_LOCATION (cond
),
4468 TREE_OPERAND (cond
, 1), ERROR_MARK
,
4469 NULL
, tf_warning_or_error
);
4470 if (error_operand_p (tem
))
4475 cond
= error_mark_node
;
4478 if (cond
== error_mark_node
)
4480 error_at (elocus
, "invalid controlling predicate");
4483 diff
= build_x_binary_op (elocus
, MINUS_EXPR
, TREE_OPERAND (cond
, 1),
4484 ERROR_MARK
, iter
, ERROR_MARK
, NULL
,
4485 tf_warning_or_error
);
4486 if (error_operand_p (diff
))
4488 if (TREE_CODE (TREE_TYPE (diff
)) != INTEGER_TYPE
)
4490 error_at (elocus
, "difference between %qE and %qD does not have integer type",
4491 TREE_OPERAND (cond
, 1), iter
);
4495 switch (TREE_CODE (incr
))
4497 case PREINCREMENT_EXPR
:
4498 case PREDECREMENT_EXPR
:
4499 case POSTINCREMENT_EXPR
:
4500 case POSTDECREMENT_EXPR
:
4501 if (TREE_OPERAND (incr
, 0) != iter
)
4503 incr
= error_mark_node
;
4506 iter_incr
= build_x_unary_op (EXPR_LOCATION (incr
),
4507 TREE_CODE (incr
), iter
,
4508 tf_warning_or_error
);
4509 if (error_operand_p (iter_incr
))
4511 else if (TREE_CODE (incr
) == PREINCREMENT_EXPR
4512 || TREE_CODE (incr
) == POSTINCREMENT_EXPR
)
4513 incr
= integer_one_node
;
4515 incr
= integer_minus_one_node
;
4518 if (TREE_OPERAND (incr
, 0) != iter
)
4519 incr
= error_mark_node
;
4520 else if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
4521 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
4523 tree rhs
= TREE_OPERAND (incr
, 1);
4524 if (TREE_OPERAND (rhs
, 0) == iter
)
4526 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs
, 1)))
4528 incr
= error_mark_node
;
4531 iter_incr
= build_x_modify_expr (EXPR_LOCATION (rhs
),
4532 iter
, TREE_CODE (rhs
),
4533 TREE_OPERAND (rhs
, 1),
4534 tf_warning_or_error
);
4535 if (error_operand_p (iter_incr
))
4537 incr
= TREE_OPERAND (rhs
, 1);
4538 incr
= cp_convert (TREE_TYPE (diff
), incr
,
4539 tf_warning_or_error
);
4540 if (TREE_CODE (rhs
) == MINUS_EXPR
)
4542 incr
= build1 (NEGATE_EXPR
, TREE_TYPE (diff
), incr
);
4543 incr
= fold_if_not_in_template (incr
);
4545 if (TREE_CODE (incr
) != INTEGER_CST
4546 && (TREE_CODE (incr
) != NOP_EXPR
4547 || (TREE_CODE (TREE_OPERAND (incr
, 0))
4552 else if (TREE_OPERAND (rhs
, 1) == iter
)
4554 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs
, 0))) != INTEGER_TYPE
4555 || TREE_CODE (rhs
) != PLUS_EXPR
)
4556 incr
= error_mark_node
;
4559 iter_incr
= build_x_binary_op (EXPR_LOCATION (rhs
),
4561 TREE_OPERAND (rhs
, 0),
4564 tf_warning_or_error
);
4565 if (error_operand_p (iter_incr
))
4567 iter_incr
= build_x_modify_expr (EXPR_LOCATION (rhs
),
4570 tf_warning_or_error
);
4571 if (error_operand_p (iter_incr
))
4573 incr
= TREE_OPERAND (rhs
, 0);
4578 incr
= error_mark_node
;
4581 incr
= error_mark_node
;
4584 incr
= error_mark_node
;
4588 if (incr
== error_mark_node
)
4590 error_at (elocus
, "invalid increment expression");
4594 incr
= cp_convert (TREE_TYPE (diff
), incr
, tf_warning_or_error
);
4595 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
4596 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
4597 && OMP_CLAUSE_DECL (c
) == iter
)
4600 decl
= create_temporary_var (TREE_TYPE (diff
));
4602 add_decl_expr (decl
);
4603 last
= create_temporary_var (TREE_TYPE (diff
));
4605 add_decl_expr (last
);
4606 if (c
&& iter_incr
== NULL
)
4608 incr_var
= create_temporary_var (TREE_TYPE (diff
));
4609 pushdecl (incr_var
);
4610 add_decl_expr (incr_var
);
4612 gcc_assert (stmts_are_full_exprs_p ());
4614 orig_pre_body
= *pre_body
;
4615 *pre_body
= push_stmt_list ();
4617 add_stmt (orig_pre_body
);
4619 finish_expr_stmt (build_x_modify_expr (elocus
,
4620 iter
, NOP_EXPR
, init
,
4621 tf_warning_or_error
));
4622 init
= build_int_cst (TREE_TYPE (diff
), 0);
4623 if (c
&& iter_incr
== NULL
)
4625 finish_expr_stmt (build_x_modify_expr (elocus
,
4627 incr
, tf_warning_or_error
));
4629 iter_incr
= build_x_modify_expr (elocus
,
4630 iter
, PLUS_EXPR
, incr
,
4631 tf_warning_or_error
);
4633 finish_expr_stmt (build_x_modify_expr (elocus
,
4634 last
, NOP_EXPR
, init
,
4635 tf_warning_or_error
));
4636 *pre_body
= pop_stmt_list (*pre_body
);
4638 cond
= cp_build_binary_op (elocus
,
4639 TREE_CODE (cond
), decl
, diff
,
4640 tf_warning_or_error
);
4641 incr
= build_modify_expr (elocus
, decl
, NULL_TREE
, PLUS_EXPR
,
4642 elocus
, incr
, NULL_TREE
);
4645 *body
= push_stmt_list ();
4646 iter_init
= build2 (MINUS_EXPR
, TREE_TYPE (diff
), decl
, last
);
4647 iter_init
= build_x_modify_expr (elocus
,
4648 iter
, PLUS_EXPR
, iter_init
,
4649 tf_warning_or_error
);
4650 iter_init
= build1 (NOP_EXPR
, void_type_node
, iter_init
);
4651 finish_expr_stmt (iter_init
);
4652 finish_expr_stmt (build_x_modify_expr (elocus
,
4653 last
, NOP_EXPR
, decl
,
4654 tf_warning_or_error
));
4655 add_stmt (orig_body
);
4656 *body
= pop_stmt_list (*body
);
4660 OMP_CLAUSE_LASTPRIVATE_STMT (c
) = push_stmt_list ();
4661 finish_expr_stmt (iter_incr
);
4662 OMP_CLAUSE_LASTPRIVATE_STMT (c
)
4663 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (c
));
4666 TREE_VEC_ELT (declv
, i
) = decl
;
4667 TREE_VEC_ELT (initv
, i
) = init
;
4668 TREE_VEC_ELT (condv
, i
) = cond
;
4669 TREE_VEC_ELT (incrv
, i
) = incr
;
4674 /* Build and validate an OMP_FOR statement. CLAUSES, BODY, COND, INCR
4675 are directly for their associated operands in the statement. DECL
4676 and INIT are a combo; if DECL is NULL then INIT ought to be a
4677 MODIFY_EXPR, and the DECL should be extracted. PRE_BODY are
4678 optional statements that need to go before the loop into its
4682 finish_omp_for (location_t locus
, tree declv
, tree initv
, tree condv
,
4683 tree incrv
, tree body
, tree pre_body
, tree clauses
)
4685 tree omp_for
= NULL
, orig_incr
= NULL
;
4686 tree decl
, init
, cond
, incr
;
4690 gcc_assert (TREE_VEC_LENGTH (declv
) == TREE_VEC_LENGTH (initv
));
4691 gcc_assert (TREE_VEC_LENGTH (declv
) == TREE_VEC_LENGTH (condv
));
4692 gcc_assert (TREE_VEC_LENGTH (declv
) == TREE_VEC_LENGTH (incrv
));
4693 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
4695 decl
= TREE_VEC_ELT (declv
, i
);
4696 init
= TREE_VEC_ELT (initv
, i
);
4697 cond
= TREE_VEC_ELT (condv
, i
);
4698 incr
= TREE_VEC_ELT (incrv
, i
);
4704 switch (TREE_CODE (init
))
4707 decl
= TREE_OPERAND (init
, 0);
4708 init
= TREE_OPERAND (init
, 1);
4711 if (TREE_CODE (TREE_OPERAND (init
, 1)) == NOP_EXPR
)
4713 decl
= TREE_OPERAND (init
, 0);
4714 init
= TREE_OPERAND (init
, 2);
4724 "expected iteration declaration or initialization");
4729 if (init
&& EXPR_HAS_LOCATION (init
))
4730 elocus
= EXPR_LOCATION (init
);
4734 error_at (elocus
, "missing controlling predicate");
4740 error_at (elocus
, "missing increment expression");
4744 TREE_VEC_ELT (declv
, i
) = decl
;
4745 TREE_VEC_ELT (initv
, i
) = init
;
4748 if (dependent_omp_for_p (declv
, initv
, condv
, incrv
))
4752 stmt
= make_node (OMP_FOR
);
4754 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
4756 /* This is really just a place-holder. We'll be decomposing this
4757 again and going through the cp_build_modify_expr path below when
4758 we instantiate the thing. */
4759 TREE_VEC_ELT (initv
, i
)
4760 = build2 (MODIFY_EXPR
, void_type_node
, TREE_VEC_ELT (declv
, i
),
4761 TREE_VEC_ELT (initv
, i
));
4764 TREE_TYPE (stmt
) = void_type_node
;
4765 OMP_FOR_INIT (stmt
) = initv
;
4766 OMP_FOR_COND (stmt
) = condv
;
4767 OMP_FOR_INCR (stmt
) = incrv
;
4768 OMP_FOR_BODY (stmt
) = body
;
4769 OMP_FOR_PRE_BODY (stmt
) = pre_body
;
4770 OMP_FOR_CLAUSES (stmt
) = clauses
;
4772 SET_EXPR_LOCATION (stmt
, locus
);
4773 return add_stmt (stmt
);
4776 if (processing_template_decl
)
4777 orig_incr
= make_tree_vec (TREE_VEC_LENGTH (incrv
));
4779 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); )
4781 decl
= TREE_VEC_ELT (declv
, i
);
4782 init
= TREE_VEC_ELT (initv
, i
);
4783 cond
= TREE_VEC_ELT (condv
, i
);
4784 incr
= TREE_VEC_ELT (incrv
, i
);
4786 TREE_VEC_ELT (orig_incr
, i
) = incr
;
4789 if (init
&& EXPR_HAS_LOCATION (init
))
4790 elocus
= EXPR_LOCATION (init
);
4794 error_at (elocus
, "expected iteration declaration or initialization");
4798 if (incr
&& TREE_CODE (incr
) == MODOP_EXPR
)
4801 TREE_VEC_ELT (orig_incr
, i
) = incr
;
4802 incr
= cp_build_modify_expr (TREE_OPERAND (incr
, 0),
4803 TREE_CODE (TREE_OPERAND (incr
, 1)),
4804 TREE_OPERAND (incr
, 2),
4805 tf_warning_or_error
);
4808 if (CLASS_TYPE_P (TREE_TYPE (decl
)))
4810 if (handle_omp_for_class_iterator (i
, locus
, declv
, initv
, condv
,
4811 incrv
, &body
, &pre_body
, clauses
))
4816 if (!INTEGRAL_TYPE_P (TREE_TYPE (decl
))
4817 && TREE_CODE (TREE_TYPE (decl
)) != POINTER_TYPE
)
4819 error_at (elocus
, "invalid type for iteration variable %qE", decl
);
4823 if (!processing_template_decl
)
4825 init
= fold_build_cleanup_point_expr (TREE_TYPE (init
), init
);
4826 init
= cp_build_modify_expr (decl
, NOP_EXPR
, init
, tf_warning_or_error
);
4829 init
= build2 (MODIFY_EXPR
, void_type_node
, decl
, init
);
4831 && TREE_SIDE_EFFECTS (cond
)
4832 && COMPARISON_CLASS_P (cond
)
4833 && !processing_template_decl
)
4835 tree t
= TREE_OPERAND (cond
, 0);
4836 if (TREE_SIDE_EFFECTS (t
)
4838 && (TREE_CODE (t
) != NOP_EXPR
4839 || TREE_OPERAND (t
, 0) != decl
))
4840 TREE_OPERAND (cond
, 0)
4841 = fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4843 t
= TREE_OPERAND (cond
, 1);
4844 if (TREE_SIDE_EFFECTS (t
)
4846 && (TREE_CODE (t
) != NOP_EXPR
4847 || TREE_OPERAND (t
, 0) != decl
))
4848 TREE_OPERAND (cond
, 1)
4849 = fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4851 if (decl
== error_mark_node
|| init
== error_mark_node
)
4854 TREE_VEC_ELT (declv
, i
) = decl
;
4855 TREE_VEC_ELT (initv
, i
) = init
;
4856 TREE_VEC_ELT (condv
, i
) = cond
;
4857 TREE_VEC_ELT (incrv
, i
) = incr
;
4861 if (IS_EMPTY_STMT (pre_body
))
4864 omp_for
= c_finish_omp_for (locus
, declv
, initv
, condv
, incrv
,
4867 if (omp_for
== NULL
)
4870 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INCR (omp_for
)); i
++)
4872 decl
= TREE_OPERAND (TREE_VEC_ELT (OMP_FOR_INIT (omp_for
), i
), 0);
4873 incr
= TREE_VEC_ELT (OMP_FOR_INCR (omp_for
), i
);
4875 if (TREE_CODE (incr
) != MODIFY_EXPR
)
4878 if (TREE_SIDE_EFFECTS (TREE_OPERAND (incr
, 1))
4879 && BINARY_CLASS_P (TREE_OPERAND (incr
, 1))
4880 && !processing_template_decl
)
4882 tree t
= TREE_OPERAND (TREE_OPERAND (incr
, 1), 0);
4883 if (TREE_SIDE_EFFECTS (t
)
4885 && (TREE_CODE (t
) != NOP_EXPR
4886 || TREE_OPERAND (t
, 0) != decl
))
4887 TREE_OPERAND (TREE_OPERAND (incr
, 1), 0)
4888 = fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4890 t
= TREE_OPERAND (TREE_OPERAND (incr
, 1), 1);
4891 if (TREE_SIDE_EFFECTS (t
)
4893 && (TREE_CODE (t
) != NOP_EXPR
4894 || TREE_OPERAND (t
, 0) != decl
))
4895 TREE_OPERAND (TREE_OPERAND (incr
, 1), 1)
4896 = fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4900 TREE_VEC_ELT (OMP_FOR_INCR (omp_for
), i
) = TREE_VEC_ELT (orig_incr
, i
);
4902 if (omp_for
!= NULL
)
4903 OMP_FOR_CLAUSES (omp_for
) = clauses
;
4908 finish_omp_atomic (enum tree_code code
, enum tree_code opcode
, tree lhs
,
4909 tree rhs
, tree v
, tree lhs1
, tree rhs1
)
4924 dependent_p
= false;
4927 /* Even in a template, we can detect invalid uses of the atomic
4928 pragma if neither LHS nor RHS is type-dependent. */
4929 if (processing_template_decl
)
4931 dependent_p
= (type_dependent_expression_p (lhs
)
4932 || (rhs
&& type_dependent_expression_p (rhs
))
4933 || (v
&& type_dependent_expression_p (v
))
4934 || (lhs1
&& type_dependent_expression_p (lhs1
))
4935 || (rhs1
&& type_dependent_expression_p (rhs1
)));
4938 lhs
= build_non_dependent_expr (lhs
);
4940 rhs
= build_non_dependent_expr (rhs
);
4942 v
= build_non_dependent_expr (v
);
4944 lhs1
= build_non_dependent_expr (lhs1
);
4946 rhs1
= build_non_dependent_expr (rhs1
);
4951 stmt
= c_finish_omp_atomic (input_location
, code
, opcode
, lhs
, rhs
,
4953 if (stmt
== error_mark_node
)
4956 if (processing_template_decl
)
4958 if (code
== OMP_ATOMIC_READ
)
4960 stmt
= build_min_nt_loc (EXPR_LOCATION (orig_lhs
),
4961 OMP_ATOMIC_READ
, orig_lhs
);
4962 stmt
= build2 (MODIFY_EXPR
, void_type_node
, orig_v
, stmt
);
4966 if (opcode
== NOP_EXPR
)
4967 stmt
= build2 (MODIFY_EXPR
, void_type_node
, orig_lhs
, orig_rhs
);
4969 stmt
= build2 (opcode
, void_type_node
, orig_lhs
, orig_rhs
);
4971 stmt
= build_min_nt_loc (EXPR_LOCATION (orig_rhs1
),
4972 COMPOUND_EXPR
, orig_rhs1
, stmt
);
4973 if (code
!= OMP_ATOMIC
)
4975 stmt
= build_min_nt_loc (EXPR_LOCATION (orig_lhs1
),
4976 code
, orig_lhs1
, stmt
);
4977 stmt
= build2 (MODIFY_EXPR
, void_type_node
, orig_v
, stmt
);
4980 stmt
= build2 (OMP_ATOMIC
, void_type_node
, integer_zero_node
, stmt
);
4986 finish_omp_barrier (void)
4988 tree fn
= builtin_decl_explicit (BUILT_IN_GOMP_BARRIER
);
4989 VEC(tree
,gc
) *vec
= make_tree_vector ();
4990 tree stmt
= finish_call_expr (fn
, &vec
, false, false, tf_warning_or_error
);
4991 release_tree_vector (vec
);
4992 finish_expr_stmt (stmt
);
4996 finish_omp_flush (void)
4998 tree fn
= builtin_decl_explicit (BUILT_IN_SYNC_SYNCHRONIZE
);
4999 VEC(tree
,gc
) *vec
= make_tree_vector ();
5000 tree stmt
= finish_call_expr (fn
, &vec
, false, false, tf_warning_or_error
);
5001 release_tree_vector (vec
);
5002 finish_expr_stmt (stmt
);
5006 finish_omp_taskwait (void)
5008 tree fn
= builtin_decl_explicit (BUILT_IN_GOMP_TASKWAIT
);
5009 VEC(tree
,gc
) *vec
= make_tree_vector ();
5010 tree stmt
= finish_call_expr (fn
, &vec
, false, false, tf_warning_or_error
);
5011 release_tree_vector (vec
);
5012 finish_expr_stmt (stmt
);
5016 finish_omp_taskyield (void)
5018 tree fn
= builtin_decl_explicit (BUILT_IN_GOMP_TASKYIELD
);
5019 VEC(tree
,gc
) *vec
= make_tree_vector ();
5020 tree stmt
= finish_call_expr (fn
, &vec
, false, false, tf_warning_or_error
);
5021 release_tree_vector (vec
);
5022 finish_expr_stmt (stmt
);
5025 /* Begin a __transaction_atomic or __transaction_relaxed statement.
5026 If PCOMPOUND is non-null, this is for a function-transaction-block, and we
5027 should create an extra compound stmt. */
5030 begin_transaction_stmt (location_t loc
, tree
*pcompound
, int flags
)
5035 *pcompound
= begin_compound_stmt (0);
5037 r
= build_stmt (loc
, TRANSACTION_EXPR
, NULL_TREE
);
5039 /* Only add the statement to the function if support enabled. */
5043 error_at (loc
, ((flags
& TM_STMT_ATTR_RELAXED
) != 0
5044 ? G_("%<__transaction_relaxed%> without "
5045 "transactional memory support enabled")
5046 : G_("%<__transaction_atomic%> without "
5047 "transactional memory support enabled")));
5049 TRANSACTION_EXPR_BODY (r
) = push_stmt_list ();
5053 /* End a __transaction_atomic or __transaction_relaxed statement.
5054 If COMPOUND_STMT is non-null, this is for a function-transaction-block,
5055 and we should end the compound. If NOEX is non-NULL, we wrap the body in
5056 a MUST_NOT_THROW_EXPR with NOEX as condition. */
5059 finish_transaction_stmt (tree stmt
, tree compound_stmt
, int flags
, tree noex
)
5061 TRANSACTION_EXPR_BODY (stmt
) = pop_stmt_list (TRANSACTION_EXPR_BODY (stmt
));
5062 TRANSACTION_EXPR_OUTER (stmt
) = (flags
& TM_STMT_ATTR_OUTER
) != 0;
5063 TRANSACTION_EXPR_RELAXED (stmt
) = (flags
& TM_STMT_ATTR_RELAXED
) != 0;
5064 TRANSACTION_EXPR_IS_STMT (stmt
) = 1;
5066 /* noexcept specifications are not allowed for function transactions. */
5067 gcc_assert (!(noex
&& compound_stmt
));
5070 tree body
= build_must_not_throw_expr (TRANSACTION_EXPR_BODY (stmt
),
5072 SET_EXPR_LOCATION (body
, EXPR_LOCATION (TRANSACTION_EXPR_BODY (stmt
)));
5073 TREE_SIDE_EFFECTS (body
) = 1;
5074 TRANSACTION_EXPR_BODY (stmt
) = body
;
5078 finish_compound_stmt (compound_stmt
);
5082 /* Build a __transaction_atomic or __transaction_relaxed expression. If
5083 NOEX is non-NULL, we wrap the body in a MUST_NOT_THROW_EXPR with NOEX as
5087 build_transaction_expr (location_t loc
, tree expr
, int flags
, tree noex
)
5092 expr
= build_must_not_throw_expr (expr
, noex
);
5093 SET_EXPR_LOCATION (expr
, loc
);
5094 TREE_SIDE_EFFECTS (expr
) = 1;
5096 ret
= build1 (TRANSACTION_EXPR
, TREE_TYPE (expr
), expr
);
5097 if (flags
& TM_STMT_ATTR_RELAXED
)
5098 TRANSACTION_EXPR_RELAXED (ret
) = 1;
5099 SET_EXPR_LOCATION (ret
, loc
);
5104 init_cp_semantics (void)
5108 /* Build a STATIC_ASSERT for a static assertion with the condition
5109 CONDITION and the message text MESSAGE. LOCATION is the location
5110 of the static assertion in the source code. When MEMBER_P, this
5111 static assertion is a member of a class. */
5113 finish_static_assert (tree condition
, tree message
, location_t location
,
5116 if (check_for_bare_parameter_packs (condition
))
5117 condition
= error_mark_node
;
5119 if (type_dependent_expression_p (condition
)
5120 || value_dependent_expression_p (condition
))
5122 /* We're in a template; build a STATIC_ASSERT and put it in
5126 assertion
= make_node (STATIC_ASSERT
);
5127 STATIC_ASSERT_CONDITION (assertion
) = condition
;
5128 STATIC_ASSERT_MESSAGE (assertion
) = message
;
5129 STATIC_ASSERT_SOURCE_LOCATION (assertion
) = location
;
5132 maybe_add_class_template_decl_list (current_class_type
,
5136 add_stmt (assertion
);
5141 /* Fold the expression and convert it to a boolean value. */
5142 condition
= fold_non_dependent_expr (condition
);
5143 condition
= cp_convert (boolean_type_node
, condition
, tf_warning_or_error
);
5144 condition
= maybe_constant_value (condition
);
5146 if (TREE_CODE (condition
) == INTEGER_CST
&& !integer_zerop (condition
))
5147 /* Do nothing; the condition is satisfied. */
5151 location_t saved_loc
= input_location
;
5153 input_location
= location
;
5154 if (TREE_CODE (condition
) == INTEGER_CST
5155 && integer_zerop (condition
))
5156 /* Report the error. */
5157 error ("static assertion failed: %s", TREE_STRING_POINTER (message
));
5158 else if (condition
&& condition
!= error_mark_node
)
5160 error ("non-constant condition for static assertion");
5161 cxx_constant_value (condition
);
5163 input_location
= saved_loc
;
5167 /* Implements the C++0x decltype keyword. Returns the type of EXPR,
5168 suitable for use as a type-specifier.
5170 ID_EXPRESSION_OR_MEMBER_ACCESS_P is true when EXPR was parsed as an
5171 id-expression or a class member access, FALSE when it was parsed as
5172 a full expression. */
5175 finish_decltype_type (tree expr
, bool id_expression_or_member_access_p
,
5176 tsubst_flags_t complain
)
5178 tree type
= NULL_TREE
;
5180 if (!expr
|| error_operand_p (expr
))
5181 return error_mark_node
;
5184 || TREE_CODE (expr
) == TYPE_DECL
5185 || (TREE_CODE (expr
) == BIT_NOT_EXPR
5186 && TYPE_P (TREE_OPERAND (expr
, 0))))
5188 if (complain
& tf_error
)
5189 error ("argument to decltype must be an expression");
5190 return error_mark_node
;
5193 /* FIXME instantiation-dependent */
5194 if (type_dependent_expression_p (expr
)
5195 /* In a template, a COMPONENT_REF has an IDENTIFIER_NODE for op1 even
5196 if it isn't dependent, so that we can check access control at
5197 instantiation time, so defer the decltype as well (PR 42277). */
5198 || (id_expression_or_member_access_p
5199 && processing_template_decl
5200 && TREE_CODE (expr
) == COMPONENT_REF
))
5202 type
= cxx_make_type (DECLTYPE_TYPE
);
5203 DECLTYPE_TYPE_EXPR (type
) = expr
;
5204 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type
)
5205 = id_expression_or_member_access_p
;
5206 SET_TYPE_STRUCTURAL_EQUALITY (type
);
5211 /* The type denoted by decltype(e) is defined as follows: */
5213 expr
= resolve_nondeduced_context (expr
);
5215 if (type_unknown_p (expr
))
5217 if (complain
& tf_error
)
5218 error ("decltype cannot resolve address of overloaded function");
5219 return error_mark_node
;
5222 if (invalid_nonstatic_memfn_p (expr
, complain
))
5223 return error_mark_node
;
5225 /* To get the size of a static data member declared as an array of
5226 unknown bound, we need to instantiate it. */
5227 if (TREE_CODE (expr
) == VAR_DECL
5228 && VAR_HAD_UNKNOWN_BOUND (expr
)
5229 && DECL_TEMPLATE_INSTANTIATION (expr
))
5230 instantiate_decl (expr
, /*defer_ok*/true, /*expl_inst_mem*/false);
5232 if (id_expression_or_member_access_p
)
5234 /* If e is an id-expression or a class member access (5.2.5
5235 [expr.ref]), decltype(e) is defined as the type of the entity
5236 named by e. If there is no such entity, or e names a set of
5237 overloaded functions, the program is ill-formed. */
5238 if (TREE_CODE (expr
) == IDENTIFIER_NODE
)
5239 expr
= lookup_name (expr
);
5241 if (TREE_CODE (expr
) == INDIRECT_REF
)
5242 /* This can happen when the expression is, e.g., "a.b". Just
5243 look at the underlying operand. */
5244 expr
= TREE_OPERAND (expr
, 0);
5246 if (TREE_CODE (expr
) == OFFSET_REF
5247 || TREE_CODE (expr
) == MEMBER_REF
)
5248 /* We're only interested in the field itself. If it is a
5249 BASELINK, we will need to see through it in the next
5251 expr
= TREE_OPERAND (expr
, 1);
5253 if (BASELINK_P (expr
))
5254 /* See through BASELINK nodes to the underlying function. */
5255 expr
= BASELINK_FUNCTIONS (expr
);
5257 switch (TREE_CODE (expr
))
5260 if (DECL_BIT_FIELD_TYPE (expr
))
5262 type
= DECL_BIT_FIELD_TYPE (expr
);
5265 /* Fall through for fields that aren't bitfields. */
5272 case TEMPLATE_PARM_INDEX
:
5273 expr
= mark_type_use (expr
);
5274 type
= TREE_TYPE (expr
);
5278 type
= error_mark_node
;
5282 mark_type_use (expr
);
5283 type
= is_bitfield_expr_with_lowered_type (expr
);
5285 type
= TREE_TYPE (TREE_OPERAND (expr
, 1));
5293 /* We can get here when the id-expression refers to an
5294 enumerator or non-type template parameter. */
5295 type
= TREE_TYPE (expr
);
5300 return error_mark_node
;
5305 /* Within a lambda-expression:
5307 Every occurrence of decltype((x)) where x is a possibly
5308 parenthesized id-expression that names an entity of
5309 automatic storage duration is treated as if x were
5310 transformed into an access to a corresponding data member
5311 of the closure type that would have been declared if x
5312 were a use of the denoted entity. */
5313 if (outer_automatic_var_p (expr
)
5314 && current_function_decl
5315 && LAMBDA_FUNCTION_P (current_function_decl
))
5316 type
= capture_decltype (expr
);
5317 else if (error_operand_p (expr
))
5318 type
= error_mark_node
;
5319 else if (expr
== current_class_ptr
)
5320 /* If the expression is just "this", we want the
5321 cv-unqualified pointer for the "this" type. */
5322 type
= TYPE_MAIN_VARIANT (TREE_TYPE (expr
));
5325 /* Otherwise, where T is the type of e, if e is an lvalue,
5326 decltype(e) is defined as T&; if an xvalue, T&&; otherwise, T. */
5327 cp_lvalue_kind clk
= lvalue_kind (expr
);
5328 type
= unlowered_expr_type (expr
);
5329 gcc_assert (TREE_CODE (type
) != REFERENCE_TYPE
);
5330 if (clk
!= clk_none
&& !(clk
& clk_class
))
5331 type
= cp_build_reference_type (type
, (clk
& clk_rvalueref
));
5338 /* Called from trait_expr_value to evaluate either __has_nothrow_assign or
5339 __has_nothrow_copy, depending on assign_p. */
5342 classtype_has_nothrow_assign_or_copy_p (tree type
, bool assign_p
)
5349 ix
= lookup_fnfields_1 (type
, ansi_assopname (NOP_EXPR
));
5352 fns
= VEC_index (tree
, CLASSTYPE_METHOD_VEC (type
), ix
);
5354 else if (TYPE_HAS_COPY_CTOR (type
))
5356 /* If construction of the copy constructor was postponed, create
5358 if (CLASSTYPE_LAZY_COPY_CTOR (type
))
5359 lazily_declare_fn (sfk_copy_constructor
, type
);
5360 if (CLASSTYPE_LAZY_MOVE_CTOR (type
))
5361 lazily_declare_fn (sfk_move_constructor
, type
);
5362 fns
= CLASSTYPE_CONSTRUCTORS (type
);
5367 for (; fns
; fns
= OVL_NEXT (fns
))
5369 tree fn
= OVL_CURRENT (fns
);
5373 if (copy_fn_p (fn
) == 0)
5376 else if (copy_fn_p (fn
) <= 0)
5379 if (!TYPE_NOTHROW_P (TREE_TYPE (fn
)))
5386 /* Actually evaluates the trait. */
5389 trait_expr_value (cp_trait_kind kind
, tree type1
, tree type2
)
5391 enum tree_code type_code1
;
5394 type_code1
= TREE_CODE (type1
);
5398 case CPTK_HAS_NOTHROW_ASSIGN
:
5399 type1
= strip_array_types (type1
);
5400 return (!CP_TYPE_CONST_P (type1
) && type_code1
!= REFERENCE_TYPE
5401 && (trait_expr_value (CPTK_HAS_TRIVIAL_ASSIGN
, type1
, type2
)
5402 || (CLASS_TYPE_P (type1
)
5403 && classtype_has_nothrow_assign_or_copy_p (type1
,
5406 case CPTK_HAS_TRIVIAL_ASSIGN
:
5407 /* ??? The standard seems to be missing the "or array of such a class
5408 type" wording for this trait. */
5409 type1
= strip_array_types (type1
);
5410 return (!CP_TYPE_CONST_P (type1
) && type_code1
!= REFERENCE_TYPE
5411 && (trivial_type_p (type1
)
5412 || (CLASS_TYPE_P (type1
)
5413 && TYPE_HAS_TRIVIAL_COPY_ASSIGN (type1
))));
5415 case CPTK_HAS_NOTHROW_CONSTRUCTOR
:
5416 type1
= strip_array_types (type1
);
5417 return (trait_expr_value (CPTK_HAS_TRIVIAL_CONSTRUCTOR
, type1
, type2
)
5418 || (CLASS_TYPE_P (type1
)
5419 && (t
= locate_ctor (type1
))
5420 && TYPE_NOTHROW_P (TREE_TYPE (t
))));
5422 case CPTK_HAS_TRIVIAL_CONSTRUCTOR
:
5423 type1
= strip_array_types (type1
);
5424 return (trivial_type_p (type1
)
5425 || (CLASS_TYPE_P (type1
) && TYPE_HAS_TRIVIAL_DFLT (type1
)));
5427 case CPTK_HAS_NOTHROW_COPY
:
5428 type1
= strip_array_types (type1
);
5429 return (trait_expr_value (CPTK_HAS_TRIVIAL_COPY
, type1
, type2
)
5430 || (CLASS_TYPE_P (type1
)
5431 && classtype_has_nothrow_assign_or_copy_p (type1
, false)));
5433 case CPTK_HAS_TRIVIAL_COPY
:
5434 /* ??? The standard seems to be missing the "or array of such a class
5435 type" wording for this trait. */
5436 type1
= strip_array_types (type1
);
5437 return (trivial_type_p (type1
) || type_code1
== REFERENCE_TYPE
5438 || (CLASS_TYPE_P (type1
) && TYPE_HAS_TRIVIAL_COPY_CTOR (type1
)));
5440 case CPTK_HAS_TRIVIAL_DESTRUCTOR
:
5441 type1
= strip_array_types (type1
);
5442 return (trivial_type_p (type1
) || type_code1
== REFERENCE_TYPE
5443 || (CLASS_TYPE_P (type1
)
5444 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type1
)));
5446 case CPTK_HAS_VIRTUAL_DESTRUCTOR
:
5447 return type_has_virtual_destructor (type1
);
5449 case CPTK_IS_ABSTRACT
:
5450 return (ABSTRACT_CLASS_TYPE_P (type1
));
5452 case CPTK_IS_BASE_OF
:
5453 return (NON_UNION_CLASS_TYPE_P (type1
) && NON_UNION_CLASS_TYPE_P (type2
)
5454 && DERIVED_FROM_P (type1
, type2
));
5457 return (NON_UNION_CLASS_TYPE_P (type1
));
5459 case CPTK_IS_CONVERTIBLE_TO
:
5464 return (NON_UNION_CLASS_TYPE_P (type1
) && CLASSTYPE_EMPTY_P (type1
));
5467 return (type_code1
== ENUMERAL_TYPE
);
5470 return (CLASS_TYPE_P (type1
) && CLASSTYPE_FINAL (type1
));
5472 case CPTK_IS_LITERAL_TYPE
:
5473 return (literal_type_p (type1
));
5476 return (pod_type_p (type1
));
5478 case CPTK_IS_POLYMORPHIC
:
5479 return (CLASS_TYPE_P (type1
) && TYPE_POLYMORPHIC_P (type1
));
5481 case CPTK_IS_STD_LAYOUT
:
5482 return (std_layout_type_p (type1
));
5484 case CPTK_IS_TRIVIAL
:
5485 return (trivial_type_p (type1
));
5488 return (type_code1
== UNION_TYPE
);
5496 /* If TYPE is an array of unknown bound, or (possibly cv-qualified)
5497 void, or a complete type, returns it, otherwise NULL_TREE. */
5500 check_trait_type (tree type
)
5502 if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
)
5503 && COMPLETE_TYPE_P (TREE_TYPE (type
)))
5506 if (VOID_TYPE_P (type
))
5509 return complete_type_or_else (strip_array_types (type
), NULL_TREE
);
5512 /* Process a trait expression. */
5515 finish_trait_expr (cp_trait_kind kind
, tree type1
, tree type2
)
5517 gcc_assert (kind
== CPTK_HAS_NOTHROW_ASSIGN
5518 || kind
== CPTK_HAS_NOTHROW_CONSTRUCTOR
5519 || kind
== CPTK_HAS_NOTHROW_COPY
5520 || kind
== CPTK_HAS_TRIVIAL_ASSIGN
5521 || kind
== CPTK_HAS_TRIVIAL_CONSTRUCTOR
5522 || kind
== CPTK_HAS_TRIVIAL_COPY
5523 || kind
== CPTK_HAS_TRIVIAL_DESTRUCTOR
5524 || kind
== CPTK_HAS_VIRTUAL_DESTRUCTOR
5525 || kind
== CPTK_IS_ABSTRACT
5526 || kind
== CPTK_IS_BASE_OF
5527 || kind
== CPTK_IS_CLASS
5528 || kind
== CPTK_IS_CONVERTIBLE_TO
5529 || kind
== CPTK_IS_EMPTY
5530 || kind
== CPTK_IS_ENUM
5531 || kind
== CPTK_IS_FINAL
5532 || kind
== CPTK_IS_LITERAL_TYPE
5533 || kind
== CPTK_IS_POD
5534 || kind
== CPTK_IS_POLYMORPHIC
5535 || kind
== CPTK_IS_STD_LAYOUT
5536 || kind
== CPTK_IS_TRIVIAL
5537 || kind
== CPTK_IS_UNION
);
5539 if (kind
== CPTK_IS_CONVERTIBLE_TO
)
5541 sorry ("__is_convertible_to");
5542 return error_mark_node
;
5545 if (type1
== error_mark_node
5546 || ((kind
== CPTK_IS_BASE_OF
|| kind
== CPTK_IS_CONVERTIBLE_TO
)
5547 && type2
== error_mark_node
))
5548 return error_mark_node
;
5550 if (processing_template_decl
)
5552 tree trait_expr
= make_node (TRAIT_EXPR
);
5553 TREE_TYPE (trait_expr
) = boolean_type_node
;
5554 TRAIT_EXPR_TYPE1 (trait_expr
) = type1
;
5555 TRAIT_EXPR_TYPE2 (trait_expr
) = type2
;
5556 TRAIT_EXPR_KIND (trait_expr
) = kind
;
5562 case CPTK_HAS_NOTHROW_ASSIGN
:
5563 case CPTK_HAS_TRIVIAL_ASSIGN
:
5564 case CPTK_HAS_NOTHROW_CONSTRUCTOR
:
5565 case CPTK_HAS_TRIVIAL_CONSTRUCTOR
:
5566 case CPTK_HAS_NOTHROW_COPY
:
5567 case CPTK_HAS_TRIVIAL_COPY
:
5568 case CPTK_HAS_TRIVIAL_DESTRUCTOR
:
5569 case CPTK_HAS_VIRTUAL_DESTRUCTOR
:
5570 case CPTK_IS_ABSTRACT
:
5573 case CPTK_IS_LITERAL_TYPE
:
5575 case CPTK_IS_POLYMORPHIC
:
5576 case CPTK_IS_STD_LAYOUT
:
5577 case CPTK_IS_TRIVIAL
:
5578 if (!check_trait_type (type1
))
5579 return error_mark_node
;
5582 case CPTK_IS_BASE_OF
:
5583 if (NON_UNION_CLASS_TYPE_P (type1
) && NON_UNION_CLASS_TYPE_P (type2
)
5584 && !same_type_ignoring_top_level_qualifiers_p (type1
, type2
)
5585 && !complete_type_or_else (type2
, NULL_TREE
))
5586 /* We already issued an error. */
5587 return error_mark_node
;
5595 case CPTK_IS_CONVERTIBLE_TO
:
5600 return (trait_expr_value (kind
, type1
, type2
)
5601 ? boolean_true_node
: boolean_false_node
);
5604 /* Do-nothing variants of functions to handle pragma FLOAT_CONST_DECIMAL64,
5605 which is ignored for C++. */
5608 set_float_const_decimal64 (void)
5613 clear_float_const_decimal64 (void)
5618 float_const_decimal64_p (void)
5624 /* Return true if T is a literal type. */
5627 literal_type_p (tree t
)
5629 if (SCALAR_TYPE_P (t
)
5630 || TREE_CODE (t
) == VECTOR_TYPE
5631 || TREE_CODE (t
) == REFERENCE_TYPE
)
5633 if (CLASS_TYPE_P (t
))
5635 t
= complete_type (t
);
5636 gcc_assert (COMPLETE_TYPE_P (t
) || errorcount
);
5637 return CLASSTYPE_LITERAL_P (t
);
5639 if (TREE_CODE (t
) == ARRAY_TYPE
)
5640 return literal_type_p (strip_array_types (t
));
5644 /* If DECL is a variable declared `constexpr', require its type
5645 be literal. Return the DECL if OK, otherwise NULL. */
5648 ensure_literal_type_for_constexpr_object (tree decl
)
5650 tree type
= TREE_TYPE (decl
);
5651 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_DECLARED_CONSTEXPR_P (decl
)
5652 && !processing_template_decl
)
5654 if (CLASS_TYPE_P (type
) && !COMPLETE_TYPE_P (complete_type (type
)))
5655 /* Don't complain here, we'll complain about incompleteness
5656 when we try to initialize the variable. */;
5657 else if (!literal_type_p (type
))
5659 error ("the type %qT of constexpr variable %qD is not literal",
5661 explain_non_literal_class (type
);
5668 /* Representation of entries in the constexpr function definition table. */
5670 typedef struct GTY(()) constexpr_fundef
{
5675 /* This table holds all constexpr function definitions seen in
5676 the current translation unit. */
5678 static GTY ((param_is (constexpr_fundef
))) htab_t constexpr_fundef_table
;
5680 /* Utility function used for managing the constexpr function table.
5681 Return true if the entries pointed to by P and Q are for the
5682 same constexpr function. */
5685 constexpr_fundef_equal (const void *p
, const void *q
)
5687 const constexpr_fundef
*lhs
= (const constexpr_fundef
*) p
;
5688 const constexpr_fundef
*rhs
= (const constexpr_fundef
*) q
;
5689 return lhs
->decl
== rhs
->decl
;
5692 /* Utility function used for managing the constexpr function table.
5693 Return a hash value for the entry pointed to by Q. */
5695 static inline hashval_t
5696 constexpr_fundef_hash (const void *p
)
5698 const constexpr_fundef
*fundef
= (const constexpr_fundef
*) p
;
5699 return DECL_UID (fundef
->decl
);
5702 /* Return a previously saved definition of function FUN. */
5704 static constexpr_fundef
*
5705 retrieve_constexpr_fundef (tree fun
)
5707 constexpr_fundef fundef
= { NULL
, NULL
};
5708 if (constexpr_fundef_table
== NULL
)
5712 return (constexpr_fundef
*) htab_find (constexpr_fundef_table
, &fundef
);
5715 /* Check whether the parameter and return types of FUN are valid for a
5716 constexpr function, and complain if COMPLAIN. */
5719 is_valid_constexpr_fn (tree fun
, bool complain
)
5721 tree parm
= FUNCTION_FIRST_USER_PARM (fun
);
5723 for (; parm
!= NULL
; parm
= TREE_CHAIN (parm
))
5724 if (!literal_type_p (TREE_TYPE (parm
)))
5729 error ("invalid type for parameter %d of constexpr "
5730 "function %q+#D", DECL_PARM_INDEX (parm
), fun
);
5731 explain_non_literal_class (TREE_TYPE (parm
));
5735 if (!DECL_CONSTRUCTOR_P (fun
))
5737 tree rettype
= TREE_TYPE (TREE_TYPE (fun
));
5738 if (!literal_type_p (rettype
))
5743 error ("invalid return type %qT of constexpr function %q+D",
5745 explain_non_literal_class (rettype
);
5749 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
5750 && !CLASSTYPE_LITERAL_P (DECL_CONTEXT (fun
)))
5755 error ("enclosing class of constexpr non-static member "
5756 "function %q+#D is not a literal type", fun
);
5757 explain_non_literal_class (DECL_CONTEXT (fun
));
5761 else if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fun
)))
5765 error ("%q#T has virtual base classes", DECL_CONTEXT (fun
));
5771 /* Subroutine of build_constexpr_constructor_member_initializers.
5772 The expression tree T represents a data member initialization
5773 in a (constexpr) constructor definition. Build a pairing of
5774 the data member with its initializer, and prepend that pair
5775 to the existing initialization pair INITS. */
5778 build_data_member_initialization (tree t
, VEC(constructor_elt
,gc
) **vec
)
5781 if (TREE_CODE (t
) == CLEANUP_POINT_EXPR
)
5782 t
= TREE_OPERAND (t
, 0);
5783 if (TREE_CODE (t
) == EXPR_STMT
)
5784 t
= TREE_OPERAND (t
, 0);
5785 if (t
== error_mark_node
)
5787 if (TREE_CODE (t
) == STATEMENT_LIST
)
5789 tree_stmt_iterator i
;
5790 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
5792 if (! build_data_member_initialization (tsi_stmt (i
), vec
))
5797 if (TREE_CODE (t
) == CLEANUP_STMT
)
5799 /* We can't see a CLEANUP_STMT in a constructor for a literal class,
5800 but we can in a constexpr constructor for a non-literal class. Just
5801 ignore it; either all the initialization will be constant, in which
5802 case the cleanup can't run, or it can't be constexpr.
5803 Still recurse into CLEANUP_BODY. */
5804 return build_data_member_initialization (CLEANUP_BODY (t
), vec
);
5806 if (TREE_CODE (t
) == CONVERT_EXPR
)
5807 t
= TREE_OPERAND (t
, 0);
5808 if (TREE_CODE (t
) == INIT_EXPR
5809 || TREE_CODE (t
) == MODIFY_EXPR
)
5811 member
= TREE_OPERAND (t
, 0);
5812 init
= unshare_expr (TREE_OPERAND (t
, 1));
5816 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
5817 member
= CALL_EXPR_ARG (t
, 0);
5818 /* We don't use build_cplus_new here because it complains about
5819 abstract bases. Leaving the call unwrapped means that it has the
5820 wrong type, but cxx_eval_constant_expression doesn't care. */
5821 init
= unshare_expr (t
);
5823 if (TREE_CODE (member
) == INDIRECT_REF
)
5824 member
= TREE_OPERAND (member
, 0);
5825 if (TREE_CODE (member
) == NOP_EXPR
)
5829 if (TREE_CODE (op
) == ADDR_EXPR
)
5831 gcc_assert (same_type_ignoring_top_level_qualifiers_p
5832 (TREE_TYPE (TREE_TYPE (op
)),
5833 TREE_TYPE (TREE_TYPE (member
))));
5834 /* Initializing a cv-qualified member; we need to look through
5838 else if (op
== current_class_ptr
5839 && (same_type_ignoring_top_level_qualifiers_p
5840 (TREE_TYPE (TREE_TYPE (member
)),
5841 current_class_type
)))
5842 /* Delegating constructor. */
5846 /* This is an initializer for an empty base; keep it for now so
5847 we can check it in cxx_eval_bare_aggregate. */
5848 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member
))));
5851 if (TREE_CODE (member
) == ADDR_EXPR
)
5852 member
= TREE_OPERAND (member
, 0);
5853 if (TREE_CODE (member
) == COMPONENT_REF
5854 /* If we're initializing a member of a subaggregate, it's a vtable
5855 pointer. Leave it as COMPONENT_REF so we remember the path to get
5857 && TREE_CODE (TREE_OPERAND (member
, 0)) != COMPONENT_REF
)
5858 member
= TREE_OPERAND (member
, 1);
5859 CONSTRUCTOR_APPEND_ELT (*vec
, member
, init
);
5863 /* Make sure that there are no statements after LAST in the constructor
5864 body represented by LIST. */
5867 check_constexpr_ctor_body (tree last
, tree list
)
5870 if (TREE_CODE (list
) == STATEMENT_LIST
)
5872 tree_stmt_iterator i
= tsi_last (list
);
5873 for (; !tsi_end_p (i
); tsi_prev (&i
))
5875 tree t
= tsi_stmt (i
);
5878 if (TREE_CODE (t
) == BIND_EXPR
)
5880 if (!check_constexpr_ctor_body (last
, BIND_EXPR_BODY (t
)))
5885 /* We currently allow typedefs and static_assert.
5886 FIXME allow them in the standard, too. */
5887 if (TREE_CODE (t
) != STATIC_ASSERT
)
5894 else if (list
!= last
5895 && TREE_CODE (list
) != STATIC_ASSERT
)
5899 error ("constexpr constructor does not have empty body");
5900 DECL_DECLARED_CONSTEXPR_P (current_function_decl
) = false;
5905 /* Build compile-time evalable representations of member-initializer list
5906 for a constexpr constructor. */
5909 build_constexpr_constructor_member_initializers (tree type
, tree body
)
5911 VEC(constructor_elt
,gc
) *vec
= NULL
;
5913 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
5914 || TREE_CODE (body
) == EH_SPEC_BLOCK
)
5915 body
= TREE_OPERAND (body
, 0);
5916 if (TREE_CODE (body
) == STATEMENT_LIST
)
5917 body
= STATEMENT_LIST_HEAD (body
)->stmt
;
5918 body
= BIND_EXPR_BODY (body
);
5919 if (TREE_CODE (body
) == CLEANUP_POINT_EXPR
)
5921 body
= TREE_OPERAND (body
, 0);
5922 if (TREE_CODE (body
) == EXPR_STMT
)
5923 body
= TREE_OPERAND (body
, 0);
5924 if (TREE_CODE (body
) == INIT_EXPR
5925 && (same_type_ignoring_top_level_qualifiers_p
5926 (TREE_TYPE (TREE_OPERAND (body
, 0)),
5927 current_class_type
)))
5930 return TREE_OPERAND (body
, 1);
5932 ok
= build_data_member_initialization (body
, &vec
);
5934 else if (TREE_CODE (body
) == STATEMENT_LIST
)
5936 tree_stmt_iterator i
;
5937 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
5939 ok
= build_data_member_initialization (tsi_stmt (i
), &vec
);
5944 else if (TREE_CODE (body
) == TRY_BLOCK
)
5946 error ("body of %<constexpr%> constructor cannot be "
5947 "a function-try-block");
5948 return error_mark_node
;
5950 else if (EXPR_P (body
))
5951 ok
= build_data_member_initialization (body
, &vec
);
5953 gcc_assert (errorcount
> 0);
5956 if (VEC_length (constructor_elt
, vec
) > 0)
5958 /* In a delegating constructor, return the target. */
5959 constructor_elt
*ce
= VEC_index (constructor_elt
, vec
, 0);
5960 if (ce
->index
== current_class_ptr
)
5963 VEC_free (constructor_elt
, gc
, vec
);
5967 return build_constructor (type
, vec
);
5970 return error_mark_node
;
5973 /* Subroutine of register_constexpr_fundef. BODY is the body of a function
5974 declared to be constexpr, or a sub-statement thereof. Returns the
5975 return value if suitable, error_mark_node for a statement not allowed in
5976 a constexpr function, or NULL_TREE if no return value was found. */
5979 constexpr_fn_retval (tree body
)
5981 switch (TREE_CODE (body
))
5983 case STATEMENT_LIST
:
5985 tree_stmt_iterator i
;
5986 tree expr
= NULL_TREE
;
5987 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
5989 tree s
= constexpr_fn_retval (tsi_stmt (i
));
5990 if (s
== error_mark_node
)
5991 return error_mark_node
;
5992 else if (s
== NULL_TREE
)
5993 /* Keep iterating. */;
5995 /* Multiple return statements. */
5996 return error_mark_node
;
6004 return unshare_expr (TREE_OPERAND (body
, 0));
6007 if (TREE_CODE (DECL_EXPR_DECL (body
)) == USING_DECL
)
6009 return error_mark_node
;
6011 case CLEANUP_POINT_EXPR
:
6012 return constexpr_fn_retval (TREE_OPERAND (body
, 0));
6018 return error_mark_node
;
6022 /* Subroutine of register_constexpr_fundef. BODY is the DECL_SAVED_TREE of
6023 FUN; do the necessary transformations to turn it into a single expression
6024 that we can store in the hash table. */
6027 massage_constexpr_body (tree fun
, tree body
)
6029 if (DECL_CONSTRUCTOR_P (fun
))
6030 body
= build_constexpr_constructor_member_initializers
6031 (DECL_CONTEXT (fun
), body
);
6034 if (TREE_CODE (body
) == EH_SPEC_BLOCK
)
6035 body
= EH_SPEC_STMTS (body
);
6036 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
6037 body
= TREE_OPERAND (body
, 0);
6038 if (TREE_CODE (body
) == BIND_EXPR
)
6039 body
= BIND_EXPR_BODY (body
);
6040 body
= constexpr_fn_retval (body
);
6045 /* FUN is a constexpr constructor with massaged body BODY. Return true
6046 if some bases/fields are uninitialized, and complain if COMPLAIN. */
6049 cx_check_missing_mem_inits (tree fun
, tree body
, bool complain
)
6056 if (TREE_CODE (body
) != CONSTRUCTOR
)
6059 nelts
= CONSTRUCTOR_NELTS (body
);
6060 ctype
= DECL_CONTEXT (fun
);
6061 field
= TYPE_FIELDS (ctype
);
6063 if (TREE_CODE (ctype
) == UNION_TYPE
)
6065 if (nelts
== 0 && next_initializable_field (field
))
6068 error ("%<constexpr%> constructor for union %qT must "
6069 "initialize exactly one non-static data member", ctype
);
6076 for (i
= 0; i
<= nelts
; ++i
)
6083 index
= CONSTRUCTOR_ELT (body
, i
)->index
;
6084 /* Skip base and vtable inits. */
6085 if (TREE_CODE (index
) != FIELD_DECL
)
6088 for (; field
!= index
; field
= DECL_CHAIN (field
))
6091 if (TREE_CODE (field
) != FIELD_DECL
6092 || (DECL_C_BIT_FIELD (field
) && !DECL_NAME (field
)))
6094 ftype
= strip_array_types (TREE_TYPE (field
));
6095 if (type_has_constexpr_default_constructor (ftype
))
6097 /* It's OK to skip a member with a trivial constexpr ctor.
6098 A constexpr ctor that isn't trivial should have been
6100 gcc_checking_assert (!TYPE_HAS_COMPLEX_DFLT (ftype
)
6101 || errorcount
!= 0);
6106 error ("uninitialized member %qD in %<constexpr%> constructor",
6110 if (field
== NULL_TREE
)
6112 field
= DECL_CHAIN (field
);
6118 /* We are processing the definition of the constexpr function FUN.
6119 Check that its BODY fulfills the propriate requirements and
6120 enter it in the constexpr function definition table.
6121 For constructor BODY is actually the TREE_LIST of the
6122 member-initializer list. */
6125 register_constexpr_fundef (tree fun
, tree body
)
6127 constexpr_fundef entry
;
6128 constexpr_fundef
**slot
;
6130 if (!is_valid_constexpr_fn (fun
, !DECL_GENERATED_P (fun
)))
6133 body
= massage_constexpr_body (fun
, body
);
6134 if (body
== NULL_TREE
|| body
== error_mark_node
)
6136 if (!DECL_CONSTRUCTOR_P (fun
))
6137 error ("body of constexpr function %qD not a return-statement", fun
);
6141 if (!potential_rvalue_constant_expression (body
))
6143 if (!DECL_GENERATED_P (fun
))
6144 require_potential_rvalue_constant_expression (body
);
6148 if (DECL_CONSTRUCTOR_P (fun
)
6149 && cx_check_missing_mem_inits (fun
, body
, !DECL_GENERATED_P (fun
)))
6152 /* Create the constexpr function table if necessary. */
6153 if (constexpr_fundef_table
== NULL
)
6154 constexpr_fundef_table
= htab_create_ggc (101,
6155 constexpr_fundef_hash
,
6156 constexpr_fundef_equal
,
6160 slot
= (constexpr_fundef
**)
6161 htab_find_slot (constexpr_fundef_table
, &entry
, INSERT
);
6163 gcc_assert (*slot
== NULL
);
6164 *slot
= ggc_alloc_constexpr_fundef ();
6170 /* FUN is a non-constexpr function called in a context that requires a
6171 constant expression. If it comes from a constexpr template, explain why
6172 the instantiation isn't constexpr. */
6175 explain_invalid_constexpr_fn (tree fun
)
6177 static struct pointer_set_t
*diagnosed
;
6179 location_t save_loc
;
6180 /* Only diagnose defaulted functions or instantiations. */
6181 if (!DECL_DEFAULTED_FN (fun
)
6182 && !is_instantiation_of_constexpr (fun
))
6184 if (diagnosed
== NULL
)
6185 diagnosed
= pointer_set_create ();
6186 if (pointer_set_insert (diagnosed
, fun
) != 0)
6187 /* Already explained. */
6190 save_loc
= input_location
;
6191 input_location
= DECL_SOURCE_LOCATION (fun
);
6192 inform (0, "%q+D is not usable as a constexpr function because:", fun
);
6193 /* First check the declaration. */
6194 if (is_valid_constexpr_fn (fun
, true))
6196 /* Then if it's OK, the body. */
6197 if (DECL_DEFAULTED_FN (fun
))
6198 explain_implicit_non_constexpr (fun
);
6201 body
= massage_constexpr_body (fun
, DECL_SAVED_TREE (fun
));
6202 require_potential_rvalue_constant_expression (body
);
6203 if (DECL_CONSTRUCTOR_P (fun
))
6204 cx_check_missing_mem_inits (fun
, body
, true);
6207 input_location
= save_loc
;
6210 /* Objects of this type represent calls to constexpr functions
6211 along with the bindings of parameters to their arguments, for
6212 the purpose of compile time evaluation. */
6214 typedef struct GTY(()) constexpr_call
{
6215 /* Description of the constexpr function definition. */
6216 constexpr_fundef
*fundef
;
6217 /* Parameter bindings environment. A TREE_LIST where each TREE_PURPOSE
6218 is a parameter _DECL and the TREE_VALUE is the value of the parameter.
6219 Note: This arrangement is made to accomodate the use of
6220 iterative_hash_template_arg (see pt.c). If you change this
6221 representation, also change the hash calculation in
6222 cxx_eval_call_expression. */
6224 /* Result of the call.
6225 NULL means the call is being evaluated.
6226 error_mark_node means that the evaluation was erroneous;
6227 otherwise, the actuall value of the call. */
6229 /* The hash of this call; we remember it here to avoid having to
6230 recalculate it when expanding the hash table. */
6234 /* A table of all constexpr calls that have been evaluated by the
6235 compiler in this translation unit. */
6237 static GTY ((param_is (constexpr_call
))) htab_t constexpr_call_table
;
6239 static tree
cxx_eval_constant_expression (const constexpr_call
*, tree
,
6240 bool, bool, bool *);
6241 static tree
cxx_eval_vec_perm_expr (const constexpr_call
*, tree
, bool, bool,
6245 /* Compute a hash value for a constexpr call representation. */
6248 constexpr_call_hash (const void *p
)
6250 const constexpr_call
*info
= (const constexpr_call
*) p
;
6254 /* Return 1 if the objects pointed to by P and Q represent calls
6255 to the same constexpr function with the same arguments.
6256 Otherwise, return 0. */
6259 constexpr_call_equal (const void *p
, const void *q
)
6261 const constexpr_call
*lhs
= (const constexpr_call
*) p
;
6262 const constexpr_call
*rhs
= (const constexpr_call
*) q
;
6267 if (!constexpr_fundef_equal (lhs
->fundef
, rhs
->fundef
))
6269 lhs_bindings
= lhs
->bindings
;
6270 rhs_bindings
= rhs
->bindings
;
6271 while (lhs_bindings
!= NULL
&& rhs_bindings
!= NULL
)
6273 tree lhs_arg
= TREE_VALUE (lhs_bindings
);
6274 tree rhs_arg
= TREE_VALUE (rhs_bindings
);
6275 gcc_assert (TREE_TYPE (lhs_arg
) == TREE_TYPE (rhs_arg
));
6276 if (!cp_tree_equal (lhs_arg
, rhs_arg
))
6278 lhs_bindings
= TREE_CHAIN (lhs_bindings
);
6279 rhs_bindings
= TREE_CHAIN (rhs_bindings
);
6281 return lhs_bindings
== rhs_bindings
;
6284 /* Initialize the constexpr call table, if needed. */
6287 maybe_initialize_constexpr_call_table (void)
6289 if (constexpr_call_table
== NULL
)
6290 constexpr_call_table
= htab_create_ggc (101,
6291 constexpr_call_hash
,
6292 constexpr_call_equal
,
6296 /* Return true if T designates the implied `this' parameter. */
6299 is_this_parameter (tree t
)
6301 return t
== current_class_ptr
;
6304 /* We have an expression tree T that represents a call, either CALL_EXPR
6305 or AGGR_INIT_EXPR. If the call is lexically to a named function,
6306 retrun the _DECL for that function. */
6309 get_function_named_in_call (tree t
)
6312 switch (TREE_CODE (t
))
6315 fun
= CALL_EXPR_FN (t
);
6318 case AGGR_INIT_EXPR
:
6319 fun
= AGGR_INIT_EXPR_FN (t
);
6326 if (TREE_CODE (fun
) == ADDR_EXPR
6327 && TREE_CODE (TREE_OPERAND (fun
, 0)) == FUNCTION_DECL
)
6328 fun
= TREE_OPERAND (fun
, 0);
6332 /* We have an expression tree T that represents a call, either CALL_EXPR
6333 or AGGR_INIT_EXPR. Return the Nth argument. */
6336 get_nth_callarg (tree t
, int n
)
6338 switch (TREE_CODE (t
))
6341 return CALL_EXPR_ARG (t
, n
);
6343 case AGGR_INIT_EXPR
:
6344 return AGGR_INIT_EXPR_ARG (t
, n
);
6352 /* Look up the binding of the function parameter T in a constexpr
6353 function call context CALL. */
6356 lookup_parameter_binding (const constexpr_call
*call
, tree t
)
6358 tree b
= purpose_member (t
, call
->bindings
);
6359 return TREE_VALUE (b
);
6362 /* Attempt to evaluate T which represents a call to a builtin function.
6363 We assume here that all builtin functions evaluate to scalar types
6364 represented by _CST nodes. */
6367 cxx_eval_builtin_function_call (const constexpr_call
*call
, tree t
,
6368 bool allow_non_constant
, bool addr
,
6369 bool *non_constant_p
)
6371 const int nargs
= call_expr_nargs (t
);
6372 tree
*args
= (tree
*) alloca (nargs
* sizeof (tree
));
6375 for (i
= 0; i
< nargs
; ++i
)
6377 args
[i
] = cxx_eval_constant_expression (call
, CALL_EXPR_ARG (t
, i
),
6378 allow_non_constant
, addr
,
6380 if (allow_non_constant
&& *non_constant_p
)
6383 if (*non_constant_p
)
6385 new_call
= build_call_array_loc (EXPR_LOCATION (t
), TREE_TYPE (t
),
6386 CALL_EXPR_FN (t
), nargs
, args
);
6387 return fold (new_call
);
6390 /* TEMP is the constant value of a temporary object of type TYPE. Adjust
6391 the type of the value to match. */
6394 adjust_temp_type (tree type
, tree temp
)
6396 if (TREE_TYPE (temp
) == type
)
6398 /* Avoid wrapping an aggregate value in a NOP_EXPR. */
6399 if (TREE_CODE (temp
) == CONSTRUCTOR
)
6400 return build_constructor (type
, CONSTRUCTOR_ELTS (temp
));
6401 gcc_assert (SCALAR_TYPE_P (type
));
6402 return cp_fold_convert (type
, temp
);
6405 /* Subroutine of cxx_eval_call_expression.
6406 We are processing a call expression (either CALL_EXPR or
6407 AGGR_INIT_EXPR) in the call context of OLD_CALL. Evaluate
6408 all arguments and bind their values to correspondings
6409 parameters, making up the NEW_CALL context. */
6412 cxx_bind_parameters_in_call (const constexpr_call
*old_call
, tree t
,
6413 constexpr_call
*new_call
,
6414 bool allow_non_constant
,
6415 bool *non_constant_p
)
6417 const int nargs
= call_expr_nargs (t
);
6418 tree fun
= new_call
->fundef
->decl
;
6419 tree parms
= DECL_ARGUMENTS (fun
);
6421 for (i
= 0; i
< nargs
; ++i
)
6424 tree type
= parms
? TREE_TYPE (parms
) : void_type_node
;
6425 /* For member function, the first argument is a pointer to the implied
6426 object. And for an object contruction, don't bind `this' before
6427 it is fully constructed. */
6428 if (i
== 0 && DECL_CONSTRUCTOR_P (fun
))
6430 x
= get_nth_callarg (t
, i
);
6431 arg
= cxx_eval_constant_expression (old_call
, x
, allow_non_constant
,
6432 TREE_CODE (type
) == REFERENCE_TYPE
,
6434 /* Don't VERIFY_CONSTANT here. */
6435 if (*non_constant_p
&& allow_non_constant
)
6437 /* Just discard ellipsis args after checking their constantitude. */
6440 if (*non_constant_p
)
6441 /* Don't try to adjust the type of non-constant args. */
6444 /* Make sure the binding has the same type as the parm. */
6445 if (TREE_CODE (type
) != REFERENCE_TYPE
)
6446 arg
= adjust_temp_type (type
, arg
);
6447 new_call
->bindings
= tree_cons (parms
, arg
, new_call
->bindings
);
6449 parms
= TREE_CHAIN (parms
);
6453 /* Variables and functions to manage constexpr call expansion context.
6454 These do not need to be marked for PCH or GC. */
6456 /* FIXME remember and print actual constant arguments. */
6457 static VEC(tree
,heap
) *call_stack
= NULL
;
6458 static int call_stack_tick
;
6459 static int last_cx_error_tick
;
6462 push_cx_call_context (tree call
)
6465 if (!EXPR_HAS_LOCATION (call
))
6466 SET_EXPR_LOCATION (call
, input_location
);
6467 VEC_safe_push (tree
, heap
, call_stack
, call
);
6468 if (VEC_length (tree
, call_stack
) > (unsigned) max_constexpr_depth
)
6474 pop_cx_call_context (void)
6477 VEC_pop (tree
, call_stack
);
6481 cx_error_context (void)
6483 VEC(tree
,heap
) *r
= NULL
;
6484 if (call_stack_tick
!= last_cx_error_tick
6485 && !VEC_empty (tree
, call_stack
))
6487 last_cx_error_tick
= call_stack_tick
;
6491 /* Subroutine of cxx_eval_constant_expression.
6492 Evaluate the call expression tree T in the context of OLD_CALL expression
6496 cxx_eval_call_expression (const constexpr_call
*old_call
, tree t
,
6497 bool allow_non_constant
, bool addr
,
6498 bool *non_constant_p
)
6500 location_t loc
= EXPR_LOC_OR_HERE (t
);
6501 tree fun
= get_function_named_in_call (t
);
6503 constexpr_call new_call
= { NULL
, NULL
, NULL
, 0 };
6504 constexpr_call
**slot
;
6505 constexpr_call
*entry
;
6508 if (TREE_CODE (fun
) != FUNCTION_DECL
)
6510 /* Might be a constexpr function pointer. */
6511 fun
= cxx_eval_constant_expression (old_call
, fun
, allow_non_constant
,
6512 /*addr*/false, non_constant_p
);
6513 if (TREE_CODE (fun
) == ADDR_EXPR
)
6514 fun
= TREE_OPERAND (fun
, 0);
6516 if (TREE_CODE (fun
) != FUNCTION_DECL
)
6518 if (!allow_non_constant
&& !*non_constant_p
)
6519 error_at (loc
, "expression %qE does not designate a constexpr "
6521 *non_constant_p
= true;
6524 if (DECL_CLONED_FUNCTION_P (fun
))
6525 fun
= DECL_CLONED_FUNCTION (fun
);
6526 if (is_builtin_fn (fun
))
6527 return cxx_eval_builtin_function_call (old_call
, t
, allow_non_constant
,
6528 addr
, non_constant_p
);
6529 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
6531 if (!allow_non_constant
)
6533 error_at (loc
, "call to non-constexpr function %qD", fun
);
6534 explain_invalid_constexpr_fn (fun
);
6536 *non_constant_p
= true;
6540 /* Shortcut trivial copy constructor/op=. */
6541 if (call_expr_nargs (t
) == 2 && trivial_fn_p (fun
))
6543 tree arg
= convert_from_reference (get_nth_callarg (t
, 1));
6544 return cxx_eval_constant_expression (old_call
, arg
, allow_non_constant
,
6545 addr
, non_constant_p
);
6548 /* If in direct recursive call, optimize definition search. */
6549 if (old_call
!= NULL
&& old_call
->fundef
->decl
== fun
)
6550 new_call
.fundef
= old_call
->fundef
;
6553 new_call
.fundef
= retrieve_constexpr_fundef (fun
);
6554 if (new_call
.fundef
== NULL
|| new_call
.fundef
->body
== NULL
)
6556 if (!allow_non_constant
)
6558 if (DECL_INITIAL (fun
))
6560 /* The definition of fun was somehow unsuitable. */
6561 error_at (loc
, "%qD called in a constant expression", fun
);
6562 explain_invalid_constexpr_fn (fun
);
6565 error_at (loc
, "%qD used before its definition", fun
);
6567 *non_constant_p
= true;
6571 cxx_bind_parameters_in_call (old_call
, t
, &new_call
,
6572 allow_non_constant
, non_constant_p
);
6573 if (*non_constant_p
)
6576 depth_ok
= push_cx_call_context (t
);
6579 = iterative_hash_template_arg (new_call
.bindings
,
6580 constexpr_fundef_hash (new_call
.fundef
));
6582 /* If we have seen this call before, we are done. */
6583 maybe_initialize_constexpr_call_table ();
6584 slot
= (constexpr_call
**)
6585 htab_find_slot (constexpr_call_table
, &new_call
, INSERT
);
6589 /* We need to keep a pointer to the entry, not just the slot, as the
6590 slot can move in the call to cxx_eval_builtin_function_call. */
6591 *slot
= entry
= ggc_alloc_constexpr_call ();
6594 /* Calls which are in progress have their result set to NULL
6595 so that we can detect circular dependencies. */
6596 else if (entry
->result
== NULL
)
6598 if (!allow_non_constant
)
6599 error ("call has circular dependency");
6600 *non_constant_p
= true;
6601 entry
->result
= result
= error_mark_node
;
6606 if (!allow_non_constant
)
6607 error ("constexpr evaluation depth exceeds maximum of %d (use "
6608 "-fconstexpr-depth= to increase the maximum)",
6609 max_constexpr_depth
);
6610 *non_constant_p
= true;
6611 entry
->result
= result
= error_mark_node
;
6615 result
= entry
->result
;
6616 if (!result
|| result
== error_mark_node
)
6617 result
= (cxx_eval_constant_expression
6618 (&new_call
, new_call
.fundef
->body
,
6619 allow_non_constant
, addr
,
6621 if (result
== error_mark_node
)
6622 *non_constant_p
= true;
6623 if (*non_constant_p
)
6624 entry
->result
= result
= error_mark_node
;
6627 /* If this was a call to initialize an object, set the type of
6628 the CONSTRUCTOR to the type of that object. */
6629 if (DECL_CONSTRUCTOR_P (fun
))
6631 tree ob_arg
= get_nth_callarg (t
, 0);
6632 STRIP_NOPS (ob_arg
);
6633 gcc_assert (TREE_CODE (TREE_TYPE (ob_arg
)) == POINTER_TYPE
6634 && CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (ob_arg
))));
6635 result
= adjust_temp_type (TREE_TYPE (TREE_TYPE (ob_arg
)),
6638 entry
->result
= result
;
6642 pop_cx_call_context ();
6643 return unshare_expr (result
);
6646 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
6649 reduced_constant_expression_p (tree t
)
6651 if (TREE_OVERFLOW_P (t
))
6652 /* Integer overflow makes this not a constant expression. */
6654 /* FIXME are we calling this too much? */
6655 return initializer_constant_valid_p (t
, TREE_TYPE (t
)) != NULL_TREE
;
6658 /* Some expressions may have constant operands but are not constant
6659 themselves, such as 1/0. Call this function (or rather, the macro
6660 following it) to check for that condition.
6662 We only call this in places that require an arithmetic constant, not in
6663 places where we might have a non-constant expression that can be a
6664 component of a constant expression, such as the address of a constexpr
6665 variable that might be dereferenced later. */
6668 verify_constant (tree t
, bool allow_non_constant
, bool *non_constant_p
)
6670 if (!*non_constant_p
&& !reduced_constant_expression_p (t
))
6672 if (!allow_non_constant
)
6674 /* If T was already folded to a _CST with TREE_OVERFLOW set,
6675 printing the folded constant isn't helpful. */
6676 if (TREE_OVERFLOW_P (t
))
6678 permerror (input_location
, "overflow in constant expression");
6679 /* If we're being permissive (and are in an enforcing
6680 context), consider this constant. */
6681 if (flag_permissive
)
6685 error ("%q+E is not a constant expression", t
);
6687 *non_constant_p
= true;
6689 return *non_constant_p
;
6691 #define VERIFY_CONSTANT(X) \
6693 if (verify_constant ((X), allow_non_constant, non_constant_p)) \
6697 /* Subroutine of cxx_eval_constant_expression.
6698 Attempt to reduce the unary expression tree T to a compile time value.
6699 If successful, return the value. Otherwise issue a diagnostic
6700 and return error_mark_node. */
6703 cxx_eval_unary_expression (const constexpr_call
*call
, tree t
,
6704 bool allow_non_constant
, bool addr
,
6705 bool *non_constant_p
)
6708 tree orig_arg
= TREE_OPERAND (t
, 0);
6709 tree arg
= cxx_eval_constant_expression (call
, orig_arg
, allow_non_constant
,
6710 addr
, non_constant_p
);
6711 VERIFY_CONSTANT (arg
);
6712 if (arg
== orig_arg
)
6714 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), arg
);
6715 VERIFY_CONSTANT (r
);
6719 /* Subroutine of cxx_eval_constant_expression.
6720 Like cxx_eval_unary_expression, except for binary expressions. */
6723 cxx_eval_binary_expression (const constexpr_call
*call
, tree t
,
6724 bool allow_non_constant
, bool addr
,
6725 bool *non_constant_p
)
6728 tree orig_lhs
= TREE_OPERAND (t
, 0);
6729 tree orig_rhs
= TREE_OPERAND (t
, 1);
6731 lhs
= cxx_eval_constant_expression (call
, orig_lhs
,
6732 allow_non_constant
, addr
,
6734 VERIFY_CONSTANT (lhs
);
6735 rhs
= cxx_eval_constant_expression (call
, orig_rhs
,
6736 allow_non_constant
, addr
,
6738 VERIFY_CONSTANT (rhs
);
6739 if (lhs
== orig_lhs
&& rhs
== orig_rhs
)
6741 r
= fold_build2 (TREE_CODE (t
), TREE_TYPE (t
), lhs
, rhs
);
6742 VERIFY_CONSTANT (r
);
6746 /* Subroutine of cxx_eval_constant_expression.
6747 Attempt to evaluate condition expressions. Dead branches are not
6751 cxx_eval_conditional_expression (const constexpr_call
*call
, tree t
,
6752 bool allow_non_constant
, bool addr
,
6753 bool *non_constant_p
)
6755 tree val
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 0),
6756 allow_non_constant
, addr
,
6758 VERIFY_CONSTANT (val
);
6759 /* Don't VERIFY_CONSTANT the other operands. */
6760 if (integer_zerop (val
))
6761 return cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 2),
6762 allow_non_constant
, addr
,
6764 return cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 1),
6765 allow_non_constant
, addr
,
6769 /* Subroutine of cxx_eval_constant_expression.
6770 Attempt to reduce a reference to an array slot. */
6773 cxx_eval_array_reference (const constexpr_call
*call
, tree t
,
6774 bool allow_non_constant
, bool addr
,
6775 bool *non_constant_p
)
6777 tree oldary
= TREE_OPERAND (t
, 0);
6778 tree ary
= cxx_eval_constant_expression (call
, oldary
,
6779 allow_non_constant
, addr
,
6784 unsigned len
, elem_nchars
= 1;
6785 if (*non_constant_p
)
6787 oldidx
= TREE_OPERAND (t
, 1);
6788 index
= cxx_eval_constant_expression (call
, oldidx
,
6789 allow_non_constant
, false,
6791 VERIFY_CONSTANT (index
);
6792 if (addr
&& ary
== oldary
&& index
== oldidx
)
6795 return build4 (ARRAY_REF
, TREE_TYPE (t
), ary
, index
, NULL
, NULL
);
6796 elem_type
= TREE_TYPE (TREE_TYPE (ary
));
6797 if (TREE_CODE (ary
) == CONSTRUCTOR
)
6798 len
= CONSTRUCTOR_NELTS (ary
);
6799 else if (TREE_CODE (ary
) == STRING_CST
)
6801 elem_nchars
= (TYPE_PRECISION (elem_type
)
6802 / TYPE_PRECISION (char_type_node
));
6803 len
= (unsigned) TREE_STRING_LENGTH (ary
) / elem_nchars
;
6807 /* We can't do anything with other tree codes, so use
6808 VERIFY_CONSTANT to complain and fail. */
6809 VERIFY_CONSTANT (ary
);
6812 if (compare_tree_int (index
, len
) >= 0)
6814 if (tree_int_cst_lt (index
, array_type_nelts_top (TREE_TYPE (ary
))))
6816 /* If it's within the array bounds but doesn't have an explicit
6817 initializer, it's value-initialized. */
6818 tree val
= build_value_init (elem_type
, tf_warning_or_error
);
6819 return cxx_eval_constant_expression (call
, val
,
6820 allow_non_constant
, addr
,
6824 if (!allow_non_constant
)
6825 error ("array subscript out of bound");
6826 *non_constant_p
= true;
6829 i
= tree_low_cst (index
, 0);
6830 if (TREE_CODE (ary
) == CONSTRUCTOR
)
6831 return VEC_index (constructor_elt
, CONSTRUCTOR_ELTS (ary
), i
)->value
;
6832 else if (elem_nchars
== 1)
6833 return build_int_cst (cv_unqualified (TREE_TYPE (TREE_TYPE (ary
))),
6834 TREE_STRING_POINTER (ary
)[i
]);
6837 tree type
= cv_unqualified (TREE_TYPE (TREE_TYPE (ary
)));
6838 return native_interpret_expr (type
, (const unsigned char *)
6839 TREE_STRING_POINTER (ary
)
6840 + i
* elem_nchars
, elem_nchars
);
6842 /* Don't VERIFY_CONSTANT here. */
6845 /* Subroutine of cxx_eval_constant_expression.
6846 Attempt to reduce a field access of a value of class type. */
6849 cxx_eval_component_reference (const constexpr_call
*call
, tree t
,
6850 bool allow_non_constant
, bool addr
,
6851 bool *non_constant_p
)
6853 unsigned HOST_WIDE_INT i
;
6856 tree part
= TREE_OPERAND (t
, 1);
6857 tree orig_whole
= TREE_OPERAND (t
, 0);
6858 tree whole
= cxx_eval_constant_expression (call
, orig_whole
,
6859 allow_non_constant
, addr
,
6861 if (whole
== orig_whole
)
6864 return fold_build3 (COMPONENT_REF
, TREE_TYPE (t
),
6865 whole
, part
, NULL_TREE
);
6866 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
6868 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
6870 if (!allow_non_constant
)
6871 error ("%qE is not a constant expression", orig_whole
);
6872 *non_constant_p
= true;
6874 if (DECL_MUTABLE_P (part
))
6876 if (!allow_non_constant
)
6877 error ("mutable %qD is not usable in a constant expression", part
);
6878 *non_constant_p
= true;
6880 if (*non_constant_p
)
6882 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
6887 if (TREE_CODE (TREE_TYPE (whole
)) == UNION_TYPE
6888 && CONSTRUCTOR_NELTS (whole
) > 0)
6890 /* DR 1188 says we don't have to deal with this. */
6891 if (!allow_non_constant
)
6892 error ("accessing %qD member instead of initialized %qD member in "
6893 "constant expression", part
, CONSTRUCTOR_ELT (whole
, 0)->index
);
6894 *non_constant_p
= true;
6898 /* If there's no explicit init for this field, it's value-initialized. */
6899 value
= build_value_init (TREE_TYPE (t
), tf_warning_or_error
);
6900 return cxx_eval_constant_expression (call
, value
,
6901 allow_non_constant
, addr
,
6905 /* Subroutine of cxx_eval_constant_expression.
6906 Attempt to reduce a field access of a value of class type that is
6907 expressed as a BIT_FIELD_REF. */
6910 cxx_eval_bit_field_ref (const constexpr_call
*call
, tree t
,
6911 bool allow_non_constant
, bool addr
,
6912 bool *non_constant_p
)
6914 tree orig_whole
= TREE_OPERAND (t
, 0);
6915 tree retval
, fldval
, utype
, mask
;
6916 bool fld_seen
= false;
6917 HOST_WIDE_INT istart
, isize
;
6918 tree whole
= cxx_eval_constant_expression (call
, orig_whole
,
6919 allow_non_constant
, addr
,
6921 tree start
, field
, value
;
6922 unsigned HOST_WIDE_INT i
;
6924 if (whole
== orig_whole
)
6926 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
6928 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
6930 if (!allow_non_constant
)
6931 error ("%qE is not a constant expression", orig_whole
);
6932 *non_constant_p
= true;
6934 if (*non_constant_p
)
6937 start
= TREE_OPERAND (t
, 2);
6938 istart
= tree_low_cst (start
, 0);
6939 isize
= tree_low_cst (TREE_OPERAND (t
, 1), 0);
6940 utype
= TREE_TYPE (t
);
6941 if (!TYPE_UNSIGNED (utype
))
6942 utype
= build_nonstandard_integer_type (TYPE_PRECISION (utype
), 1);
6943 retval
= build_int_cst (utype
, 0);
6944 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
6946 tree bitpos
= bit_position (field
);
6947 if (bitpos
== start
&& DECL_SIZE (field
) == TREE_OPERAND (t
, 1))
6949 if (TREE_CODE (TREE_TYPE (field
)) == INTEGER_TYPE
6950 && TREE_CODE (value
) == INTEGER_CST
6951 && host_integerp (bitpos
, 0)
6952 && host_integerp (DECL_SIZE (field
), 0))
6954 HOST_WIDE_INT bit
= tree_low_cst (bitpos
, 0);
6955 HOST_WIDE_INT sz
= tree_low_cst (DECL_SIZE (field
), 0);
6956 HOST_WIDE_INT shift
;
6957 if (bit
>= istart
&& bit
+ sz
<= istart
+ isize
)
6959 fldval
= fold_convert (utype
, value
);
6960 mask
= build_int_cst_type (utype
, -1);
6961 mask
= fold_build2 (LSHIFT_EXPR
, utype
, mask
,
6962 size_int (TYPE_PRECISION (utype
) - sz
));
6963 mask
= fold_build2 (RSHIFT_EXPR
, utype
, mask
,
6964 size_int (TYPE_PRECISION (utype
) - sz
));
6965 fldval
= fold_build2 (BIT_AND_EXPR
, utype
, fldval
, mask
);
6966 shift
= bit
- istart
;
6967 if (BYTES_BIG_ENDIAN
)
6968 shift
= TYPE_PRECISION (utype
) - shift
- sz
;
6969 fldval
= fold_build2 (LSHIFT_EXPR
, utype
, fldval
,
6971 retval
= fold_build2 (BIT_IOR_EXPR
, utype
, retval
, fldval
);
6977 return fold_convert (TREE_TYPE (t
), retval
);
6979 return error_mark_node
;
6982 /* Subroutine of cxx_eval_constant_expression.
6983 Evaluate a short-circuited logical expression T in the context
6984 of a given constexpr CALL. BAILOUT_VALUE is the value for
6985 early return. CONTINUE_VALUE is used here purely for
6986 sanity check purposes. */
6989 cxx_eval_logical_expression (const constexpr_call
*call
, tree t
,
6990 tree bailout_value
, tree continue_value
,
6991 bool allow_non_constant
, bool addr
,
6992 bool *non_constant_p
)
6995 tree lhs
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 0),
6996 allow_non_constant
, addr
,
6998 VERIFY_CONSTANT (lhs
);
6999 if (tree_int_cst_equal (lhs
, bailout_value
))
7001 gcc_assert (tree_int_cst_equal (lhs
, continue_value
));
7002 r
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 1),
7003 allow_non_constant
, addr
, non_constant_p
);
7004 VERIFY_CONSTANT (r
);
7008 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
7009 CONSTRUCTOR elements to initialize (part of) an object containing that
7010 field. Return a pointer to the constructor_elt corresponding to the
7011 initialization of the field. */
7013 static constructor_elt
*
7014 base_field_constructor_elt (VEC(constructor_elt
,gc
) *v
, tree ref
)
7016 tree aggr
= TREE_OPERAND (ref
, 0);
7017 tree field
= TREE_OPERAND (ref
, 1);
7019 constructor_elt
*ce
;
7021 gcc_assert (TREE_CODE (ref
) == COMPONENT_REF
);
7023 if (TREE_CODE (aggr
) == COMPONENT_REF
)
7025 constructor_elt
*base_ce
7026 = base_field_constructor_elt (v
, aggr
);
7027 v
= CONSTRUCTOR_ELTS (base_ce
->value
);
7030 for (i
= 0; VEC_iterate (constructor_elt
, v
, i
, ce
); ++i
)
7031 if (ce
->index
== field
)
7038 /* Subroutine of cxx_eval_constant_expression.
7039 The expression tree T denotes a C-style array or a C-style
7040 aggregate. Reduce it to a constant expression. */
7043 cxx_eval_bare_aggregate (const constexpr_call
*call
, tree t
,
7044 bool allow_non_constant
, bool addr
,
7045 bool *non_constant_p
)
7047 VEC(constructor_elt
,gc
) *v
= CONSTRUCTOR_ELTS (t
);
7048 VEC(constructor_elt
,gc
) *n
= VEC_alloc (constructor_elt
, gc
,
7049 VEC_length (constructor_elt
, v
));
7050 constructor_elt
*ce
;
7052 bool changed
= false;
7053 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t
));
7054 for (i
= 0; VEC_iterate (constructor_elt
, v
, i
, ce
); ++i
)
7056 tree elt
= cxx_eval_constant_expression (call
, ce
->value
,
7057 allow_non_constant
, addr
,
7059 /* Don't VERIFY_CONSTANT here. */
7060 if (allow_non_constant
&& *non_constant_p
)
7062 if (elt
!= ce
->value
)
7064 if (TREE_CODE (ce
->index
) == COMPONENT_REF
)
7066 /* This is an initialization of a vfield inside a base
7067 subaggregate that we already initialized; push this
7068 initialization into the previous initialization. */
7069 constructor_elt
*inner
= base_field_constructor_elt (n
, ce
->index
);
7072 else if (TREE_CODE (ce
->index
) == NOP_EXPR
)
7074 /* This is an initializer for an empty base; now that we've
7075 checked that it's constant, we can ignore it. */
7076 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (ce
->index
))));
7079 CONSTRUCTOR_APPEND_ELT (n
, ce
->index
, elt
);
7081 if (*non_constant_p
|| !changed
)
7084 VEC_free (constructor_elt
, gc
, n
);
7087 t
= build_constructor (TREE_TYPE (t
), n
);
7088 TREE_CONSTANT (t
) = true;
7092 /* Subroutine of cxx_eval_constant_expression.
7093 The expression tree T is a VEC_INIT_EXPR which denotes the desired
7094 initialization of a non-static data member of array type. Reduce it to a
7097 Note that apart from value-initialization (when VALUE_INIT is true),
7098 this is only intended to support value-initialization and the
7099 initializations done by defaulted constructors for classes with
7100 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
7101 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
7102 for the copy/move constructor. */
7105 cxx_eval_vec_init_1 (const constexpr_call
*call
, tree atype
, tree init
,
7106 bool value_init
, bool allow_non_constant
, bool addr
,
7107 bool *non_constant_p
)
7109 tree elttype
= TREE_TYPE (atype
);
7110 int max
= tree_low_cst (array_type_nelts (atype
), 0);
7111 VEC(constructor_elt
,gc
) *n
= VEC_alloc (constructor_elt
, gc
, max
+ 1);
7112 bool pre_init
= false;
7115 /* For the default constructor, build up a call to the default
7116 constructor of the element type. We only need to handle class types
7117 here, as for a constructor to be constexpr, all members must be
7118 initialized, which for a defaulted default constructor means they must
7119 be of a class type with a constexpr default constructor. */
7120 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
7121 /* We only do this at the lowest level. */;
7122 else if (value_init
)
7124 init
= build_value_init (elttype
, tf_warning_or_error
);
7125 init
= cxx_eval_constant_expression
7126 (call
, init
, allow_non_constant
, addr
, non_constant_p
);
7131 VEC(tree
,gc
) *argvec
= make_tree_vector ();
7132 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
7133 &argvec
, elttype
, LOOKUP_NORMAL
,
7134 tf_warning_or_error
);
7135 release_tree_vector (argvec
);
7136 init
= cxx_eval_constant_expression (call
, init
, allow_non_constant
,
7137 addr
, non_constant_p
);
7141 if (*non_constant_p
&& !allow_non_constant
)
7144 for (i
= 0; i
<= max
; ++i
)
7146 tree idx
= build_int_cst (size_type_node
, i
);
7148 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
7150 /* A multidimensional array; recurse. */
7151 if (value_init
|| init
== NULL_TREE
)
7152 eltinit
= NULL_TREE
;
7154 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
7155 tf_warning_or_error
);
7156 eltinit
= cxx_eval_vec_init_1 (call
, elttype
, eltinit
, value_init
,
7157 allow_non_constant
, addr
,
7162 /* Initializing an element using value or default initialization
7163 we just pre-built above. */
7167 eltinit
= unshare_expr (init
);
7171 /* Copying an element. */
7172 VEC(tree
,gc
) *argvec
;
7173 gcc_assert (same_type_ignoring_top_level_qualifiers_p
7174 (atype
, TREE_TYPE (init
)));
7175 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
7176 tf_warning_or_error
);
7177 if (!real_lvalue_p (init
))
7178 eltinit
= move (eltinit
);
7179 argvec
= make_tree_vector ();
7180 VEC_quick_push (tree
, argvec
, eltinit
);
7181 eltinit
= (build_special_member_call
7182 (NULL_TREE
, complete_ctor_identifier
, &argvec
,
7183 elttype
, LOOKUP_NORMAL
, tf_warning_or_error
));
7184 release_tree_vector (argvec
);
7185 eltinit
= cxx_eval_constant_expression
7186 (call
, eltinit
, allow_non_constant
, addr
, non_constant_p
);
7188 if (*non_constant_p
&& !allow_non_constant
)
7190 CONSTRUCTOR_APPEND_ELT (n
, idx
, eltinit
);
7193 if (!*non_constant_p
)
7195 init
= build_constructor (atype
, n
);
7196 TREE_CONSTANT (init
) = true;
7201 VEC_free (constructor_elt
, gc
, n
);
7206 cxx_eval_vec_init (const constexpr_call
*call
, tree t
,
7207 bool allow_non_constant
, bool addr
,
7208 bool *non_constant_p
)
7210 tree atype
= TREE_TYPE (t
);
7211 tree init
= VEC_INIT_EXPR_INIT (t
);
7212 tree r
= cxx_eval_vec_init_1 (call
, atype
, init
,
7213 VEC_INIT_EXPR_VALUE_INIT (t
),
7214 allow_non_constant
, addr
, non_constant_p
);
7215 if (*non_constant_p
)
7221 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
7222 match. We want to be less strict for simple *& folding; if we have a
7223 non-const temporary that we access through a const pointer, that should
7224 work. We handle this here rather than change fold_indirect_ref_1
7225 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
7226 don't really make sense outside of constant expression evaluation. Also
7227 we want to allow folding to COMPONENT_REF, which could cause trouble
7228 with TBAA in fold_indirect_ref_1.
7230 Try to keep this function synced with fold_indirect_ref_1. */
7233 cxx_fold_indirect_ref (location_t loc
, tree type
, tree op0
, bool *empty_base
)
7239 subtype
= TREE_TYPE (sub
);
7240 if (!POINTER_TYPE_P (subtype
))
7243 if (TREE_CODE (sub
) == ADDR_EXPR
)
7245 tree op
= TREE_OPERAND (sub
, 0);
7246 tree optype
= TREE_TYPE (op
);
7248 /* *&CONST_DECL -> to the value of the const decl. */
7249 if (TREE_CODE (op
) == CONST_DECL
)
7250 return DECL_INITIAL (op
);
7251 /* *&p => p; make sure to handle *&"str"[cst] here. */
7252 if (same_type_ignoring_top_level_qualifiers_p (optype
, type
))
7254 tree fop
= fold_read_from_constant_string (op
);
7260 /* *(foo *)&fooarray => fooarray[0] */
7261 else if (TREE_CODE (optype
) == ARRAY_TYPE
7262 && (same_type_ignoring_top_level_qualifiers_p
7263 (type
, TREE_TYPE (optype
))))
7265 tree type_domain
= TYPE_DOMAIN (optype
);
7266 tree min_val
= size_zero_node
;
7267 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
7268 min_val
= TYPE_MIN_VALUE (type_domain
);
7269 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
7270 NULL_TREE
, NULL_TREE
);
7272 /* *(foo *)&complexfoo => __real__ complexfoo */
7273 else if (TREE_CODE (optype
) == COMPLEX_TYPE
7274 && (same_type_ignoring_top_level_qualifiers_p
7275 (type
, TREE_TYPE (optype
))))
7276 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
7277 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
7278 else if (TREE_CODE (optype
) == VECTOR_TYPE
7279 && (same_type_ignoring_top_level_qualifiers_p
7280 (type
, TREE_TYPE (optype
))))
7282 tree part_width
= TYPE_SIZE (type
);
7283 tree index
= bitsize_int (0);
7284 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
, index
);
7286 /* Also handle conversion to an empty base class, which
7287 is represented with a NOP_EXPR. */
7288 else if (is_empty_class (type
)
7289 && CLASS_TYPE_P (optype
)
7290 && DERIVED_FROM_P (type
, optype
))
7295 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
7296 else if (RECORD_OR_UNION_TYPE_P (optype
))
7298 tree field
= TYPE_FIELDS (optype
);
7299 for (; field
; field
= DECL_CHAIN (field
))
7300 if (TREE_CODE (field
) == FIELD_DECL
7301 && integer_zerop (byte_position (field
))
7302 && (same_type_ignoring_top_level_qualifiers_p
7303 (TREE_TYPE (field
), type
)))
7305 return fold_build3 (COMPONENT_REF
, type
, op
, field
, NULL_TREE
);
7310 else if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
7311 && TREE_CODE (TREE_OPERAND (sub
, 1)) == INTEGER_CST
)
7313 tree op00
= TREE_OPERAND (sub
, 0);
7314 tree op01
= TREE_OPERAND (sub
, 1);
7317 if (TREE_CODE (op00
) == ADDR_EXPR
)
7320 op00
= TREE_OPERAND (op00
, 0);
7321 op00type
= TREE_TYPE (op00
);
7323 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
7324 if (TREE_CODE (op00type
) == VECTOR_TYPE
7325 && (same_type_ignoring_top_level_qualifiers_p
7326 (type
, TREE_TYPE (op00type
))))
7328 HOST_WIDE_INT offset
= tree_low_cst (op01
, 0);
7329 tree part_width
= TYPE_SIZE (type
);
7330 unsigned HOST_WIDE_INT part_widthi
= tree_low_cst (part_width
, 0)/BITS_PER_UNIT
;
7331 unsigned HOST_WIDE_INT indexi
= offset
* BITS_PER_UNIT
;
7332 tree index
= bitsize_int (indexi
);
7334 if (offset
/part_widthi
<= TYPE_VECTOR_SUBPARTS (op00type
))
7335 return fold_build3_loc (loc
,
7336 BIT_FIELD_REF
, type
, op00
,
7340 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
7341 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
7342 && (same_type_ignoring_top_level_qualifiers_p
7343 (type
, TREE_TYPE (op00type
))))
7345 tree size
= TYPE_SIZE_UNIT (type
);
7346 if (tree_int_cst_equal (size
, op01
))
7347 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
7349 /* ((foo *)&fooarray)[1] => fooarray[1] */
7350 else if (TREE_CODE (op00type
) == ARRAY_TYPE
7351 && (same_type_ignoring_top_level_qualifiers_p
7352 (type
, TREE_TYPE (op00type
))))
7354 tree type_domain
= TYPE_DOMAIN (op00type
);
7355 tree min_val
= size_zero_node
;
7356 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
7357 min_val
= TYPE_MIN_VALUE (type_domain
);
7358 op01
= size_binop_loc (loc
, EXACT_DIV_EXPR
, op01
,
7359 TYPE_SIZE_UNIT (type
));
7360 op01
= size_binop_loc (loc
, PLUS_EXPR
, op01
, min_val
);
7361 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
7362 NULL_TREE
, NULL_TREE
);
7364 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
7365 else if (RECORD_OR_UNION_TYPE_P (op00type
))
7367 tree field
= TYPE_FIELDS (op00type
);
7368 for (; field
; field
= DECL_CHAIN (field
))
7369 if (TREE_CODE (field
) == FIELD_DECL
7370 && tree_int_cst_equal (byte_position (field
), op01
)
7371 && (same_type_ignoring_top_level_qualifiers_p
7372 (TREE_TYPE (field
), type
)))
7374 return fold_build3 (COMPONENT_REF
, type
, op00
,
7381 /* *(foo *)fooarrptreturn> (*fooarrptr)[0] */
7382 else if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
7383 && (same_type_ignoring_top_level_qualifiers_p
7384 (type
, TREE_TYPE (TREE_TYPE (subtype
)))))
7387 tree min_val
= size_zero_node
;
7388 sub
= cxx_fold_indirect_ref (loc
, TREE_TYPE (subtype
), sub
, NULL
);
7390 sub
= build1_loc (loc
, INDIRECT_REF
, TREE_TYPE (subtype
), sub
);
7391 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
7392 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
7393 min_val
= TYPE_MIN_VALUE (type_domain
);
7394 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
7402 cxx_eval_indirect_ref (const constexpr_call
*call
, tree t
,
7403 bool allow_non_constant
, bool addr
,
7404 bool *non_constant_p
)
7406 tree orig_op0
= TREE_OPERAND (t
, 0);
7407 tree op0
= cxx_eval_constant_expression (call
, orig_op0
, allow_non_constant
,
7408 /*addr*/false, non_constant_p
);
7409 bool empty_base
= false;
7412 /* Don't VERIFY_CONSTANT here. */
7413 if (*non_constant_p
)
7416 r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), op0
,
7420 r
= cxx_eval_constant_expression (call
, r
, allow_non_constant
,
7421 addr
, non_constant_p
);
7426 if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
)
7428 sub
= TREE_OPERAND (sub
, 0);
7431 if (TREE_CODE (sub
) == ADDR_EXPR
)
7433 /* We couldn't fold to a constant value. Make sure it's not
7434 something we should have been able to fold. */
7435 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
7436 (TREE_TYPE (TREE_TYPE (sub
)), TREE_TYPE (t
)));
7437 /* DR 1188 says we don't have to deal with this. */
7438 if (!allow_non_constant
)
7439 error ("accessing value of %qE through a %qT glvalue in a "
7440 "constant expression", build_fold_indirect_ref (sub
),
7442 *non_constant_p
= true;
7447 /* If we're pulling out the value of an empty base, make sure
7448 that the whole object is constant and then return an empty
7452 VERIFY_CONSTANT (r
);
7453 r
= build_constructor (TREE_TYPE (t
), NULL
);
7454 TREE_CONSTANT (r
) = true;
7462 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
7463 Shared between potential_constant_expression and
7464 cxx_eval_constant_expression. */
7467 non_const_var_error (tree r
)
7469 tree type
= TREE_TYPE (r
);
7470 error ("the value of %qD is not usable in a constant "
7472 /* Avoid error cascade. */
7473 if (DECL_INITIAL (r
) == error_mark_node
)
7475 if (DECL_DECLARED_CONSTEXPR_P (r
))
7476 inform (DECL_SOURCE_LOCATION (r
),
7477 "%qD used in its own initializer", r
);
7478 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
7480 if (!CP_TYPE_CONST_P (type
))
7481 inform (DECL_SOURCE_LOCATION (r
),
7482 "%q#D is not const", r
);
7483 else if (CP_TYPE_VOLATILE_P (type
))
7484 inform (DECL_SOURCE_LOCATION (r
),
7485 "%q#D is volatile", r
);
7486 else if (!DECL_INITIAL (r
)
7487 || !TREE_CONSTANT (DECL_INITIAL (r
)))
7488 inform (DECL_SOURCE_LOCATION (r
),
7489 "%qD was not initialized with a constant "
7496 if (cxx_dialect
>= cxx0x
&& !DECL_DECLARED_CONSTEXPR_P (r
))
7497 inform (DECL_SOURCE_LOCATION (r
),
7498 "%qD was not declared %<constexpr%>", r
);
7500 inform (DECL_SOURCE_LOCATION (r
),
7501 "%qD does not have integral or enumeration type",
7506 /* Evaluate VEC_PERM_EXPR (v1, v2, mask). */
7508 cxx_eval_vec_perm_expr (const constexpr_call
*call
, tree t
,
7509 bool allow_non_constant
, bool addr
,
7510 bool * non_constant_p
)
7515 tree elttype
= TREE_TYPE (t
);
7517 for (i
= 0; i
< 3; i
++)
7519 args
[i
] = cxx_eval_constant_expression (call
, TREE_OPERAND (t
, i
),
7520 allow_non_constant
, addr
,
7522 if (*non_constant_p
)
7526 gcc_assert (TREE_CODE (TREE_TYPE (args
[0])) == VECTOR_TYPE
);
7527 gcc_assert (TREE_CODE (TREE_TYPE (args
[1])) == VECTOR_TYPE
);
7528 gcc_assert (TREE_CODE (TREE_TYPE (args
[2])) == VECTOR_TYPE
);
7530 val
= fold_ternary_loc (EXPR_LOCATION (t
), VEC_PERM_EXPR
, elttype
,
7531 args
[0], args
[1], args
[2]);
7532 if (val
!= NULL_TREE
)
7539 /* Attempt to reduce the expression T to a constant value.
7540 On failure, issue diagnostic and return error_mark_node. */
7541 /* FIXME unify with c_fully_fold */
7544 cxx_eval_constant_expression (const constexpr_call
*call
, tree t
,
7545 bool allow_non_constant
, bool addr
,
7546 bool *non_constant_p
)
7550 if (t
== error_mark_node
)
7552 *non_constant_p
= true;
7555 if (CONSTANT_CLASS_P (t
))
7557 if (TREE_CODE (t
) == PTRMEM_CST
)
7558 t
= cplus_expand_constant (t
);
7561 if (TREE_CODE (t
) != NOP_EXPR
7562 && reduced_constant_expression_p (t
))
7565 switch (TREE_CODE (t
))
7570 /* else fall through. */
7572 r
= integral_constant_value (t
);
7573 if (TREE_CODE (r
) == TARGET_EXPR
7574 && TREE_CODE (TARGET_EXPR_INITIAL (r
)) == CONSTRUCTOR
)
7575 r
= TARGET_EXPR_INITIAL (r
);
7578 if (!allow_non_constant
)
7579 non_const_var_error (r
);
7580 *non_constant_p
= true;
7590 if (call
&& DECL_CONTEXT (t
) == call
->fundef
->decl
)
7592 if (DECL_ARTIFICIAL (t
) && DECL_CONSTRUCTOR_P (DECL_CONTEXT (t
)))
7594 if (!allow_non_constant
)
7595 sorry ("use of the value of the object being constructed "
7596 "in a constant expression");
7597 *non_constant_p
= true;
7600 r
= lookup_parameter_binding (call
, t
);
7603 /* Defer in case this is only used for its type. */;
7606 if (!allow_non_constant
)
7607 error ("%qE is not a constant expression", t
);
7608 *non_constant_p
= true;
7613 case AGGR_INIT_EXPR
:
7614 r
= cxx_eval_call_expression (call
, t
, allow_non_constant
, addr
,
7619 if (!literal_type_p (TREE_TYPE (t
)))
7621 if (!allow_non_constant
)
7623 error ("temporary of non-literal type %qT in a "
7624 "constant expression", TREE_TYPE (t
));
7625 explain_non_literal_class (TREE_TYPE (t
));
7627 *non_constant_p
= true;
7630 /* else fall through. */
7632 /* Pass false for 'addr' because these codes indicate
7633 initialization of a temporary. */
7634 r
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 1),
7635 allow_non_constant
, false,
7637 if (!*non_constant_p
)
7638 /* Adjust the type of the result to the type of the temporary. */
7639 r
= adjust_temp_type (TREE_TYPE (t
), r
);
7643 r
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 1),
7644 allow_non_constant
, addr
,
7649 case NON_LVALUE_EXPR
:
7650 case TRY_CATCH_EXPR
:
7651 case CLEANUP_POINT_EXPR
:
7652 case MUST_NOT_THROW_EXPR
:
7654 r
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 0),
7655 allow_non_constant
, addr
,
7659 /* These differ from cxx_eval_unary_expression in that this doesn't
7660 check for a constant operand or result; an address can be
7661 constant without its operand being, and vice versa. */
7663 r
= cxx_eval_indirect_ref (call
, t
, allow_non_constant
, addr
,
7669 tree oldop
= TREE_OPERAND (t
, 0);
7670 tree op
= cxx_eval_constant_expression (call
, oldop
,
7674 /* Don't VERIFY_CONSTANT here. */
7675 if (*non_constant_p
)
7677 /* This function does more aggressive folding than fold itself. */
7678 r
= build_fold_addr_expr_with_type (op
, TREE_TYPE (t
));
7679 if (TREE_CODE (r
) == ADDR_EXPR
&& TREE_OPERAND (r
, 0) == oldop
)
7687 case FIX_TRUNC_EXPR
:
7692 case TRUTH_NOT_EXPR
:
7693 case FIXED_CONVERT_EXPR
:
7694 r
= cxx_eval_unary_expression (call
, t
, allow_non_constant
, addr
,
7700 /* check_return_expr sometimes wraps a TARGET_EXPR in a
7701 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
7702 introduced by build_call_a. */
7703 tree op0
= TREE_OPERAND (t
, 0);
7704 tree op1
= TREE_OPERAND (t
, 1);
7706 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
7707 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
7708 r
= cxx_eval_constant_expression (call
, op0
, allow_non_constant
,
7709 addr
, non_constant_p
);
7712 /* Check that the LHS is constant and then discard it. */
7713 cxx_eval_constant_expression (call
, op0
, allow_non_constant
,
7714 false, non_constant_p
);
7715 r
= cxx_eval_constant_expression (call
, op1
, allow_non_constant
,
7716 addr
, non_constant_p
);
7721 case POINTER_PLUS_EXPR
:
7725 case TRUNC_DIV_EXPR
:
7727 case FLOOR_DIV_EXPR
:
7728 case ROUND_DIV_EXPR
:
7729 case TRUNC_MOD_EXPR
:
7731 case ROUND_MOD_EXPR
:
7733 case EXACT_DIV_EXPR
:
7743 case TRUTH_XOR_EXPR
:
7750 case UNORDERED_EXPR
:
7759 r
= cxx_eval_binary_expression (call
, t
, allow_non_constant
, addr
,
7763 /* fold can introduce non-IF versions of these; still treat them as
7764 short-circuiting. */
7765 case TRUTH_AND_EXPR
:
7766 case TRUTH_ANDIF_EXPR
:
7767 r
= cxx_eval_logical_expression (call
, t
, boolean_false_node
,
7769 allow_non_constant
, addr
,
7774 case TRUTH_ORIF_EXPR
:
7775 r
= cxx_eval_logical_expression (call
, t
, boolean_true_node
,
7777 allow_non_constant
, addr
,
7782 r
= cxx_eval_array_reference (call
, t
, allow_non_constant
, addr
,
7787 r
= cxx_eval_component_reference (call
, t
, allow_non_constant
, addr
,
7792 r
= cxx_eval_bit_field_ref (call
, t
, allow_non_constant
, addr
,
7798 r
= cxx_eval_conditional_expression (call
, t
, allow_non_constant
, addr
,
7803 r
= cxx_eval_bare_aggregate (call
, t
, allow_non_constant
, addr
,
7808 /* We can get this in a defaulted constructor for a class with a
7809 non-static data member of array type. Either the initializer will
7810 be NULL, meaning default-initialization, or it will be an lvalue
7811 or xvalue of the same type, meaning direct-initialization from the
7812 corresponding member. */
7813 r
= cxx_eval_vec_init (call
, t
, allow_non_constant
, addr
,
7818 r
= cxx_eval_vec_perm_expr (call
, t
, allow_non_constant
, addr
,
7823 case VIEW_CONVERT_EXPR
:
7826 tree oldop
= TREE_OPERAND (t
, 0);
7827 tree op
= cxx_eval_constant_expression (call
, oldop
,
7828 allow_non_constant
, addr
,
7830 if (*non_constant_p
)
7833 /* We didn't fold at the top so we could check for ptr-int
7836 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), op
);
7837 /* Conversion of an out-of-range value has implementation-defined
7838 behavior; the language considers it different from arithmetic
7839 overflow, which is undefined. */
7840 if (TREE_OVERFLOW_P (r
) && !TREE_OVERFLOW_P (op
))
7841 TREE_OVERFLOW (r
) = false;
7845 case EMPTY_CLASS_EXPR
:
7846 /* This is good enough for a function argument that might not get
7847 used, and they can't do anything with it, so just return it. */
7851 case PREINCREMENT_EXPR
:
7852 case POSTINCREMENT_EXPR
:
7853 case PREDECREMENT_EXPR
:
7854 case POSTDECREMENT_EXPR
:
7858 case VEC_DELETE_EXPR
:
7862 /* GCC internal stuff. */
7865 case WITH_CLEANUP_EXPR
:
7866 case STATEMENT_LIST
:
7868 case NON_DEPENDENT_EXPR
:
7872 if (!allow_non_constant
)
7873 error_at (EXPR_LOC_OR_HERE (t
),
7874 "expression %qE is not a constant-expression", t
);
7875 *non_constant_p
= true;
7879 internal_error ("unexpected expression %qE of kind %s", t
,
7880 tree_code_name
[TREE_CODE (t
)]);
7881 *non_constant_p
= true;
7885 if (r
== error_mark_node
)
7886 *non_constant_p
= true;
7888 if (*non_constant_p
)
7895 cxx_eval_outermost_constant_expr (tree t
, bool allow_non_constant
)
7897 bool non_constant_p
= false;
7898 tree r
= cxx_eval_constant_expression (NULL
, t
, allow_non_constant
,
7899 false, &non_constant_p
);
7901 verify_constant (r
, allow_non_constant
, &non_constant_p
);
7903 if (TREE_CODE (t
) != CONSTRUCTOR
7904 && cp_has_mutable_p (TREE_TYPE (t
)))
7906 /* We allow a mutable type if the original expression was a
7907 CONSTRUCTOR so that we can do aggregate initialization of
7908 constexpr variables. */
7909 if (!allow_non_constant
)
7910 error ("%qT cannot be the type of a complete constant expression "
7911 "because it has mutable sub-objects", TREE_TYPE (t
));
7912 non_constant_p
= true;
7915 /* Technically we should check this for all subexpressions, but that
7916 runs into problems with our internal representation of pointer
7917 subtraction and the 5.19 rules are still in flux. */
7918 if (CONVERT_EXPR_CODE_P (TREE_CODE (r
))
7919 && ARITHMETIC_TYPE_P (TREE_TYPE (r
))
7920 && TREE_CODE (TREE_OPERAND (r
, 0)) == ADDR_EXPR
)
7922 if (!allow_non_constant
)
7923 error ("conversion from pointer type %qT "
7924 "to arithmetic type %qT in a constant-expression",
7925 TREE_TYPE (TREE_OPERAND (r
, 0)), TREE_TYPE (r
));
7926 non_constant_p
= true;
7929 if (non_constant_p
&& !allow_non_constant
)
7930 return error_mark_node
;
7931 else if (non_constant_p
&& TREE_CONSTANT (t
))
7933 /* This isn't actually constant, so unset TREE_CONSTANT. */
7934 if (EXPR_P (t
) || TREE_CODE (t
) == CONSTRUCTOR
)
7937 r
= build_nop (TREE_TYPE (t
), t
);
7938 TREE_CONSTANT (r
) = false;
7941 else if (non_constant_p
|| r
== t
)
7943 else if (TREE_CODE (r
) == CONSTRUCTOR
&& CLASS_TYPE_P (TREE_TYPE (r
)))
7945 if (TREE_CODE (t
) == TARGET_EXPR
7946 && TARGET_EXPR_INITIAL (t
) == r
)
7950 r
= get_target_expr (r
);
7951 TREE_CONSTANT (r
) = true;
7959 /* Returns true if T is a valid subexpression of a constant expression,
7960 even if it isn't itself a constant expression. */
7963 is_sub_constant_expr (tree t
)
7965 bool non_constant_p
= false;
7966 cxx_eval_constant_expression (NULL
, t
, true, false, &non_constant_p
);
7967 return !non_constant_p
;
7970 /* If T represents a constant expression returns its reduced value.
7971 Otherwise return error_mark_node. If T is dependent, then
7975 cxx_constant_value (tree t
)
7977 return cxx_eval_outermost_constant_expr (t
, false);
7980 /* If T is a constant expression, returns its reduced value.
7981 Otherwise, if T does not have TREE_CONSTANT set, returns T.
7982 Otherwise, returns a version of T without TREE_CONSTANT. */
7985 maybe_constant_value (tree t
)
7989 if (type_dependent_expression_p (t
)
7990 || type_unknown_p (t
)
7991 || BRACE_ENCLOSED_INITIALIZER_P (t
)
7992 || !potential_constant_expression (t
)
7993 || value_dependent_expression_p (t
))
7995 if (TREE_OVERFLOW_P (t
))
7997 t
= build_nop (TREE_TYPE (t
), t
);
7998 TREE_CONSTANT (t
) = false;
8003 r
= cxx_eval_outermost_constant_expr (t
, true);
8004 #ifdef ENABLE_CHECKING
8005 /* cp_tree_equal looks through NOPs, so allow them. */
8007 || CONVERT_EXPR_P (t
)
8008 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
8009 || !cp_tree_equal (r
, t
));
8014 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
8015 than wrapped in a TARGET_EXPR. */
8018 maybe_constant_init (tree t
)
8020 t
= maybe_constant_value (t
);
8021 if (TREE_CODE (t
) == TARGET_EXPR
)
8023 tree init
= TARGET_EXPR_INITIAL (t
);
8024 if (TREE_CODE (init
) == CONSTRUCTOR
8025 && TREE_CONSTANT (init
))
8032 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
8033 /* Return true if the object referred to by REF has automatic or thread
8036 enum { ck_ok
, ck_bad
, ck_unknown
};
8038 check_automatic_or_tls (tree ref
)
8040 enum machine_mode mode
;
8041 HOST_WIDE_INT bitsize
, bitpos
;
8043 int volatilep
= 0, unsignedp
= 0;
8044 tree decl
= get_inner_reference (ref
, &bitsize
, &bitpos
, &offset
,
8045 &mode
, &unsignedp
, &volatilep
, false);
8048 /* If there isn't a decl in the middle, we don't know the linkage here,
8049 and this isn't a constant expression anyway. */
8052 dk
= decl_storage_duration (decl
);
8053 return (dk
== dk_auto
|| dk
== dk_thread
) ? ck_bad
: ck_ok
;
8057 /* Return true if T denotes a potentially constant expression. Issue
8058 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
8059 an lvalue-rvalue conversion is implied.
8061 C++0x [expr.const] used to say
8063 6 An expression is a potential constant expression if it is
8064 a constant expression where all occurences of function
8065 parameters are replaced by arbitrary constant expressions
8066 of the appropriate type.
8068 2 A conditional expression is a constant expression unless it
8069 involves one of the following as a potentially evaluated
8070 subexpression (3.2), but subexpressions of logical AND (5.14),
8071 logical OR (5.15), and conditional (5.16) operations that are
8072 not evaluated are not considered. */
8075 potential_constant_expression_1 (tree t
, bool want_rval
, tsubst_flags_t flags
)
8077 enum { any
= false, rval
= true };
8081 /* C++98 has different rules for the form of a constant expression that
8082 are enforced in the parser, so we can assume that anything that gets
8083 this far is suitable. */
8084 if (cxx_dialect
< cxx0x
)
8087 if (t
== error_mark_node
)
8091 if (TREE_THIS_VOLATILE (t
))
8093 if (flags
& tf_error
)
8094 error ("expression %qE has side-effects", t
);
8097 if (CONSTANT_CLASS_P (t
))
8099 if (TREE_OVERFLOW (t
))
8101 if (flags
& tf_error
)
8103 permerror (EXPR_LOC_OR_HERE (t
),
8104 "overflow in constant expression");
8105 if (flag_permissive
)
8113 switch (TREE_CODE (t
))
8119 case TEMPLATE_ID_EXPR
:
8126 case TEMPLATE_PARM_INDEX
:
8128 case IDENTIFIER_NODE
:
8129 case USERDEF_LITERAL
:
8130 /* We can see a FIELD_DECL in a pointer-to-member expression. */
8136 case AGGR_INIT_EXPR
:
8138 /* -- an invocation of a function other than a constexpr function
8139 or a constexpr constructor. */
8141 tree fun
= get_function_named_in_call (t
);
8142 const int nargs
= call_expr_nargs (t
);
8145 if (is_overloaded_fn (fun
))
8147 if (TREE_CODE (fun
) == FUNCTION_DECL
)
8149 if (builtin_valid_in_constant_expr_p (fun
))
8151 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
8152 /* Allow any built-in function; if the expansion
8153 isn't constant, we'll deal with that then. */
8154 && !is_builtin_fn (fun
))
8156 if (flags
& tf_error
)
8158 error_at (EXPR_LOC_OR_HERE (t
),
8159 "call to non-constexpr function %qD", fun
);
8160 explain_invalid_constexpr_fn (fun
);
8164 /* A call to a non-static member function takes the address
8165 of the object as the first argument. But in a constant
8166 expression the address will be folded away, so look
8168 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
8169 && !DECL_CONSTRUCTOR_P (fun
))
8171 tree x
= get_nth_callarg (t
, 0);
8172 if (is_this_parameter (x
))
8174 if (DECL_CONSTRUCTOR_P (DECL_CONTEXT (x
)))
8176 if (flags
& tf_error
)
8177 sorry ("calling a member function of the "
8178 "object being constructed in a constant "
8182 /* Otherwise OK. */;
8184 else if (!potential_constant_expression_1 (x
, rval
, flags
))
8190 fun
= get_first_fn (fun
);
8191 /* Skip initial arguments to base constructors. */
8192 if (DECL_BASE_CONSTRUCTOR_P (fun
))
8193 i
= num_artificial_parms_for (fun
);
8194 fun
= DECL_ORIGIN (fun
);
8198 if (potential_constant_expression_1 (fun
, rval
, flags
))
8199 /* Might end up being a constant function pointer. */;
8203 for (; i
< nargs
; ++i
)
8205 tree x
= get_nth_callarg (t
, i
);
8206 if (!potential_constant_expression_1 (x
, rval
, flags
))
8212 case NON_LVALUE_EXPR
:
8213 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
8214 -- an lvalue of integral type that refers to a non-volatile
8215 const variable or static data member initialized with
8216 constant expressions, or
8218 -- an lvalue of literal type that refers to non-volatile
8219 object defined with constexpr, or that refers to a
8220 sub-object of such an object; */
8221 return potential_constant_expression_1 (TREE_OPERAND (t
, 0), rval
, flags
);
8224 if (want_rval
&& !decl_constant_var_p (t
)
8225 && !dependent_type_p (TREE_TYPE (t
)))
8227 if (flags
& tf_error
)
8228 non_const_var_error (t
);
8235 case VIEW_CONVERT_EXPR
:
8236 /* -- a reinterpret_cast. FIXME not implemented, and this rule
8237 may change to something more specific to type-punning (DR 1312). */
8239 tree from
= TREE_OPERAND (t
, 0);
8240 return (potential_constant_expression_1
8241 (from
, TREE_CODE (t
) != VIEW_CONVERT_EXPR
, flags
));
8245 /* -- a unary operator & that is applied to an lvalue that
8246 designates an object with thread or automatic storage
8248 t
= TREE_OPERAND (t
, 0);
8250 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
8251 any checking here, as we might dereference the pointer later. If
8252 we remove this code, also remove check_automatic_or_tls. */
8253 i
= check_automatic_or_tls (t
);
8258 if (flags
& tf_error
)
8259 error ("address-of an object %qE with thread local or "
8260 "automatic storage is not a constant expression", t
);
8264 return potential_constant_expression_1 (t
, any
, flags
);
8270 /* -- a class member access unless its postfix-expression is
8271 of literal type or of pointer to literal type. */
8272 /* This test would be redundant, as it follows from the
8273 postfix-expression being a potential constant expression. */
8274 return potential_constant_expression_1 (TREE_OPERAND (t
, 0),
8277 case EXPR_PACK_EXPANSION
:
8278 return potential_constant_expression_1 (PACK_EXPANSION_PATTERN (t
),
8283 tree x
= TREE_OPERAND (t
, 0);
8285 if (is_this_parameter (x
))
8287 if (want_rval
&& DECL_CONTEXT (x
)
8288 && DECL_CONSTRUCTOR_P (DECL_CONTEXT (x
)))
8290 if (flags
& tf_error
)
8291 sorry ("use of the value of the object being constructed "
8292 "in a constant expression");
8297 return potential_constant_expression_1 (x
, rval
, flags
);
8301 case DYNAMIC_CAST_EXPR
:
8302 case PSEUDO_DTOR_EXPR
:
8303 case PREINCREMENT_EXPR
:
8304 case POSTINCREMENT_EXPR
:
8305 case PREDECREMENT_EXPR
:
8306 case POSTDECREMENT_EXPR
:
8310 case VEC_DELETE_EXPR
:
8314 /* GCC internal stuff. */
8317 case WITH_CLEANUP_EXPR
:
8318 case CLEANUP_POINT_EXPR
:
8319 case MUST_NOT_THROW_EXPR
:
8320 case TRY_CATCH_EXPR
:
8321 case STATEMENT_LIST
:
8322 /* Don't bother trying to define a subset of statement-expressions to
8323 be constant-expressions, at least for now. */
8327 case TRANSACTION_EXPR
:
8332 if (flags
& tf_error
)
8333 error ("expression %qE is not a constant-expression", t
);
8337 /* -- a typeid expression whose operand is of polymorphic
8340 tree e
= TREE_OPERAND (t
, 0);
8341 if (!TYPE_P (e
) && !type_dependent_expression_p (e
)
8342 && TYPE_POLYMORPHIC_P (TREE_TYPE (e
)))
8344 if (flags
& tf_error
)
8345 error ("typeid-expression is not a constant expression "
8346 "because %qE is of polymorphic type", e
);
8353 /* -- a subtraction where both operands are pointers. */
8354 if (TYPE_PTR_P (TREE_OPERAND (t
, 0))
8355 && TYPE_PTR_P (TREE_OPERAND (t
, 1)))
8357 if (flags
& tf_error
)
8358 error ("difference of two pointer expressions is not "
8359 "a constant expression");
8371 /* -- a relational or equality operator where at least
8372 one of the operands is a pointer. */
8373 if (TYPE_PTR_P (TREE_OPERAND (t
, 0))
8374 || TYPE_PTR_P (TREE_OPERAND (t
, 1)))
8376 if (flags
& tf_error
)
8377 error ("pointer comparison expression is not a "
8378 "constant expression");
8386 if (TYPE_P (TREE_OPERAND (t
, 0)))
8388 /* else fall through. */
8394 case FIX_TRUNC_EXPR
:
8398 case TRUTH_NOT_EXPR
:
8399 case FIXED_CONVERT_EXPR
:
8400 case UNARY_PLUS_EXPR
:
8401 return potential_constant_expression_1 (TREE_OPERAND (t
, 0), rval
,
8405 case CONST_CAST_EXPR
:
8406 case STATIC_CAST_EXPR
:
8407 case REINTERPRET_CAST_EXPR
:
8408 case IMPLICIT_CONV_EXPR
:
8409 return (potential_constant_expression_1
8410 (TREE_OPERAND (t
, 0),
8411 TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
, flags
));
8414 case NON_DEPENDENT_EXPR
:
8415 /* For convenience. */
8417 return potential_constant_expression_1 (TREE_OPERAND (t
, 0),
8421 return potential_constant_expression_1 (TREE_OPERAND (t
, 1),
8425 if (!literal_type_p (TREE_TYPE (t
)))
8427 if (flags
& tf_error
)
8429 error ("temporary of non-literal type %qT in a "
8430 "constant expression", TREE_TYPE (t
));
8431 explain_non_literal_class (TREE_TYPE (t
));
8436 return potential_constant_expression_1 (TREE_OPERAND (t
, 1),
8441 VEC(constructor_elt
, gc
) *v
= CONSTRUCTOR_ELTS (t
);
8442 constructor_elt
*ce
;
8443 for (i
= 0; VEC_iterate (constructor_elt
, v
, i
, ce
); ++i
)
8444 if (!potential_constant_expression_1 (ce
->value
, want_rval
, flags
))
8451 gcc_assert (TREE_PURPOSE (t
) == NULL_TREE
8452 || DECL_P (TREE_PURPOSE (t
)));
8453 if (!potential_constant_expression_1 (TREE_VALUE (t
), want_rval
,
8456 if (TREE_CHAIN (t
) == NULL_TREE
)
8458 return potential_constant_expression_1 (TREE_CHAIN (t
), want_rval
,
8462 case TRUNC_DIV_EXPR
:
8464 case FLOOR_DIV_EXPR
:
8465 case ROUND_DIV_EXPR
:
8466 case TRUNC_MOD_EXPR
:
8468 case ROUND_MOD_EXPR
:
8470 tree denom
= TREE_OPERAND (t
, 1);
8471 /* We can't call maybe_constant_value on an expression
8472 that hasn't been through fold_non_dependent_expr yet. */
8473 if (!processing_template_decl
)
8474 denom
= maybe_constant_value (denom
);
8475 if (integer_zerop (denom
))
8477 if (flags
& tf_error
)
8478 error ("division by zero is not a constant-expression");
8490 /* check_return_expr sometimes wraps a TARGET_EXPR in a
8491 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
8492 introduced by build_call_a. */
8493 tree op0
= TREE_OPERAND (t
, 0);
8494 tree op1
= TREE_OPERAND (t
, 1);
8496 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
8497 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
8498 return potential_constant_expression_1 (op0
, want_rval
, flags
);
8503 /* If the first operand is the non-short-circuit constant, look at
8504 the second operand; otherwise we only care about the first one for
8506 case TRUTH_AND_EXPR
:
8507 case TRUTH_ANDIF_EXPR
:
8508 tmp
= boolean_true_node
;
8511 case TRUTH_ORIF_EXPR
:
8512 tmp
= boolean_false_node
;
8514 if (TREE_OPERAND (t
, 0) == tmp
)
8515 return potential_constant_expression_1 (TREE_OPERAND (t
, 1), rval
, flags
);
8517 return potential_constant_expression_1 (TREE_OPERAND (t
, 0), rval
, flags
);
8521 case POINTER_PLUS_EXPR
:
8523 case EXACT_DIV_EXPR
:
8533 case TRUTH_XOR_EXPR
:
8534 case UNORDERED_EXPR
:
8547 case ARRAY_RANGE_REF
:
8551 for (i
= 0; i
< 2; ++i
)
8552 if (!potential_constant_expression_1 (TREE_OPERAND (t
, i
),
8559 for (i
= 0; i
< 3; ++i
)
8560 if (!potential_constant_expression_1 (TREE_OPERAND (t
, i
),
8567 /* If the condition is a known constant, we know which of the legs we
8568 care about; otherwise we only require that the condition and
8569 either of the legs be potentially constant. */
8570 tmp
= TREE_OPERAND (t
, 0);
8571 if (!potential_constant_expression_1 (tmp
, rval
, flags
))
8573 else if (integer_zerop (tmp
))
8574 return potential_constant_expression_1 (TREE_OPERAND (t
, 2),
8576 else if (TREE_CODE (tmp
) == INTEGER_CST
)
8577 return potential_constant_expression_1 (TREE_OPERAND (t
, 1),
8579 for (i
= 1; i
< 3; ++i
)
8580 if (potential_constant_expression_1 (TREE_OPERAND (t
, i
),
8581 want_rval
, tf_none
))
8583 if (flags
& tf_error
)
8584 error ("expression %qE is not a constant-expression", t
);
8588 if (VEC_INIT_EXPR_IS_CONSTEXPR (t
))
8590 if (flags
& tf_error
)
8592 error ("non-constant array initialization");
8593 diagnose_non_constexpr_vec_init (t
);
8598 sorry ("unexpected AST of kind %s", tree_code_name
[TREE_CODE (t
)]);
8604 /* The main entry point to the above. */
8607 potential_constant_expression (tree t
)
8609 return potential_constant_expression_1 (t
, false, tf_none
);
8612 /* As above, but require a constant rvalue. */
8615 potential_rvalue_constant_expression (tree t
)
8617 return potential_constant_expression_1 (t
, true, tf_none
);
8620 /* Like above, but complain about non-constant expressions. */
8623 require_potential_constant_expression (tree t
)
8625 return potential_constant_expression_1 (t
, false, tf_warning_or_error
);
8628 /* Cross product of the above. */
8631 require_potential_rvalue_constant_expression (tree t
)
8633 return potential_constant_expression_1 (t
, true, tf_warning_or_error
);
8636 /* Constructor for a lambda expression. */
8639 build_lambda_expr (void)
8641 tree lambda
= make_node (LAMBDA_EXPR
);
8642 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda
) = CPLD_NONE
;
8643 LAMBDA_EXPR_CAPTURE_LIST (lambda
) = NULL_TREE
;
8644 LAMBDA_EXPR_THIS_CAPTURE (lambda
) = NULL_TREE
;
8645 LAMBDA_EXPR_PENDING_PROXIES (lambda
) = NULL
;
8646 LAMBDA_EXPR_RETURN_TYPE (lambda
) = NULL_TREE
;
8647 LAMBDA_EXPR_MUTABLE_P (lambda
) = false;
8651 /* Create the closure object for a LAMBDA_EXPR. */
8654 build_lambda_object (tree lambda_expr
)
8656 /* Build aggregate constructor call.
8657 - cp_parser_braced_list
8658 - cp_parser_functional_cast */
8659 VEC(constructor_elt
,gc
) *elts
= NULL
;
8660 tree node
, expr
, type
;
8661 location_t saved_loc
;
8663 if (processing_template_decl
)
8666 /* Make sure any error messages refer to the lambda-introducer. */
8667 saved_loc
= input_location
;
8668 input_location
= LAMBDA_EXPR_LOCATION (lambda_expr
);
8670 for (node
= LAMBDA_EXPR_CAPTURE_LIST (lambda_expr
);
8672 node
= TREE_CHAIN (node
))
8674 tree field
= TREE_PURPOSE (node
);
8675 tree val
= TREE_VALUE (node
);
8677 if (field
== error_mark_node
)
8679 expr
= error_mark_node
;
8686 /* Mere mortals can't copy arrays with aggregate initialization, so
8687 do some magic to make it work here. */
8688 if (TREE_CODE (TREE_TYPE (field
)) == ARRAY_TYPE
)
8689 val
= build_array_copy (val
);
8690 else if (DECL_NORMAL_CAPTURE_P (field
)
8691 && TREE_CODE (TREE_TYPE (field
)) != REFERENCE_TYPE
)
8693 /* "the entities that are captured by copy are used to
8694 direct-initialize each corresponding non-static data
8695 member of the resulting closure object."
8697 There's normally no way to express direct-initialization
8698 from an element of a CONSTRUCTOR, so we build up a special
8699 TARGET_EXPR to bypass the usual copy-initialization. */
8700 val
= force_rvalue (val
, tf_warning_or_error
);
8701 if (TREE_CODE (val
) == TARGET_EXPR
)
8702 TARGET_EXPR_DIRECT_INIT_P (val
) = true;
8705 CONSTRUCTOR_APPEND_ELT (elts
, DECL_NAME (field
), val
);
8708 expr
= build_constructor (init_list_type_node
, elts
);
8709 CONSTRUCTOR_IS_DIRECT_INIT (expr
) = 1;
8711 /* N2927: "[The closure] class type is not an aggregate."
8712 But we briefly treat it as an aggregate to make this simpler. */
8713 type
= LAMBDA_EXPR_CLOSURE (lambda_expr
);
8714 CLASSTYPE_NON_AGGREGATE (type
) = 0;
8715 expr
= finish_compound_literal (type
, expr
, tf_warning_or_error
);
8716 CLASSTYPE_NON_AGGREGATE (type
) = 1;
8719 input_location
= saved_loc
;
8723 /* Return an initialized RECORD_TYPE for LAMBDA.
8724 LAMBDA must have its explicit captures already. */
8727 begin_lambda_type (tree lambda
)
8732 /* Unique name. This is just like an unnamed class, but we cannot use
8733 make_anon_name because of certain checks against TYPE_ANONYMOUS_P. */
8735 name
= make_lambda_name ();
8737 /* Create the new RECORD_TYPE for this lambda. */
8738 type
= xref_tag (/*tag_code=*/record_type
,
8740 /*scope=*/ts_within_enclosing_non_class
,
8741 /*template_header_p=*/false);
8744 /* Designate it as a struct so that we can use aggregate initialization. */
8745 CLASSTYPE_DECLARED_CLASS (type
) = false;
8747 /* Clear base types. */
8748 xref_basetypes (type
, /*bases=*/NULL_TREE
);
8750 /* Start the class. */
8751 type
= begin_class_definition (type
);
8752 if (type
== error_mark_node
)
8753 return error_mark_node
;
8755 /* Cross-reference the expression and the type. */
8756 LAMBDA_EXPR_CLOSURE (lambda
) = type
;
8757 CLASSTYPE_LAMBDA_EXPR (type
) = lambda
;
8762 /* Returns the type to use for the return type of the operator() of a
8766 lambda_return_type (tree expr
)
8768 if (expr
== NULL_TREE
)
8769 return void_type_node
;
8770 if (type_unknown_p (expr
)
8771 || BRACE_ENCLOSED_INITIALIZER_P (expr
))
8773 cxx_incomplete_type_error (expr
, TREE_TYPE (expr
));
8774 return void_type_node
;
8776 gcc_checking_assert (!type_dependent_expression_p (expr
));
8777 return cv_unqualified (type_decays_to (unlowered_expr_type (expr
)));
8780 /* Given a LAMBDA_EXPR or closure type LAMBDA, return the op() of the
8784 lambda_function (tree lambda
)
8787 if (TREE_CODE (lambda
) == LAMBDA_EXPR
)
8788 type
= LAMBDA_EXPR_CLOSURE (lambda
);
8791 gcc_assert (LAMBDA_TYPE_P (type
));
8792 /* Don't let debug_tree cause instantiation. */
8793 if (CLASSTYPE_TEMPLATE_INSTANTIATION (type
)
8794 && !COMPLETE_OR_OPEN_TYPE_P (type
))
8796 lambda
= lookup_member (type
, ansi_opname (CALL_EXPR
),
8797 /*protect=*/0, /*want_type=*/false,
8798 tf_warning_or_error
);
8800 lambda
= BASELINK_FUNCTIONS (lambda
);
8804 /* Returns the type to use for the FIELD_DECL corresponding to the
8806 The caller should add REFERENCE_TYPE for capture by reference. */
8809 lambda_capture_field_type (tree expr
)
8812 if (type_dependent_expression_p (expr
))
8814 type
= cxx_make_type (DECLTYPE_TYPE
);
8815 DECLTYPE_TYPE_EXPR (type
) = expr
;
8816 DECLTYPE_FOR_LAMBDA_CAPTURE (type
) = true;
8817 SET_TYPE_STRUCTURAL_EQUALITY (type
);
8820 type
= non_reference (unlowered_expr_type (expr
));
8824 /* Insert the deduced return type for an auto function. */
8827 apply_deduced_return_type (tree fco
, tree return_type
)
8831 if (return_type
== error_mark_node
)
8834 if (LAMBDA_FUNCTION_P (fco
))
8836 tree lambda
= CLASSTYPE_LAMBDA_EXPR (current_class_type
);
8837 LAMBDA_EXPR_RETURN_TYPE (lambda
) = return_type
;
8840 if (DECL_CONV_FN_P (fco
))
8841 DECL_NAME (fco
) = mangle_conv_op_name_for_type (return_type
);
8843 TREE_TYPE (fco
) = change_return_type (return_type
, TREE_TYPE (fco
));
8845 result
= DECL_RESULT (fco
);
8846 if (result
== NULL_TREE
)
8848 if (TREE_TYPE (result
) == return_type
)
8851 /* We already have a DECL_RESULT from start_preparsed_function.
8852 Now we need to redo the work it and allocate_struct_function
8853 did to reflect the new type. */
8854 gcc_assert (current_function_decl
== fco
);
8855 result
= build_decl (input_location
, RESULT_DECL
, NULL_TREE
,
8856 TYPE_MAIN_VARIANT (return_type
));
8857 DECL_ARTIFICIAL (result
) = 1;
8858 DECL_IGNORED_P (result
) = 1;
8859 cp_apply_type_quals_to_decl (cp_type_quals (return_type
),
8862 DECL_RESULT (fco
) = result
;
8864 if (!processing_template_decl
)
8866 bool aggr
= aggregate_value_p (result
, fco
);
8867 #ifdef PCC_STATIC_STRUCT_RETURN
8868 cfun
->returns_pcc_struct
= aggr
;
8870 cfun
->returns_struct
= aggr
;
8875 /* DECL is a local variable or parameter from the surrounding scope of a
8876 lambda-expression. Returns the decltype for a use of the capture field
8877 for DECL even if it hasn't been captured yet. */
8880 capture_decltype (tree decl
)
8882 tree lam
= CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (current_function_decl
));
8883 /* FIXME do lookup instead of list walk? */
8884 tree cap
= value_member (decl
, LAMBDA_EXPR_CAPTURE_LIST (lam
));
8888 type
= TREE_TYPE (TREE_PURPOSE (cap
));
8890 switch (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lam
))
8893 error ("%qD is not captured", decl
);
8894 return error_mark_node
;
8897 type
= TREE_TYPE (decl
);
8898 if (TREE_CODE (type
) == REFERENCE_TYPE
8899 && TREE_CODE (TREE_TYPE (type
)) != FUNCTION_TYPE
)
8900 type
= TREE_TYPE (type
);
8903 case CPLD_REFERENCE
:
8904 type
= TREE_TYPE (decl
);
8905 if (TREE_CODE (type
) != REFERENCE_TYPE
)
8906 type
= build_reference_type (TREE_TYPE (decl
));
8913 if (TREE_CODE (type
) != REFERENCE_TYPE
)
8915 if (!LAMBDA_EXPR_MUTABLE_P (lam
))
8916 type
= cp_build_qualified_type (type
, (cp_type_quals (type
)
8918 type
= build_reference_type (type
);
8923 /* Returns true iff DECL is a lambda capture proxy variable created by
8924 build_capture_proxy. */
8927 is_capture_proxy (tree decl
)
8929 return (TREE_CODE (decl
) == VAR_DECL
8930 && DECL_HAS_VALUE_EXPR_P (decl
)
8931 && !DECL_ANON_UNION_VAR_P (decl
)
8932 && LAMBDA_FUNCTION_P (DECL_CONTEXT (decl
)));
8935 /* Returns true iff DECL is a capture proxy for a normal capture
8936 (i.e. without explicit initializer). */
8939 is_normal_capture_proxy (tree decl
)
8943 if (!is_capture_proxy (decl
))
8944 /* It's not a capture proxy. */
8947 /* It is a capture proxy, is it a normal capture? */
8948 val
= DECL_VALUE_EXPR (decl
);
8949 gcc_assert (TREE_CODE (val
) == COMPONENT_REF
);
8950 val
= TREE_OPERAND (val
, 1);
8951 return DECL_NORMAL_CAPTURE_P (val
);
8954 /* VAR is a capture proxy created by build_capture_proxy; add it to the
8955 current function, which is the operator() for the appropriate lambda. */
8958 insert_capture_proxy (tree var
)
8960 cp_binding_level
*b
;
8964 /* Put the capture proxy in the extra body block so that it won't clash
8965 with a later local variable. */
8966 b
= current_binding_level
;
8967 for (skip
= 0; ; ++skip
)
8969 cp_binding_level
*n
= b
->level_chain
;
8970 if (n
->kind
== sk_function_parms
)
8974 pushdecl_with_scope (var
, b
, false);
8976 /* And put a DECL_EXPR in the STATEMENT_LIST for the same block. */
8977 var
= build_stmt (DECL_SOURCE_LOCATION (var
), DECL_EXPR
, var
);
8978 stmt_list
= VEC_index (tree
, stmt_list_stack
,
8979 VEC_length (tree
, stmt_list_stack
) - 1 - skip
);
8980 gcc_assert (stmt_list
);
8981 append_to_statement_list_force (var
, &stmt_list
);
8984 /* We've just finished processing a lambda; if the containing scope is also
8985 a lambda, insert any capture proxies that were created while processing
8986 the nested lambda. */
8989 insert_pending_capture_proxies (void)
8992 VEC(tree
,gc
) *proxies
;
8995 if (!current_function_decl
|| !LAMBDA_FUNCTION_P (current_function_decl
))
8998 lam
= CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (current_function_decl
));
8999 proxies
= LAMBDA_EXPR_PENDING_PROXIES (lam
);
9000 for (i
= 0; i
< VEC_length (tree
, proxies
); ++i
)
9002 tree var
= VEC_index (tree
, proxies
, i
);
9003 insert_capture_proxy (var
);
9005 release_tree_vector (LAMBDA_EXPR_PENDING_PROXIES (lam
));
9006 LAMBDA_EXPR_PENDING_PROXIES (lam
) = NULL
;
9009 /* Given REF, a COMPONENT_REF designating a field in the lambda closure,
9010 return the type we want the proxy to have: the type of the field itself,
9011 with added const-qualification if the lambda isn't mutable and the
9012 capture is by value. */
9015 lambda_proxy_type (tree ref
)
9018 if (REFERENCE_REF_P (ref
))
9019 ref
= TREE_OPERAND (ref
, 0);
9020 type
= TREE_TYPE (ref
);
9021 if (!dependent_type_p (type
))
9023 type
= cxx_make_type (DECLTYPE_TYPE
);
9024 DECLTYPE_TYPE_EXPR (type
) = ref
;
9025 DECLTYPE_FOR_LAMBDA_PROXY (type
) = true;
9026 SET_TYPE_STRUCTURAL_EQUALITY (type
);
9030 /* MEMBER is a capture field in a lambda closure class. Now that we're
9031 inside the operator(), build a placeholder var for future lookups and
9035 build_capture_proxy (tree member
)
9037 tree var
, object
, fn
, closure
, name
, lam
, type
;
9039 closure
= DECL_CONTEXT (member
);
9040 fn
= lambda_function (closure
);
9041 lam
= CLASSTYPE_LAMBDA_EXPR (closure
);
9043 /* The proxy variable forwards to the capture field. */
9044 object
= build_fold_indirect_ref (DECL_ARGUMENTS (fn
));
9045 object
= finish_non_static_data_member (member
, object
, NULL_TREE
);
9046 if (REFERENCE_REF_P (object
))
9047 object
= TREE_OPERAND (object
, 0);
9049 /* Remove the __ inserted by add_capture. */
9050 name
= get_identifier (IDENTIFIER_POINTER (DECL_NAME (member
)) + 2);
9052 type
= lambda_proxy_type (object
);
9053 var
= build_decl (input_location
, VAR_DECL
, name
, type
);
9054 SET_DECL_VALUE_EXPR (var
, object
);
9055 DECL_HAS_VALUE_EXPR_P (var
) = 1;
9056 DECL_ARTIFICIAL (var
) = 1;
9057 TREE_USED (var
) = 1;
9058 DECL_CONTEXT (var
) = fn
;
9060 if (name
== this_identifier
)
9062 gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (lam
) == member
);
9063 LAMBDA_EXPR_THIS_CAPTURE (lam
) = var
;
9066 if (fn
== current_function_decl
)
9067 insert_capture_proxy (var
);
9069 VEC_safe_push (tree
, gc
, LAMBDA_EXPR_PENDING_PROXIES (lam
), var
);
9074 /* From an ID and INITIALIZER, create a capture (by reference if
9075 BY_REFERENCE_P is true), add it to the capture-list for LAMBDA,
9079 add_capture (tree lambda
, tree id
, tree initializer
, bool by_reference_p
,
9080 bool explicit_init_p
)
9083 tree type
, member
, name
;
9085 type
= lambda_capture_field_type (initializer
);
9088 type
= build_reference_type (type
);
9089 if (!real_lvalue_p (initializer
))
9090 error ("cannot capture %qE by reference", initializer
);
9093 /* Capture by copy requires a complete type. */
9094 type
= complete_type (type
);
9096 /* Add __ to the beginning of the field name so that user code
9097 won't find the field with name lookup. We can't just leave the name
9098 unset because template instantiation uses the name to find
9099 instantiated fields. */
9100 buf
= (char *) alloca (IDENTIFIER_LENGTH (id
) + 3);
9101 buf
[1] = buf
[0] = '_';
9102 memcpy (buf
+ 2, IDENTIFIER_POINTER (id
),
9103 IDENTIFIER_LENGTH (id
) + 1);
9104 name
= get_identifier (buf
);
9106 /* If TREE_TYPE isn't set, we're still in the introducer, so check
9108 if (!LAMBDA_EXPR_CLOSURE (lambda
))
9110 if (IDENTIFIER_MARKED (name
))
9112 pedwarn (input_location
, 0,
9113 "already captured %qD in lambda expression", id
);
9116 IDENTIFIER_MARKED (name
) = true;
9119 /* Make member variable. */
9120 member
= build_lang_decl (FIELD_DECL
, name
, type
);
9122 if (!explicit_init_p
)
9123 /* Normal captures are invisible to name lookup but uses are replaced
9124 with references to the capture field; we implement this by only
9125 really making them invisible in unevaluated context; see
9126 qualify_lookup. For now, let's make explicitly initialized captures
9128 DECL_NORMAL_CAPTURE_P (member
) = true;
9130 if (id
== this_identifier
)
9131 LAMBDA_EXPR_THIS_CAPTURE (lambda
) = member
;
9133 /* Add it to the appropriate closure class if we've started it. */
9134 if (current_class_type
9135 && current_class_type
== LAMBDA_EXPR_CLOSURE (lambda
))
9136 finish_member_declaration (member
);
9138 LAMBDA_EXPR_CAPTURE_LIST (lambda
)
9139 = tree_cons (member
, initializer
, LAMBDA_EXPR_CAPTURE_LIST (lambda
));
9141 if (LAMBDA_EXPR_CLOSURE (lambda
))
9142 return build_capture_proxy (member
);
9143 /* For explicit captures we haven't started the function yet, so we wait
9144 and build the proxy from cp_parser_lambda_body. */
9148 /* Register all the capture members on the list CAPTURES, which is the
9149 LAMBDA_EXPR_CAPTURE_LIST for the lambda after the introducer. */
9152 register_capture_members (tree captures
)
9154 if (captures
== NULL_TREE
)
9157 register_capture_members (TREE_CHAIN (captures
));
9158 /* We set this in add_capture to avoid duplicates. */
9159 IDENTIFIER_MARKED (DECL_NAME (TREE_PURPOSE (captures
))) = false;
9160 finish_member_declaration (TREE_PURPOSE (captures
));
9163 /* Similar to add_capture, except this works on a stack of nested lambdas.
9164 BY_REFERENCE_P in this case is derived from the default capture mode.
9165 Returns the capture for the lambda at the bottom of the stack. */
9168 add_default_capture (tree lambda_stack
, tree id
, tree initializer
)
9170 bool this_capture_p
= (id
== this_identifier
);
9172 tree var
= NULL_TREE
;
9174 tree saved_class_type
= current_class_type
;
9178 for (node
= lambda_stack
;
9180 node
= TREE_CHAIN (node
))
9182 tree lambda
= TREE_VALUE (node
);
9184 current_class_type
= LAMBDA_EXPR_CLOSURE (lambda
);
9185 var
= add_capture (lambda
,
9190 && (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda
)
9191 == CPLD_REFERENCE
)),
9192 /*explicit_init_p=*/false);
9193 initializer
= convert_from_reference (var
);
9196 current_class_type
= saved_class_type
;
9201 /* Return the capture pertaining to a use of 'this' in LAMBDA, in the form of an
9202 INDIRECT_REF, possibly adding it through default capturing. */
9205 lambda_expr_this_capture (tree lambda
)
9209 tree this_capture
= LAMBDA_EXPR_THIS_CAPTURE (lambda
);
9211 /* Try to default capture 'this' if we can. */
9213 && LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda
) != CPLD_NONE
)
9215 tree containing_function
= TYPE_CONTEXT (LAMBDA_EXPR_CLOSURE (lambda
));
9216 tree lambda_stack
= tree_cons (NULL_TREE
, lambda
, NULL_TREE
);
9217 tree init
= NULL_TREE
;
9219 /* If we are in a lambda function, we can move out until we hit:
9220 1. a non-lambda function,
9221 2. a lambda function capturing 'this', or
9222 3. a non-default capturing lambda function. */
9223 while (LAMBDA_FUNCTION_P (containing_function
))
9226 = CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (containing_function
));
9228 if (LAMBDA_EXPR_THIS_CAPTURE (lambda
))
9230 /* An outer lambda has already captured 'this'. */
9231 init
= LAMBDA_EXPR_THIS_CAPTURE (lambda
);
9235 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda
) == CPLD_NONE
)
9236 /* An outer lambda won't let us capture 'this'. */
9239 lambda_stack
= tree_cons (NULL_TREE
,
9243 containing_function
= decl_function_context (containing_function
);
9246 if (!init
&& DECL_NONSTATIC_MEMBER_FUNCTION_P (containing_function
)
9247 && !LAMBDA_FUNCTION_P (containing_function
))
9248 /* First parameter is 'this'. */
9249 init
= DECL_ARGUMENTS (containing_function
);
9252 this_capture
= add_default_capture (lambda_stack
,
9253 /*id=*/this_identifier
,
9259 error ("%<this%> was not captured for this lambda function");
9260 result
= error_mark_node
;
9264 /* To make sure that current_class_ref is for the lambda. */
9265 gcc_assert (TYPE_MAIN_VARIANT (TREE_TYPE (current_class_ref
))
9266 == LAMBDA_EXPR_CLOSURE (lambda
));
9268 result
= this_capture
;
9270 /* If 'this' is captured, each use of 'this' is transformed into an
9271 access to the corresponding unnamed data member of the closure
9272 type cast (_expr.cast_ 5.4) to the type of 'this'. [ The cast
9273 ensures that the transformed expression is an rvalue. ] */
9274 result
= rvalue (result
);
9280 /* Returns the method basetype of the innermost non-lambda function, or
9281 NULL_TREE if none. */
9284 nonlambda_method_basetype (void)
9287 if (!current_class_ref
)
9290 type
= current_class_type
;
9291 if (!LAMBDA_TYPE_P (type
))
9294 /* Find the nearest enclosing non-lambda function. */
9295 fn
= TYPE_NAME (type
);
9297 fn
= decl_function_context (fn
);
9298 while (fn
&& LAMBDA_FUNCTION_P (fn
));
9300 if (!fn
|| !DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
9303 return TYPE_METHOD_BASETYPE (TREE_TYPE (fn
));
9306 /* If the closure TYPE has a static op(), also add a conversion to function
9310 maybe_add_lambda_conv_op (tree type
)
9312 bool nested
= (current_function_decl
!= NULL_TREE
);
9313 tree callop
= lambda_function (type
);
9314 tree rettype
, name
, fntype
, fn
, body
, compound_stmt
;
9315 tree thistype
, stattype
, statfn
, convfn
, call
, arg
;
9316 VEC (tree
, gc
) *argvec
;
9318 if (LAMBDA_EXPR_CAPTURE_LIST (CLASSTYPE_LAMBDA_EXPR (type
)) != NULL_TREE
)
9321 if (processing_template_decl
)
9324 stattype
= build_function_type (TREE_TYPE (TREE_TYPE (callop
)),
9325 FUNCTION_ARG_CHAIN (callop
));
9327 /* First build up the conversion op. */
9329 rettype
= build_pointer_type (stattype
);
9330 name
= mangle_conv_op_name_for_type (rettype
);
9331 thistype
= cp_build_qualified_type (type
, TYPE_QUAL_CONST
);
9332 fntype
= build_method_type_directly (thistype
, rettype
, void_list_node
);
9333 fn
= convfn
= build_lang_decl (FUNCTION_DECL
, name
, fntype
);
9334 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (callop
);
9336 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
9337 && DECL_ALIGN (fn
) < 2 * BITS_PER_UNIT
)
9338 DECL_ALIGN (fn
) = 2 * BITS_PER_UNIT
;
9340 SET_OVERLOADED_OPERATOR_CODE (fn
, TYPE_EXPR
);
9341 grokclassfn (type
, fn
, NO_SPECIAL
);
9342 set_linkage_according_to_type (type
, fn
);
9343 rest_of_decl_compilation (fn
, toplevel_bindings_p (), at_eof
);
9344 DECL_IN_AGGR_P (fn
) = 1;
9345 DECL_ARTIFICIAL (fn
) = 1;
9346 DECL_NOT_REALLY_EXTERN (fn
) = 1;
9347 DECL_DECLARED_INLINE_P (fn
) = 1;
9348 DECL_ARGUMENTS (fn
) = build_this_parm (fntype
, TYPE_QUAL_CONST
);
9350 add_method (type
, fn
, NULL_TREE
);
9352 /* Generic thunk code fails for varargs; we'll complain in mark_used if
9353 the conversion op is used. */
9354 if (varargs_function_p (callop
))
9356 DECL_DELETED_FN (fn
) = 1;
9360 /* Now build up the thunk to be returned. */
9362 name
= get_identifier ("_FUN");
9363 fn
= statfn
= build_lang_decl (FUNCTION_DECL
, name
, stattype
);
9364 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (callop
);
9365 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
9366 && DECL_ALIGN (fn
) < 2 * BITS_PER_UNIT
)
9367 DECL_ALIGN (fn
) = 2 * BITS_PER_UNIT
;
9368 grokclassfn (type
, fn
, NO_SPECIAL
);
9369 set_linkage_according_to_type (type
, fn
);
9370 rest_of_decl_compilation (fn
, toplevel_bindings_p (), at_eof
);
9371 DECL_IN_AGGR_P (fn
) = 1;
9372 DECL_ARTIFICIAL (fn
) = 1;
9373 DECL_NOT_REALLY_EXTERN (fn
) = 1;
9374 DECL_DECLARED_INLINE_P (fn
) = 1;
9375 DECL_STATIC_FUNCTION_P (fn
) = 1;
9376 DECL_ARGUMENTS (fn
) = copy_list (DECL_CHAIN (DECL_ARGUMENTS (callop
)));
9377 for (arg
= DECL_ARGUMENTS (fn
); arg
; arg
= DECL_CHAIN (arg
))
9378 DECL_CONTEXT (arg
) = fn
;
9380 add_method (type
, fn
, NULL_TREE
);
9383 push_function_context ();
9385 /* Still increment function_depth so that we don't GC in the
9386 middle of an expression. */
9389 /* Generate the body of the thunk. */
9391 start_preparsed_function (statfn
, NULL_TREE
,
9392 SF_PRE_PARSED
| SF_INCLASS_INLINE
);
9393 if (DECL_ONE_ONLY (statfn
))
9395 /* Put the thunk in the same comdat group as the call op. */
9396 symtab_add_to_same_comdat_group
9397 ((symtab_node
) cgraph_get_create_node (statfn
),
9398 (symtab_node
) cgraph_get_create_node (callop
));
9400 body
= begin_function_body ();
9401 compound_stmt
= begin_compound_stmt (0);
9403 arg
= build1 (NOP_EXPR
, TREE_TYPE (DECL_ARGUMENTS (callop
)),
9405 argvec
= make_tree_vector ();
9406 VEC_quick_push (tree
, argvec
, arg
);
9407 for (arg
= DECL_ARGUMENTS (statfn
); arg
; arg
= DECL_CHAIN (arg
))
9409 mark_exp_read (arg
);
9410 VEC_safe_push (tree
, gc
, argvec
, arg
);
9412 call
= build_call_a (callop
, VEC_length (tree
, argvec
),
9413 VEC_address (tree
, argvec
));
9414 CALL_FROM_THUNK_P (call
) = 1;
9415 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (call
)))
9416 call
= build_cplus_new (TREE_TYPE (call
), call
, tf_warning_or_error
);
9417 call
= convert_from_reference (call
);
9418 finish_return_stmt (call
);
9420 finish_compound_stmt (compound_stmt
);
9421 finish_function_body (body
);
9423 expand_or_defer_fn (finish_function (2));
9425 /* Generate the body of the conversion op. */
9427 start_preparsed_function (convfn
, NULL_TREE
,
9428 SF_PRE_PARSED
| SF_INCLASS_INLINE
);
9429 body
= begin_function_body ();
9430 compound_stmt
= begin_compound_stmt (0);
9432 finish_return_stmt (decay_conversion (statfn
, tf_warning_or_error
));
9434 finish_compound_stmt (compound_stmt
);
9435 finish_function_body (body
);
9437 expand_or_defer_fn (finish_function (2));
9440 pop_function_context ();
9445 /* Returns true iff VAL is a lambda-related declaration which should
9446 be ignored by unqualified lookup. */
9449 is_lambda_ignored_entity (tree val
)
9451 /* In unevaluated context, look past normal capture proxies. */
9452 if (cp_unevaluated_operand
&& is_normal_capture_proxy (val
))
9455 /* Always ignore lambda fields, their names are only for debugging. */
9456 if (TREE_CODE (val
) == FIELD_DECL
9457 && CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (val
)))
9460 /* None of the lookups that use qualify_lookup want the op() from the
9461 lambda; they want the one from the enclosing class. */
9462 if (TREE_CODE (val
) == FUNCTION_DECL
&& LAMBDA_FUNCTION_P (val
))
9468 #include "gt-cp-semantics.h"