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
;
266 FOR_EACH_VEC_ELT (deferred_access_check
, checks
, i
, chk
)
267 enforce_access (chk
->binfo
, chk
->decl
, chk
->diag_decl
);
270 /* Perform the deferred access checks.
272 After performing the checks, we still have to keep the list
273 `deferred_access_stack->deferred_access_checks' since we may want
274 to check access for them again later in a different context.
281 A::X A::a, x; // No error for `A::a', error for `x'
283 We have to perform deferred access of `A::X', first with `A::a',
287 perform_deferred_access_checks (void)
289 perform_access_checks (get_deferred_access_checks ());
292 /* Defer checking the accessibility of DECL, when looked up in
293 BINFO. DIAG_DECL is the declaration to use to print diagnostics. */
296 perform_or_defer_access_check (tree binfo
, tree decl
, tree diag_decl
)
299 deferred_access
*ptr
;
300 deferred_access_check
*chk
;
301 deferred_access_check
*new_access
;
304 /* Exit if we are in a context that no access checking is performed.
306 if (deferred_access_no_check
)
309 gcc_assert (TREE_CODE (binfo
) == TREE_BINFO
);
311 ptr
= VEC_last (deferred_access
, deferred_access_stack
);
313 /* If we are not supposed to defer access checks, just check now. */
314 if (ptr
->deferring_access_checks_kind
== dk_no_deferred
)
316 enforce_access (binfo
, decl
, diag_decl
);
320 /* See if we are already going to perform this check. */
321 FOR_EACH_VEC_ELT (deferred_access_check
,
322 ptr
->deferred_access_checks
, i
, chk
)
324 if (chk
->decl
== decl
&& chk
->binfo
== binfo
&&
325 chk
->diag_decl
== diag_decl
)
330 /* If not, record the check. */
332 VEC_safe_push (deferred_access_check
, gc
,
333 ptr
->deferred_access_checks
, 0);
334 new_access
->binfo
= binfo
;
335 new_access
->decl
= decl
;
336 new_access
->diag_decl
= diag_decl
;
339 /* Used by build_over_call in LOOKUP_SPECULATIVE mode: return whether DECL
340 is accessible in BINFO, and possibly complain if not. If we're not
341 checking access, everything is accessible. */
344 speculative_access_check (tree binfo
, tree decl
, tree diag_decl
,
347 if (deferred_access_no_check
)
350 /* If we're checking for implicit delete, we don't want access
352 if (!accessible_p (binfo
, decl
, true))
354 /* Unless we're under maybe_explain_implicit_delete. */
356 enforce_access (binfo
, decl
, diag_decl
);
363 /* Returns nonzero if the current statement is a full expression,
364 i.e. temporaries created during that statement should be destroyed
365 at the end of the statement. */
368 stmts_are_full_exprs_p (void)
370 return current_stmt_tree ()->stmts_are_full_exprs_p
;
373 /* T is a statement. Add it to the statement-tree. This is the C++
374 version. The C/ObjC frontends have a slightly different version of
380 enum tree_code code
= TREE_CODE (t
);
382 if (EXPR_P (t
) && code
!= LABEL_EXPR
)
384 if (!EXPR_HAS_LOCATION (t
))
385 SET_EXPR_LOCATION (t
, input_location
);
387 /* When we expand a statement-tree, we must know whether or not the
388 statements are full-expressions. We record that fact here. */
389 STMT_IS_FULL_EXPR_P (t
) = stmts_are_full_exprs_p ();
392 /* Add T to the statement-tree. Non-side-effect statements need to be
393 recorded during statement expressions. */
394 gcc_checking_assert (!VEC_empty (tree
, stmt_list_stack
));
395 append_to_statement_list_force (t
, &cur_stmt_list
);
400 /* Returns the stmt_tree to which statements are currently being added. */
403 current_stmt_tree (void)
406 ? &cfun
->language
->base
.x_stmt_tree
407 : &scope_chain
->x_stmt_tree
);
410 /* If statements are full expressions, wrap STMT in a CLEANUP_POINT_EXPR. */
413 maybe_cleanup_point_expr (tree expr
)
415 if (!processing_template_decl
&& stmts_are_full_exprs_p ())
416 expr
= fold_build_cleanup_point_expr (TREE_TYPE (expr
), expr
);
420 /* Like maybe_cleanup_point_expr except have the type of the new expression be
421 void so we don't need to create a temporary variable to hold the inner
422 expression. The reason why we do this is because the original type might be
423 an aggregate and we cannot create a temporary variable for that type. */
426 maybe_cleanup_point_expr_void (tree expr
)
428 if (!processing_template_decl
&& stmts_are_full_exprs_p ())
429 expr
= fold_build_cleanup_point_expr (void_type_node
, expr
);
435 /* Create a declaration statement for the declaration given by the DECL. */
438 add_decl_expr (tree decl
)
440 tree r
= build_stmt (input_location
, DECL_EXPR
, decl
);
441 if (DECL_INITIAL (decl
)
442 || (DECL_SIZE (decl
) && TREE_SIDE_EFFECTS (DECL_SIZE (decl
))))
443 r
= maybe_cleanup_point_expr_void (r
);
447 /* Finish a scope. */
450 do_poplevel (tree stmt_list
)
454 if (stmts_are_full_exprs_p ())
455 block
= poplevel (kept_level_p (), 1, 0);
457 stmt_list
= pop_stmt_list (stmt_list
);
459 if (!processing_template_decl
)
461 stmt_list
= c_build_bind_expr (input_location
, block
, stmt_list
);
462 /* ??? See c_end_compound_stmt re statement expressions. */
468 /* Begin a new scope. */
471 do_pushlevel (scope_kind sk
)
473 tree ret
= push_stmt_list ();
474 if (stmts_are_full_exprs_p ())
475 begin_scope (sk
, NULL
);
479 /* Queue a cleanup. CLEANUP is an expression/statement to be executed
480 when the current scope is exited. EH_ONLY is true when this is not
481 meant to apply to normal control flow transfer. */
484 push_cleanup (tree decl
, tree cleanup
, bool eh_only
)
486 tree stmt
= build_stmt (input_location
, CLEANUP_STMT
, NULL
, cleanup
, decl
);
487 CLEANUP_EH_ONLY (stmt
) = eh_only
;
489 CLEANUP_BODY (stmt
) = push_stmt_list ();
492 /* Begin a conditional that might contain a declaration. When generating
493 normal code, we want the declaration to appear before the statement
494 containing the conditional. When generating template code, we want the
495 conditional to be rendered as the raw DECL_EXPR. */
498 begin_cond (tree
*cond_p
)
500 if (processing_template_decl
)
501 *cond_p
= push_stmt_list ();
504 /* Finish such a conditional. */
507 finish_cond (tree
*cond_p
, tree expr
)
509 if (processing_template_decl
)
511 tree cond
= pop_stmt_list (*cond_p
);
513 if (expr
== NULL_TREE
)
514 /* Empty condition in 'for'. */
515 gcc_assert (empty_expr_stmt_p (cond
));
516 else if (check_for_bare_parameter_packs (expr
))
517 expr
= error_mark_node
;
518 else if (!empty_expr_stmt_p (cond
))
519 expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (expr
), cond
, expr
);
524 /* If *COND_P specifies a conditional with a declaration, transform the
527 for (; A x = 42;) { }
529 while (true) { A x = 42; if (!x) break; }
530 for (;;) { A x = 42; if (!x) break; }
531 The statement list for BODY will be empty if the conditional did
532 not declare anything. */
535 simplify_loop_decl_cond (tree
*cond_p
, tree body
)
539 if (!TREE_SIDE_EFFECTS (body
))
543 *cond_p
= boolean_true_node
;
545 if_stmt
= begin_if_stmt ();
546 cond
= cp_build_unary_op (TRUTH_NOT_EXPR
, cond
, 0, tf_warning_or_error
);
547 finish_if_stmt_cond (cond
, if_stmt
);
548 finish_break_stmt ();
549 finish_then_clause (if_stmt
);
550 finish_if_stmt (if_stmt
);
553 /* Finish a goto-statement. */
556 finish_goto_stmt (tree destination
)
558 if (TREE_CODE (destination
) == IDENTIFIER_NODE
)
559 destination
= lookup_label (destination
);
561 /* We warn about unused labels with -Wunused. That means we have to
562 mark the used labels as used. */
563 if (TREE_CODE (destination
) == LABEL_DECL
)
564 TREE_USED (destination
) = 1;
567 destination
= mark_rvalue_use (destination
);
568 if (!processing_template_decl
)
570 destination
= cp_convert (ptr_type_node
, destination
,
571 tf_warning_or_error
);
572 if (error_operand_p (destination
))
577 check_goto (destination
);
579 return add_stmt (build_stmt (input_location
, GOTO_EXPR
, destination
));
582 /* COND is the condition-expression for an if, while, etc.,
583 statement. Convert it to a boolean value, if appropriate.
584 In addition, verify sequence points if -Wsequence-point is enabled. */
587 maybe_convert_cond (tree cond
)
589 /* Empty conditions remain empty. */
593 /* Wait until we instantiate templates before doing conversion. */
594 if (processing_template_decl
)
597 if (warn_sequence_point
)
598 verify_sequence_points (cond
);
600 /* Do the conversion. */
601 cond
= convert_from_reference (cond
);
603 if (TREE_CODE (cond
) == MODIFY_EXPR
604 && !TREE_NO_WARNING (cond
)
607 warning (OPT_Wparentheses
,
608 "suggest parentheses around assignment used as truth value");
609 TREE_NO_WARNING (cond
) = 1;
612 return condition_conversion (cond
);
615 /* Finish an expression-statement, whose EXPRESSION is as indicated. */
618 finish_expr_stmt (tree expr
)
622 if (expr
!= NULL_TREE
)
624 if (!processing_template_decl
)
626 if (warn_sequence_point
)
627 verify_sequence_points (expr
);
628 expr
= convert_to_void (expr
, ICV_STATEMENT
, tf_warning_or_error
);
630 else if (!type_dependent_expression_p (expr
))
631 convert_to_void (build_non_dependent_expr (expr
), ICV_STATEMENT
,
632 tf_warning_or_error
);
634 if (check_for_bare_parameter_packs (expr
))
635 expr
= error_mark_node
;
637 /* Simplification of inner statement expressions, compound exprs,
638 etc can result in us already having an EXPR_STMT. */
639 if (TREE_CODE (expr
) != CLEANUP_POINT_EXPR
)
641 if (TREE_CODE (expr
) != EXPR_STMT
)
642 expr
= build_stmt (input_location
, EXPR_STMT
, expr
);
643 expr
= maybe_cleanup_point_expr_void (expr
);
655 /* Begin an if-statement. Returns a newly created IF_STMT if
662 scope
= do_pushlevel (sk_cond
);
663 r
= build_stmt (input_location
, IF_STMT
, NULL_TREE
,
664 NULL_TREE
, NULL_TREE
, scope
);
665 begin_cond (&IF_COND (r
));
669 /* Process the COND of an if-statement, which may be given by
673 finish_if_stmt_cond (tree cond
, tree if_stmt
)
675 finish_cond (&IF_COND (if_stmt
), maybe_convert_cond (cond
));
677 THEN_CLAUSE (if_stmt
) = push_stmt_list ();
680 /* Finish the then-clause of an if-statement, which may be given by
684 finish_then_clause (tree if_stmt
)
686 THEN_CLAUSE (if_stmt
) = pop_stmt_list (THEN_CLAUSE (if_stmt
));
690 /* Begin the else-clause of an if-statement. */
693 begin_else_clause (tree if_stmt
)
695 ELSE_CLAUSE (if_stmt
) = push_stmt_list ();
698 /* Finish the else-clause of an if-statement, which may be given by
702 finish_else_clause (tree if_stmt
)
704 ELSE_CLAUSE (if_stmt
) = pop_stmt_list (ELSE_CLAUSE (if_stmt
));
707 /* Finish an if-statement. */
710 finish_if_stmt (tree if_stmt
)
712 tree scope
= IF_SCOPE (if_stmt
);
713 IF_SCOPE (if_stmt
) = NULL
;
714 add_stmt (do_poplevel (scope
));
718 /* Begin a while-statement. Returns a newly created WHILE_STMT if
722 begin_while_stmt (void)
725 r
= build_stmt (input_location
, WHILE_STMT
, NULL_TREE
, NULL_TREE
);
727 WHILE_BODY (r
) = do_pushlevel (sk_block
);
728 begin_cond (&WHILE_COND (r
));
732 /* Process the COND of a while-statement, which may be given by
736 finish_while_stmt_cond (tree cond
, tree while_stmt
)
738 finish_cond (&WHILE_COND (while_stmt
), maybe_convert_cond (cond
));
739 simplify_loop_decl_cond (&WHILE_COND (while_stmt
), WHILE_BODY (while_stmt
));
742 /* Finish a while-statement, which may be given by WHILE_STMT. */
745 finish_while_stmt (tree while_stmt
)
747 WHILE_BODY (while_stmt
) = do_poplevel (WHILE_BODY (while_stmt
));
751 /* Begin a do-statement. Returns a newly created DO_STMT if
757 tree r
= build_stmt (input_location
, DO_STMT
, NULL_TREE
, NULL_TREE
);
759 DO_BODY (r
) = push_stmt_list ();
763 /* Finish the body of a do-statement, which may be given by DO_STMT. */
766 finish_do_body (tree do_stmt
)
768 tree body
= DO_BODY (do_stmt
) = pop_stmt_list (DO_BODY (do_stmt
));
770 if (TREE_CODE (body
) == STATEMENT_LIST
&& STATEMENT_LIST_TAIL (body
))
771 body
= STATEMENT_LIST_TAIL (body
)->stmt
;
773 if (IS_EMPTY_STMT (body
))
774 warning (OPT_Wempty_body
,
775 "suggest explicit braces around empty body in %<do%> statement");
778 /* Finish a do-statement, which may be given by DO_STMT, and whose
779 COND is as indicated. */
782 finish_do_stmt (tree cond
, tree do_stmt
)
784 cond
= maybe_convert_cond (cond
);
785 DO_COND (do_stmt
) = cond
;
789 /* Finish a return-statement. The EXPRESSION returned, if any, is as
793 finish_return_stmt (tree expr
)
798 expr
= check_return_expr (expr
, &no_warning
);
800 if (flag_openmp
&& !check_omp_return ())
801 return error_mark_node
;
802 if (!processing_template_decl
)
804 if (warn_sequence_point
)
805 verify_sequence_points (expr
);
807 if (DECL_DESTRUCTOR_P (current_function_decl
)
808 || (DECL_CONSTRUCTOR_P (current_function_decl
)
809 && targetm
.cxx
.cdtor_returns_this ()))
811 /* Similarly, all destructors must run destructors for
812 base-classes before returning. So, all returns in a
813 destructor get sent to the DTOR_LABEL; finish_function emits
814 code to return a value there. */
815 return finish_goto_stmt (cdtor_label
);
819 r
= build_stmt (input_location
, RETURN_EXPR
, expr
);
820 TREE_NO_WARNING (r
) |= no_warning
;
821 r
= maybe_cleanup_point_expr_void (r
);
828 /* Begin the scope of a for-statement or a range-for-statement.
829 Both the returned trees are to be used in a call to
830 begin_for_stmt or begin_range_for_stmt. */
833 begin_for_scope (tree
*init
)
835 tree scope
= NULL_TREE
;
836 if (flag_new_for_scope
> 0)
837 scope
= do_pushlevel (sk_for
);
839 if (processing_template_decl
)
840 *init
= push_stmt_list ();
847 /* Begin a for-statement. Returns a new FOR_STMT.
848 SCOPE and INIT should be the return of begin_for_scope,
852 begin_for_stmt (tree scope
, tree init
)
856 r
= build_stmt (input_location
, FOR_STMT
, NULL_TREE
, NULL_TREE
,
857 NULL_TREE
, NULL_TREE
, NULL_TREE
);
859 if (scope
== NULL_TREE
)
861 gcc_assert (!init
|| !(flag_new_for_scope
> 0));
863 scope
= begin_for_scope (&init
);
865 FOR_INIT_STMT (r
) = init
;
866 FOR_SCOPE (r
) = scope
;
871 /* Finish the for-init-statement of a for-statement, which may be
872 given by FOR_STMT. */
875 finish_for_init_stmt (tree for_stmt
)
877 if (processing_template_decl
)
878 FOR_INIT_STMT (for_stmt
) = pop_stmt_list (FOR_INIT_STMT (for_stmt
));
880 FOR_BODY (for_stmt
) = do_pushlevel (sk_block
);
881 begin_cond (&FOR_COND (for_stmt
));
884 /* Finish the COND of a for-statement, which may be given by
888 finish_for_cond (tree cond
, tree for_stmt
)
890 finish_cond (&FOR_COND (for_stmt
), maybe_convert_cond (cond
));
891 simplify_loop_decl_cond (&FOR_COND (for_stmt
), FOR_BODY (for_stmt
));
894 /* Finish the increment-EXPRESSION in a for-statement, which may be
895 given by FOR_STMT. */
898 finish_for_expr (tree expr
, tree for_stmt
)
902 /* If EXPR is an overloaded function, issue an error; there is no
903 context available to use to perform overload resolution. */
904 if (type_unknown_p (expr
))
906 cxx_incomplete_type_error (expr
, TREE_TYPE (expr
));
907 expr
= error_mark_node
;
909 if (!processing_template_decl
)
911 if (warn_sequence_point
)
912 verify_sequence_points (expr
);
913 expr
= convert_to_void (expr
, ICV_THIRD_IN_FOR
,
914 tf_warning_or_error
);
916 else if (!type_dependent_expression_p (expr
))
917 convert_to_void (build_non_dependent_expr (expr
), ICV_THIRD_IN_FOR
,
918 tf_warning_or_error
);
919 expr
= maybe_cleanup_point_expr_void (expr
);
920 if (check_for_bare_parameter_packs (expr
))
921 expr
= error_mark_node
;
922 FOR_EXPR (for_stmt
) = expr
;
925 /* Finish the body of a for-statement, which may be given by
926 FOR_STMT. The increment-EXPR for the loop must be
928 It can also finish RANGE_FOR_STMT. */
931 finish_for_stmt (tree for_stmt
)
933 if (TREE_CODE (for_stmt
) == RANGE_FOR_STMT
)
934 RANGE_FOR_BODY (for_stmt
) = do_poplevel (RANGE_FOR_BODY (for_stmt
));
936 FOR_BODY (for_stmt
) = do_poplevel (FOR_BODY (for_stmt
));
938 /* Pop the scope for the body of the loop. */
939 if (flag_new_for_scope
> 0)
942 tree
*scope_ptr
= (TREE_CODE (for_stmt
) == RANGE_FOR_STMT
943 ? &RANGE_FOR_SCOPE (for_stmt
)
944 : &FOR_SCOPE (for_stmt
));
947 add_stmt (do_poplevel (scope
));
953 /* Begin a range-for-statement. Returns a new RANGE_FOR_STMT.
954 SCOPE and INIT should be the return of begin_for_scope,
956 To finish it call finish_for_stmt(). */
959 begin_range_for_stmt (tree scope
, tree init
)
963 r
= build_stmt (input_location
, RANGE_FOR_STMT
,
964 NULL_TREE
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
966 if (scope
== NULL_TREE
)
968 gcc_assert (!init
|| !(flag_new_for_scope
> 0));
970 scope
= begin_for_scope (&init
);
973 /* RANGE_FOR_STMTs do not use nor save the init tree, so we
976 pop_stmt_list (init
);
977 RANGE_FOR_SCOPE (r
) = scope
;
982 /* Finish the head of a range-based for statement, which may
983 be given by RANGE_FOR_STMT. DECL must be the declaration
984 and EXPR must be the loop expression. */
987 finish_range_for_decl (tree range_for_stmt
, tree decl
, tree expr
)
989 RANGE_FOR_DECL (range_for_stmt
) = decl
;
990 RANGE_FOR_EXPR (range_for_stmt
) = expr
;
991 add_stmt (range_for_stmt
);
992 RANGE_FOR_BODY (range_for_stmt
) = do_pushlevel (sk_block
);
995 /* Finish a break-statement. */
998 finish_break_stmt (void)
1000 /* In switch statements break is sometimes stylistically used after
1001 a return statement. This can lead to spurious warnings about
1002 control reaching the end of a non-void function when it is
1003 inlined. Note that we are calling block_may_fallthru with
1004 language specific tree nodes; this works because
1005 block_may_fallthru returns true when given something it does not
1007 if (!block_may_fallthru (cur_stmt_list
))
1008 return void_zero_node
;
1009 return add_stmt (build_stmt (input_location
, BREAK_STMT
));
1012 /* Finish a continue-statement. */
1015 finish_continue_stmt (void)
1017 return add_stmt (build_stmt (input_location
, CONTINUE_STMT
));
1020 /* Begin a switch-statement. Returns a new SWITCH_STMT if
1024 begin_switch_stmt (void)
1028 scope
= do_pushlevel (sk_cond
);
1029 r
= build_stmt (input_location
, SWITCH_STMT
, NULL_TREE
, NULL_TREE
, NULL_TREE
, scope
);
1031 begin_cond (&SWITCH_STMT_COND (r
));
1036 /* Finish the cond of a switch-statement. */
1039 finish_switch_cond (tree cond
, tree switch_stmt
)
1041 tree orig_type
= NULL
;
1042 if (!processing_template_decl
)
1044 /* Convert the condition to an integer or enumeration type. */
1045 cond
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
, cond
, true);
1046 if (cond
== NULL_TREE
)
1048 error ("switch quantity not an integer");
1049 cond
= error_mark_node
;
1051 orig_type
= TREE_TYPE (cond
);
1052 if (cond
!= error_mark_node
)
1056 Integral promotions are performed. */
1057 cond
= perform_integral_promotions (cond
);
1058 cond
= maybe_cleanup_point_expr (cond
);
1061 if (check_for_bare_parameter_packs (cond
))
1062 cond
= error_mark_node
;
1063 else if (!processing_template_decl
&& warn_sequence_point
)
1064 verify_sequence_points (cond
);
1066 finish_cond (&SWITCH_STMT_COND (switch_stmt
), cond
);
1067 SWITCH_STMT_TYPE (switch_stmt
) = orig_type
;
1068 add_stmt (switch_stmt
);
1069 push_switch (switch_stmt
);
1070 SWITCH_STMT_BODY (switch_stmt
) = push_stmt_list ();
1073 /* Finish the body of a switch-statement, which may be given by
1074 SWITCH_STMT. The COND to switch on is indicated. */
1077 finish_switch_stmt (tree switch_stmt
)
1081 SWITCH_STMT_BODY (switch_stmt
) =
1082 pop_stmt_list (SWITCH_STMT_BODY (switch_stmt
));
1086 scope
= SWITCH_STMT_SCOPE (switch_stmt
);
1087 SWITCH_STMT_SCOPE (switch_stmt
) = NULL
;
1088 add_stmt (do_poplevel (scope
));
1091 /* Begin a try-block. Returns a newly-created TRY_BLOCK if
1095 begin_try_block (void)
1097 tree r
= build_stmt (input_location
, TRY_BLOCK
, NULL_TREE
, NULL_TREE
);
1099 TRY_STMTS (r
) = push_stmt_list ();
1103 /* Likewise, for a function-try-block. The block returned in
1104 *COMPOUND_STMT is an artificial outer scope, containing the
1105 function-try-block. */
1108 begin_function_try_block (tree
*compound_stmt
)
1111 /* This outer scope does not exist in the C++ standard, but we need
1112 a place to put __FUNCTION__ and similar variables. */
1113 *compound_stmt
= begin_compound_stmt (0);
1114 r
= begin_try_block ();
1115 FN_TRY_BLOCK_P (r
) = 1;
1119 /* Finish a try-block, which may be given by TRY_BLOCK. */
1122 finish_try_block (tree try_block
)
1124 TRY_STMTS (try_block
) = pop_stmt_list (TRY_STMTS (try_block
));
1125 TRY_HANDLERS (try_block
) = push_stmt_list ();
1128 /* Finish the body of a cleanup try-block, which may be given by
1132 finish_cleanup_try_block (tree try_block
)
1134 TRY_STMTS (try_block
) = pop_stmt_list (TRY_STMTS (try_block
));
1137 /* Finish an implicitly generated try-block, with a cleanup is given
1141 finish_cleanup (tree cleanup
, tree try_block
)
1143 TRY_HANDLERS (try_block
) = cleanup
;
1144 CLEANUP_P (try_block
) = 1;
1147 /* Likewise, for a function-try-block. */
1150 finish_function_try_block (tree try_block
)
1152 finish_try_block (try_block
);
1153 /* FIXME : something queer about CTOR_INITIALIZER somehow following
1154 the try block, but moving it inside. */
1155 in_function_try_handler
= 1;
1158 /* Finish a handler-sequence for a try-block, which may be given by
1162 finish_handler_sequence (tree try_block
)
1164 TRY_HANDLERS (try_block
) = pop_stmt_list (TRY_HANDLERS (try_block
));
1165 check_handlers (TRY_HANDLERS (try_block
));
1168 /* Finish the handler-seq for a function-try-block, given by
1169 TRY_BLOCK. COMPOUND_STMT is the outer block created by
1170 begin_function_try_block. */
1173 finish_function_handler_sequence (tree try_block
, tree compound_stmt
)
1175 in_function_try_handler
= 0;
1176 finish_handler_sequence (try_block
);
1177 finish_compound_stmt (compound_stmt
);
1180 /* Begin a handler. Returns a HANDLER if appropriate. */
1183 begin_handler (void)
1187 r
= build_stmt (input_location
, HANDLER
, NULL_TREE
, NULL_TREE
);
1190 /* Create a binding level for the eh_info and the exception object
1192 HANDLER_BODY (r
) = do_pushlevel (sk_catch
);
1197 /* Finish the handler-parameters for a handler, which may be given by
1198 HANDLER. DECL is the declaration for the catch parameter, or NULL
1199 if this is a `catch (...)' clause. */
1202 finish_handler_parms (tree decl
, tree handler
)
1204 tree type
= NULL_TREE
;
1205 if (processing_template_decl
)
1209 decl
= pushdecl (decl
);
1210 decl
= push_template_decl (decl
);
1211 HANDLER_PARMS (handler
) = decl
;
1212 type
= TREE_TYPE (decl
);
1216 type
= expand_start_catch_block (decl
);
1217 HANDLER_TYPE (handler
) = type
;
1218 if (!processing_template_decl
&& type
)
1219 mark_used (eh_type_info (type
));
1222 /* Finish a handler, which may be given by HANDLER. The BLOCKs are
1223 the return value from the matching call to finish_handler_parms. */
1226 finish_handler (tree handler
)
1228 if (!processing_template_decl
)
1229 expand_end_catch_block ();
1230 HANDLER_BODY (handler
) = do_poplevel (HANDLER_BODY (handler
));
1233 /* Begin a compound statement. FLAGS contains some bits that control the
1234 behavior and context. If BCS_NO_SCOPE is set, the compound statement
1235 does not define a scope. If BCS_FN_BODY is set, this is the outermost
1236 block of a function. If BCS_TRY_BLOCK is set, this is the block
1237 created on behalf of a TRY statement. Returns a token to be passed to
1238 finish_compound_stmt. */
1241 begin_compound_stmt (unsigned int flags
)
1245 if (flags
& BCS_NO_SCOPE
)
1247 r
= push_stmt_list ();
1248 STATEMENT_LIST_NO_SCOPE (r
) = 1;
1250 /* Normally, we try hard to keep the BLOCK for a statement-expression.
1251 But, if it's a statement-expression with a scopeless block, there's
1252 nothing to keep, and we don't want to accidentally keep a block
1253 *inside* the scopeless block. */
1254 keep_next_level (false);
1257 r
= do_pushlevel (flags
& BCS_TRY_BLOCK
? sk_try
: sk_block
);
1259 /* When processing a template, we need to remember where the braces were,
1260 so that we can set up identical scopes when instantiating the template
1261 later. BIND_EXPR is a handy candidate for this.
1262 Note that do_poplevel won't create a BIND_EXPR itself here (and thus
1263 result in nested BIND_EXPRs), since we don't build BLOCK nodes when
1264 processing templates. */
1265 if (processing_template_decl
)
1267 r
= build3 (BIND_EXPR
, NULL
, NULL
, r
, NULL
);
1268 BIND_EXPR_TRY_BLOCK (r
) = (flags
& BCS_TRY_BLOCK
) != 0;
1269 BIND_EXPR_BODY_BLOCK (r
) = (flags
& BCS_FN_BODY
) != 0;
1270 TREE_SIDE_EFFECTS (r
) = 1;
1276 /* Finish a compound-statement, which is given by STMT. */
1279 finish_compound_stmt (tree stmt
)
1281 if (TREE_CODE (stmt
) == BIND_EXPR
)
1283 tree body
= do_poplevel (BIND_EXPR_BODY (stmt
));
1284 /* If the STATEMENT_LIST is empty and this BIND_EXPR isn't special,
1285 discard the BIND_EXPR so it can be merged with the containing
1287 if (TREE_CODE (body
) == STATEMENT_LIST
1288 && STATEMENT_LIST_HEAD (body
) == NULL
1289 && !BIND_EXPR_BODY_BLOCK (stmt
)
1290 && !BIND_EXPR_TRY_BLOCK (stmt
))
1293 BIND_EXPR_BODY (stmt
) = body
;
1295 else if (STATEMENT_LIST_NO_SCOPE (stmt
))
1296 stmt
= pop_stmt_list (stmt
);
1299 /* Destroy any ObjC "super" receivers that may have been
1301 objc_clear_super_receiver ();
1303 stmt
= do_poplevel (stmt
);
1306 /* ??? See c_end_compound_stmt wrt statement expressions. */
1311 /* Finish an asm-statement, whose components are a STRING, some
1312 OUTPUT_OPERANDS, some INPUT_OPERANDS, some CLOBBERS and some
1313 LABELS. Also note whether the asm-statement should be
1314 considered volatile. */
1317 finish_asm_stmt (int volatile_p
, tree string
, tree output_operands
,
1318 tree input_operands
, tree clobbers
, tree labels
)
1322 int ninputs
= list_length (input_operands
);
1323 int noutputs
= list_length (output_operands
);
1325 if (!processing_template_decl
)
1327 const char *constraint
;
1328 const char **oconstraints
;
1329 bool allows_mem
, allows_reg
, is_inout
;
1333 oconstraints
= XALLOCAVEC (const char *, noutputs
);
1335 string
= resolve_asm_operand_names (string
, output_operands
,
1336 input_operands
, labels
);
1338 for (i
= 0, t
= output_operands
; t
; t
= TREE_CHAIN (t
), ++i
)
1340 operand
= TREE_VALUE (t
);
1342 /* ??? Really, this should not be here. Users should be using a
1343 proper lvalue, dammit. But there's a long history of using
1344 casts in the output operands. In cases like longlong.h, this
1345 becomes a primitive form of typechecking -- if the cast can be
1346 removed, then the output operand had a type of the proper width;
1347 otherwise we'll get an error. Gross, but ... */
1348 STRIP_NOPS (operand
);
1350 operand
= mark_lvalue_use (operand
);
1352 if (!lvalue_or_else (operand
, lv_asm
, tf_warning_or_error
))
1353 operand
= error_mark_node
;
1355 if (operand
!= error_mark_node
1356 && (TREE_READONLY (operand
)
1357 || CP_TYPE_CONST_P (TREE_TYPE (operand
))
1358 /* Functions are not modifiable, even though they are
1360 || TREE_CODE (TREE_TYPE (operand
)) == FUNCTION_TYPE
1361 || TREE_CODE (TREE_TYPE (operand
)) == METHOD_TYPE
1362 /* If it's an aggregate and any field is const, then it is
1363 effectively const. */
1364 || (CLASS_TYPE_P (TREE_TYPE (operand
))
1365 && C_TYPE_FIELDS_READONLY (TREE_TYPE (operand
)))))
1366 cxx_readonly_error (operand
, lv_asm
);
1368 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
1369 oconstraints
[i
] = constraint
;
1371 if (parse_output_constraint (&constraint
, i
, ninputs
, noutputs
,
1372 &allows_mem
, &allows_reg
, &is_inout
))
1374 /* If the operand is going to end up in memory,
1375 mark it addressable. */
1376 if (!allows_reg
&& !cxx_mark_addressable (operand
))
1377 operand
= error_mark_node
;
1380 operand
= error_mark_node
;
1382 TREE_VALUE (t
) = operand
;
1385 for (i
= 0, t
= input_operands
; t
; ++i
, t
= TREE_CHAIN (t
))
1387 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
1388 operand
= decay_conversion (TREE_VALUE (t
), tf_warning_or_error
);
1390 /* If the type of the operand hasn't been determined (e.g.,
1391 because it involves an overloaded function), then issue
1392 an error message. There's no context available to
1393 resolve the overloading. */
1394 if (TREE_TYPE (operand
) == unknown_type_node
)
1396 error ("type of asm operand %qE could not be determined",
1398 operand
= error_mark_node
;
1401 if (parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, 0,
1402 oconstraints
, &allows_mem
, &allows_reg
))
1404 /* If the operand is going to end up in memory,
1405 mark it addressable. */
1406 if (!allows_reg
&& allows_mem
)
1408 /* Strip the nops as we allow this case. FIXME, this really
1409 should be rejected or made deprecated. */
1410 STRIP_NOPS (operand
);
1411 if (!cxx_mark_addressable (operand
))
1412 operand
= error_mark_node
;
1416 operand
= error_mark_node
;
1418 TREE_VALUE (t
) = operand
;
1422 r
= build_stmt (input_location
, ASM_EXPR
, string
,
1423 output_operands
, input_operands
,
1425 ASM_VOLATILE_P (r
) = volatile_p
|| noutputs
== 0;
1426 r
= maybe_cleanup_point_expr_void (r
);
1427 return add_stmt (r
);
1430 /* Finish a label with the indicated NAME. Returns the new label. */
1433 finish_label_stmt (tree name
)
1435 tree decl
= define_label (input_location
, name
);
1437 if (decl
== error_mark_node
)
1438 return error_mark_node
;
1440 add_stmt (build_stmt (input_location
, LABEL_EXPR
, decl
));
1445 /* Finish a series of declarations for local labels. G++ allows users
1446 to declare "local" labels, i.e., labels with scope. This extension
1447 is useful when writing code involving statement-expressions. */
1450 finish_label_decl (tree name
)
1452 if (!at_function_scope_p ())
1454 error ("__label__ declarations are only allowed in function scopes");
1458 add_decl_expr (declare_local_label (name
));
1461 /* When DECL goes out of scope, make sure that CLEANUP is executed. */
1464 finish_decl_cleanup (tree decl
, tree cleanup
)
1466 push_cleanup (decl
, cleanup
, false);
1469 /* If the current scope exits with an exception, run CLEANUP. */
1472 finish_eh_cleanup (tree cleanup
)
1474 push_cleanup (NULL
, cleanup
, true);
1477 /* The MEM_INITS is a list of mem-initializers, in reverse of the
1478 order they were written by the user. Each node is as for
1479 emit_mem_initializers. */
1482 finish_mem_initializers (tree mem_inits
)
1484 /* Reorder the MEM_INITS so that they are in the order they appeared
1485 in the source program. */
1486 mem_inits
= nreverse (mem_inits
);
1488 if (processing_template_decl
)
1492 for (mem
= mem_inits
; mem
; mem
= TREE_CHAIN (mem
))
1494 /* If the TREE_PURPOSE is a TYPE_PACK_EXPANSION, skip the
1495 check for bare parameter packs in the TREE_VALUE, because
1496 any parameter packs in the TREE_VALUE have already been
1497 bound as part of the TREE_PURPOSE. See
1498 make_pack_expansion for more information. */
1499 if (TREE_CODE (TREE_PURPOSE (mem
)) != TYPE_PACK_EXPANSION
1500 && check_for_bare_parameter_packs (TREE_VALUE (mem
)))
1501 TREE_VALUE (mem
) = error_mark_node
;
1504 add_stmt (build_min_nt_loc (UNKNOWN_LOCATION
,
1505 CTOR_INITIALIZER
, mem_inits
));
1508 emit_mem_initializers (mem_inits
);
1511 /* Finish a parenthesized expression EXPR. */
1514 finish_parenthesized_expr (tree expr
)
1517 /* This inhibits warnings in c_common_truthvalue_conversion. */
1518 TREE_NO_WARNING (expr
) = 1;
1520 if (TREE_CODE (expr
) == OFFSET_REF
1521 || TREE_CODE (expr
) == SCOPE_REF
)
1522 /* [expr.unary.op]/3 The qualified id of a pointer-to-member must not be
1523 enclosed in parentheses. */
1524 PTRMEM_OK_P (expr
) = 0;
1526 if (TREE_CODE (expr
) == STRING_CST
)
1527 PAREN_STRING_LITERAL_P (expr
) = 1;
1532 /* Finish a reference to a non-static data member (DECL) that is not
1533 preceded by `.' or `->'. */
1536 finish_non_static_data_member (tree decl
, tree object
, tree qualifying_scope
)
1538 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
);
1542 tree scope
= qualifying_scope
;
1543 if (scope
== NULL_TREE
)
1544 scope
= context_for_name_lookup (decl
);
1545 object
= maybe_dummy_object (scope
, NULL
);
1548 if (object
== error_mark_node
)
1549 return error_mark_node
;
1551 /* DR 613: Can use non-static data members without an associated
1552 object in sizeof/decltype/alignof. */
1553 if (is_dummy_object (object
) && cp_unevaluated_operand
== 0
1554 && (!processing_template_decl
|| !current_class_ref
))
1556 if (current_function_decl
1557 && DECL_STATIC_FUNCTION_P (current_function_decl
))
1558 error ("invalid use of member %q+D in static member function", decl
);
1560 error ("invalid use of non-static data member %q+D", decl
);
1561 error ("from this location");
1563 return error_mark_node
;
1566 if (current_class_ptr
)
1567 TREE_USED (current_class_ptr
) = 1;
1568 if (processing_template_decl
&& !qualifying_scope
)
1570 tree type
= TREE_TYPE (decl
);
1572 if (TREE_CODE (type
) == REFERENCE_TYPE
)
1573 /* Quals on the object don't matter. */;
1576 /* Set the cv qualifiers. */
1577 int quals
= (current_class_ref
1578 ? cp_type_quals (TREE_TYPE (current_class_ref
))
1579 : TYPE_UNQUALIFIED
);
1581 if (DECL_MUTABLE_P (decl
))
1582 quals
&= ~TYPE_QUAL_CONST
;
1584 quals
|= cp_type_quals (TREE_TYPE (decl
));
1585 type
= cp_build_qualified_type (type
, quals
);
1588 return (convert_from_reference
1589 (build_min (COMPONENT_REF
, type
, object
, decl
, NULL_TREE
)));
1591 /* If PROCESSING_TEMPLATE_DECL is nonzero here, then
1592 QUALIFYING_SCOPE is also non-null. Wrap this in a SCOPE_REF
1594 else if (processing_template_decl
)
1595 return build_qualified_name (TREE_TYPE (decl
),
1598 /*template_p=*/false);
1601 tree access_type
= TREE_TYPE (object
);
1603 perform_or_defer_access_check (TYPE_BINFO (access_type
), decl
,
1606 /* If the data member was named `C::M', convert `*this' to `C'
1608 if (qualifying_scope
)
1610 tree binfo
= NULL_TREE
;
1611 object
= build_scoped_ref (object
, qualifying_scope
,
1615 return build_class_member_access_expr (object
, decl
,
1616 /*access_path=*/NULL_TREE
,
1617 /*preserve_reference=*/false,
1618 tf_warning_or_error
);
1622 /* If we are currently parsing a template and we encountered a typedef
1623 TYPEDEF_DECL that is being accessed though CONTEXT, this function
1624 adds the typedef to a list tied to the current template.
1625 At tempate instantiatin time, that list is walked and access check
1626 performed for each typedef.
1627 LOCATION is the location of the usage point of TYPEDEF_DECL. */
1630 add_typedef_to_current_template_for_access_check (tree typedef_decl
,
1632 location_t location
)
1634 tree template_info
= NULL
;
1635 tree cs
= current_scope ();
1637 if (!is_typedef_decl (typedef_decl
)
1639 || !CLASS_TYPE_P (context
)
1643 if (CLASS_TYPE_P (cs
) || TREE_CODE (cs
) == FUNCTION_DECL
)
1644 template_info
= get_template_info (cs
);
1647 && TI_TEMPLATE (template_info
)
1648 && !currently_open_class (context
))
1649 append_type_to_template_for_access_check (cs
, typedef_decl
,
1653 /* DECL was the declaration to which a qualified-id resolved. Issue
1654 an error message if it is not accessible. If OBJECT_TYPE is
1655 non-NULL, we have just seen `x->' or `x.' and OBJECT_TYPE is the
1656 type of `*x', or `x', respectively. If the DECL was named as
1657 `A::B' then NESTED_NAME_SPECIFIER is `A'. */
1660 check_accessibility_of_qualified_id (tree decl
,
1662 tree nested_name_specifier
)
1665 tree qualifying_type
= NULL_TREE
;
1667 /* If we are parsing a template declaration and if decl is a typedef,
1668 add it to a list tied to the template.
1669 At template instantiation time, that list will be walked and
1670 access check performed. */
1671 add_typedef_to_current_template_for_access_check (decl
,
1672 nested_name_specifier
1673 ? nested_name_specifier
1674 : DECL_CONTEXT (decl
),
1677 /* If we're not checking, return immediately. */
1678 if (deferred_access_no_check
)
1681 /* Determine the SCOPE of DECL. */
1682 scope
= context_for_name_lookup (decl
);
1683 /* If the SCOPE is not a type, then DECL is not a member. */
1684 if (!TYPE_P (scope
))
1686 /* Compute the scope through which DECL is being accessed. */
1688 /* OBJECT_TYPE might not be a class type; consider:
1690 class A { typedef int I; };
1694 In this case, we will have "A::I" as the DECL, but "I" as the
1696 && CLASS_TYPE_P (object_type
)
1697 && DERIVED_FROM_P (scope
, object_type
))
1698 /* If we are processing a `->' or `.' expression, use the type of the
1700 qualifying_type
= object_type
;
1701 else if (nested_name_specifier
)
1703 /* If the reference is to a non-static member of the
1704 current class, treat it as if it were referenced through
1706 if (DECL_NONSTATIC_MEMBER_P (decl
)
1707 && current_class_ptr
1708 && DERIVED_FROM_P (scope
, current_class_type
))
1709 qualifying_type
= current_class_type
;
1710 /* Otherwise, use the type indicated by the
1711 nested-name-specifier. */
1713 qualifying_type
= nested_name_specifier
;
1716 /* Otherwise, the name must be from the current class or one of
1718 qualifying_type
= currently_open_derived_class (scope
);
1721 /* It is possible for qualifying type to be a TEMPLATE_TYPE_PARM
1722 or similar in a default argument value. */
1723 && CLASS_TYPE_P (qualifying_type
)
1724 && !dependent_type_p (qualifying_type
))
1725 perform_or_defer_access_check (TYPE_BINFO (qualifying_type
), decl
,
1729 /* EXPR is the result of a qualified-id. The QUALIFYING_CLASS was the
1730 class named to the left of the "::" operator. DONE is true if this
1731 expression is a complete postfix-expression; it is false if this
1732 expression is followed by '->', '[', '(', etc. ADDRESS_P is true
1733 iff this expression is the operand of '&'. TEMPLATE_P is true iff
1734 the qualified-id was of the form "A::template B". TEMPLATE_ARG_P
1735 is true iff this qualified name appears as a template argument. */
1738 finish_qualified_id_expr (tree qualifying_class
,
1743 bool template_arg_p
)
1745 gcc_assert (TYPE_P (qualifying_class
));
1747 if (error_operand_p (expr
))
1748 return error_mark_node
;
1750 if (DECL_P (expr
) || BASELINK_P (expr
))
1754 check_template_keyword (expr
);
1756 /* If EXPR occurs as the operand of '&', use special handling that
1757 permits a pointer-to-member. */
1758 if (address_p
&& done
)
1760 if (TREE_CODE (expr
) == SCOPE_REF
)
1761 expr
= TREE_OPERAND (expr
, 1);
1762 expr
= build_offset_ref (qualifying_class
, expr
,
1763 /*address_p=*/true);
1767 /* Within the scope of a class, turn references to non-static
1768 members into expression of the form "this->...". */
1770 /* But, within a template argument, we do not want make the
1771 transformation, as there is no "this" pointer. */
1773 else if (TREE_CODE (expr
) == FIELD_DECL
)
1775 push_deferring_access_checks (dk_no_check
);
1776 expr
= finish_non_static_data_member (expr
, NULL_TREE
,
1778 pop_deferring_access_checks ();
1780 else if (BASELINK_P (expr
) && !processing_template_decl
)
1784 /* See if any of the functions are non-static members. */
1785 /* If so, the expression may be relative to 'this'. */
1786 if (!shared_member_p (expr
)
1787 && (ob
= maybe_dummy_object (qualifying_class
, NULL
),
1788 !is_dummy_object (ob
)))
1789 expr
= (build_class_member_access_expr
1792 BASELINK_ACCESS_BINFO (expr
),
1793 /*preserve_reference=*/false,
1794 tf_warning_or_error
));
1796 /* The expression is a qualified name whose address is not
1798 expr
= build_offset_ref (qualifying_class
, expr
, /*address_p=*/false);
1804 /* Begin a statement-expression. The value returned must be passed to
1805 finish_stmt_expr. */
1808 begin_stmt_expr (void)
1810 return push_stmt_list ();
1813 /* Process the final expression of a statement expression. EXPR can be
1814 NULL, if the final expression is empty. Return a STATEMENT_LIST
1815 containing all the statements in the statement-expression, or
1816 ERROR_MARK_NODE if there was an error. */
1819 finish_stmt_expr_expr (tree expr
, tree stmt_expr
)
1821 if (error_operand_p (expr
))
1823 /* The type of the statement-expression is the type of the last
1825 TREE_TYPE (stmt_expr
) = error_mark_node
;
1826 return error_mark_node
;
1829 /* If the last statement does not have "void" type, then the value
1830 of the last statement is the value of the entire expression. */
1833 tree type
= TREE_TYPE (expr
);
1835 if (processing_template_decl
)
1837 expr
= build_stmt (input_location
, EXPR_STMT
, expr
);
1838 expr
= add_stmt (expr
);
1839 /* Mark the last statement so that we can recognize it as such at
1840 template-instantiation time. */
1841 EXPR_STMT_STMT_EXPR_RESULT (expr
) = 1;
1843 else if (VOID_TYPE_P (type
))
1845 /* Just treat this like an ordinary statement. */
1846 expr
= finish_expr_stmt (expr
);
1850 /* It actually has a value we need to deal with. First, force it
1851 to be an rvalue so that we won't need to build up a copy
1852 constructor call later when we try to assign it to something. */
1853 expr
= force_rvalue (expr
, tf_warning_or_error
);
1854 if (error_operand_p (expr
))
1855 return error_mark_node
;
1857 /* Update for array-to-pointer decay. */
1858 type
= TREE_TYPE (expr
);
1860 /* Wrap it in a CLEANUP_POINT_EXPR and add it to the list like a
1861 normal statement, but don't convert to void or actually add
1863 if (TREE_CODE (expr
) != CLEANUP_POINT_EXPR
)
1864 expr
= maybe_cleanup_point_expr (expr
);
1868 /* The type of the statement-expression is the type of the last
1870 TREE_TYPE (stmt_expr
) = type
;
1876 /* Finish a statement-expression. EXPR should be the value returned
1877 by the previous begin_stmt_expr. Returns an expression
1878 representing the statement-expression. */
1881 finish_stmt_expr (tree stmt_expr
, bool has_no_scope
)
1886 if (error_operand_p (stmt_expr
))
1888 pop_stmt_list (stmt_expr
);
1889 return error_mark_node
;
1892 gcc_assert (TREE_CODE (stmt_expr
) == STATEMENT_LIST
);
1894 type
= TREE_TYPE (stmt_expr
);
1895 result
= pop_stmt_list (stmt_expr
);
1896 TREE_TYPE (result
) = type
;
1898 if (processing_template_decl
)
1900 result
= build_min (STMT_EXPR
, type
, result
);
1901 TREE_SIDE_EFFECTS (result
) = 1;
1902 STMT_EXPR_NO_SCOPE (result
) = has_no_scope
;
1904 else if (CLASS_TYPE_P (type
))
1906 /* Wrap the statement-expression in a TARGET_EXPR so that the
1907 temporary object created by the final expression is destroyed at
1908 the end of the full-expression containing the
1909 statement-expression. */
1910 result
= force_target_expr (type
, result
, tf_warning_or_error
);
1916 /* Returns the expression which provides the value of STMT_EXPR. */
1919 stmt_expr_value_expr (tree stmt_expr
)
1921 tree t
= STMT_EXPR_STMT (stmt_expr
);
1923 if (TREE_CODE (t
) == BIND_EXPR
)
1924 t
= BIND_EXPR_BODY (t
);
1926 if (TREE_CODE (t
) == STATEMENT_LIST
&& STATEMENT_LIST_TAIL (t
))
1927 t
= STATEMENT_LIST_TAIL (t
)->stmt
;
1929 if (TREE_CODE (t
) == EXPR_STMT
)
1930 t
= EXPR_STMT_EXPR (t
);
1935 /* Return TRUE iff EXPR_STMT is an empty list of
1936 expression statements. */
1939 empty_expr_stmt_p (tree expr_stmt
)
1941 tree body
= NULL_TREE
;
1943 if (expr_stmt
== void_zero_node
)
1948 if (TREE_CODE (expr_stmt
) == EXPR_STMT
)
1949 body
= EXPR_STMT_EXPR (expr_stmt
);
1950 else if (TREE_CODE (expr_stmt
) == STATEMENT_LIST
)
1956 if (TREE_CODE (body
) == STATEMENT_LIST
)
1957 return tsi_end_p (tsi_start (body
));
1959 return empty_expr_stmt_p (body
);
1964 /* Perform Koenig lookup. FN is the postfix-expression representing
1965 the function (or functions) to call; ARGS are the arguments to the
1966 call; if INCLUDE_STD then the `std' namespace is automatically
1967 considered an associated namespace (used in range-based for loops).
1968 Returns the functions to be considered by overload resolution. */
1971 perform_koenig_lookup (tree fn
, VEC(tree
,gc
) *args
, bool include_std
,
1972 tsubst_flags_t complain
)
1974 tree identifier
= NULL_TREE
;
1975 tree functions
= NULL_TREE
;
1976 tree tmpl_args
= NULL_TREE
;
1977 bool template_id
= false;
1979 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
1981 /* Use a separate flag to handle null args. */
1983 tmpl_args
= TREE_OPERAND (fn
, 1);
1984 fn
= TREE_OPERAND (fn
, 0);
1987 /* Find the name of the overloaded function. */
1988 if (TREE_CODE (fn
) == IDENTIFIER_NODE
)
1990 else if (is_overloaded_fn (fn
))
1993 identifier
= DECL_NAME (get_first_fn (functions
));
1995 else if (DECL_P (fn
))
1998 identifier
= DECL_NAME (fn
);
2001 /* A call to a namespace-scope function using an unqualified name.
2003 Do Koenig lookup -- unless any of the arguments are
2005 if (!any_type_dependent_arguments_p (args
)
2006 && !any_dependent_template_arguments_p (tmpl_args
))
2008 fn
= lookup_arg_dependent (identifier
, functions
, args
, include_std
);
2011 /* The unqualified name could not be resolved. */
2013 fn
= unqualified_fn_lookup_error (identifier
);
2019 if (fn
&& template_id
)
2020 fn
= build2 (TEMPLATE_ID_EXPR
, unknown_type_node
, fn
, tmpl_args
);
2025 /* Generate an expression for `FN (ARGS)'. This may change the
2028 If DISALLOW_VIRTUAL is true, the call to FN will be not generated
2029 as a virtual call, even if FN is virtual. (This flag is set when
2030 encountering an expression where the function name is explicitly
2031 qualified. For example a call to `X::f' never generates a virtual
2034 Returns code for the call. */
2037 finish_call_expr (tree fn
, VEC(tree
,gc
) **args
, bool disallow_virtual
,
2038 bool koenig_p
, tsubst_flags_t complain
)
2042 VEC(tree
,gc
) *orig_args
= NULL
;
2044 if (fn
== error_mark_node
)
2045 return error_mark_node
;
2047 gcc_assert (!TYPE_P (fn
));
2051 if (processing_template_decl
)
2053 /* If the call expression is dependent, build a CALL_EXPR node
2054 with no type; type_dependent_expression_p recognizes
2055 expressions with no type as being dependent. */
2056 if (type_dependent_expression_p (fn
)
2057 || any_type_dependent_arguments_p (*args
)
2058 /* For a non-static member function that doesn't have an
2059 explicit object argument, we need to specifically
2060 test the type dependency of the "this" pointer because it
2061 is not included in *ARGS even though it is considered to
2062 be part of the list of arguments. Note that this is
2063 related to CWG issues 515 and 1005. */
2064 || (TREE_CODE (fn
) != COMPONENT_REF
2065 && non_static_member_function_p (fn
)
2066 && current_class_ref
2067 && type_dependent_expression_p (current_class_ref
)))
2069 result
= build_nt_call_vec (fn
, *args
);
2070 KOENIG_LOOKUP_P (result
) = koenig_p
;
2075 tree fndecl
= OVL_CURRENT (fn
);
2076 if (TREE_CODE (fndecl
) != FUNCTION_DECL
2077 || !TREE_THIS_VOLATILE (fndecl
))
2083 current_function_returns_abnormally
= 1;
2087 orig_args
= make_tree_vector_copy (*args
);
2088 if (!BASELINK_P (fn
)
2089 && TREE_CODE (fn
) != PSEUDO_DTOR_EXPR
2090 && TREE_TYPE (fn
) != unknown_type_node
)
2091 fn
= build_non_dependent_expr (fn
);
2092 make_args_non_dependent (*args
);
2095 if (TREE_CODE (fn
) == COMPONENT_REF
)
2097 tree member
= TREE_OPERAND (fn
, 1);
2098 if (BASELINK_P (member
))
2100 tree object
= TREE_OPERAND (fn
, 0);
2101 return build_new_method_call (object
, member
,
2104 ? LOOKUP_NORMAL
| LOOKUP_NONVIRTUAL
2111 if (is_overloaded_fn (fn
))
2112 fn
= baselink_for_fns (fn
);
2115 if (BASELINK_P (fn
))
2119 /* A call to a member function. From [over.call.func]:
2121 If the keyword this is in scope and refers to the class of
2122 that member function, or a derived class thereof, then the
2123 function call is transformed into a qualified function call
2124 using (*this) as the postfix-expression to the left of the
2125 . operator.... [Otherwise] a contrived object of type T
2126 becomes the implied object argument.
2130 struct A { void f(); };
2131 struct B : public A {};
2132 struct C : public A { void g() { B::f(); }};
2134 "the class of that member function" refers to `A'. But 11.2
2135 [class.access.base] says that we need to convert 'this' to B* as
2136 part of the access, so we pass 'B' to maybe_dummy_object. */
2138 object
= maybe_dummy_object (BINFO_TYPE (BASELINK_ACCESS_BINFO (fn
)),
2141 if (processing_template_decl
)
2143 if (type_dependent_expression_p (object
))
2145 tree ret
= build_nt_call_vec (orig_fn
, orig_args
);
2146 release_tree_vector (orig_args
);
2149 object
= build_non_dependent_expr (object
);
2152 result
= build_new_method_call (object
, fn
, args
, NULL_TREE
,
2154 ? LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
2159 else if (is_overloaded_fn (fn
))
2161 /* If the function is an overloaded builtin, resolve it. */
2162 if (TREE_CODE (fn
) == FUNCTION_DECL
2163 && (DECL_BUILT_IN_CLASS (fn
) == BUILT_IN_NORMAL
2164 || DECL_BUILT_IN_CLASS (fn
) == BUILT_IN_MD
))
2165 result
= resolve_overloaded_builtin (input_location
, fn
, *args
);
2168 /* A call to a namespace-scope function. */
2169 result
= build_new_function_call (fn
, args
, koenig_p
, complain
);
2171 else if (TREE_CODE (fn
) == PSEUDO_DTOR_EXPR
)
2173 if (!VEC_empty (tree
, *args
))
2174 error ("arguments to destructor are not allowed");
2175 /* Mark the pseudo-destructor call as having side-effects so
2176 that we do not issue warnings about its use. */
2177 result
= build1 (NOP_EXPR
,
2179 TREE_OPERAND (fn
, 0));
2180 TREE_SIDE_EFFECTS (result
) = 1;
2182 else if (CLASS_TYPE_P (TREE_TYPE (fn
)))
2183 /* If the "function" is really an object of class type, it might
2184 have an overloaded `operator ()'. */
2185 result
= build_op_call (fn
, args
, complain
);
2188 /* A call where the function is unknown. */
2189 result
= cp_build_function_call_vec (fn
, args
, complain
);
2191 if (processing_template_decl
&& result
!= error_mark_node
)
2193 if (TREE_CODE (result
) == INDIRECT_REF
)
2194 result
= TREE_OPERAND (result
, 0);
2195 result
= build_call_vec (TREE_TYPE (result
), orig_fn
, orig_args
);
2196 SET_EXPR_LOCATION (result
, input_location
);
2197 KOENIG_LOOKUP_P (result
) = koenig_p
;
2198 release_tree_vector (orig_args
);
2199 result
= convert_from_reference (result
);
2204 /* Free garbage OVERLOADs from arg-dependent lookup. */
2205 tree next
= NULL_TREE
;
2207 fn
&& TREE_CODE (fn
) == OVERLOAD
&& OVL_ARG_DEPENDENT (fn
);
2210 if (processing_template_decl
)
2211 /* In a template, we'll re-use them at instantiation time. */
2212 OVL_ARG_DEPENDENT (fn
) = false;
2215 next
= OVL_CHAIN (fn
);
2224 /* Finish a call to a postfix increment or decrement or EXPR. (Which
2225 is indicated by CODE, which should be POSTINCREMENT_EXPR or
2226 POSTDECREMENT_EXPR.) */
2229 finish_increment_expr (tree expr
, enum tree_code code
)
2231 return build_x_unary_op (input_location
, code
, expr
, tf_warning_or_error
);
2234 /* Finish a use of `this'. Returns an expression for `this'. */
2237 finish_this_expr (void)
2241 if (current_class_ptr
)
2243 tree type
= TREE_TYPE (current_class_ref
);
2245 /* In a lambda expression, 'this' refers to the captured 'this'. */
2246 if (LAMBDA_TYPE_P (type
))
2247 result
= lambda_expr_this_capture (CLASSTYPE_LAMBDA_EXPR (type
));
2249 result
= current_class_ptr
;
2252 else if (current_function_decl
2253 && DECL_STATIC_FUNCTION_P (current_function_decl
))
2255 error ("%<this%> is unavailable for static member functions");
2256 result
= error_mark_node
;
2260 if (current_function_decl
)
2261 error ("invalid use of %<this%> in non-member function");
2263 error ("invalid use of %<this%> at top level");
2264 result
= error_mark_node
;
2270 /* Finish a pseudo-destructor expression. If SCOPE is NULL, the
2271 expression was of the form `OBJECT.~DESTRUCTOR' where DESTRUCTOR is
2272 the TYPE for the type given. If SCOPE is non-NULL, the expression
2273 was of the form `OBJECT.SCOPE::~DESTRUCTOR'. */
2276 finish_pseudo_destructor_expr (tree object
, tree scope
, tree destructor
)
2278 if (object
== error_mark_node
|| destructor
== error_mark_node
)
2279 return error_mark_node
;
2281 gcc_assert (TYPE_P (destructor
));
2283 if (!processing_template_decl
)
2285 if (scope
== error_mark_node
)
2287 error ("invalid qualifying scope in pseudo-destructor name");
2288 return error_mark_node
;
2290 if (scope
&& TYPE_P (scope
) && !check_dtor_name (scope
, destructor
))
2292 error ("qualified type %qT does not match destructor name ~%qT",
2294 return error_mark_node
;
2298 /* [expr.pseudo] says both:
2300 The type designated by the pseudo-destructor-name shall be
2301 the same as the object type.
2305 The cv-unqualified versions of the object type and of the
2306 type designated by the pseudo-destructor-name shall be the
2309 We implement the more generous second sentence, since that is
2310 what most other compilers do. */
2311 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (object
),
2314 error ("%qE is not of type %qT", object
, destructor
);
2315 return error_mark_node
;
2319 return build3 (PSEUDO_DTOR_EXPR
, void_type_node
, object
, scope
, destructor
);
2322 /* Finish an expression of the form CODE EXPR. */
2325 finish_unary_op_expr (location_t loc
, enum tree_code code
, tree expr
)
2327 tree result
= build_x_unary_op (loc
, code
, expr
, tf_warning_or_error
);
2328 if (TREE_OVERFLOW_P (result
) && !TREE_OVERFLOW_P (expr
))
2329 overflow_warning (input_location
, result
);
2334 /* Finish a compound-literal expression. TYPE is the type to which
2335 the CONSTRUCTOR in COMPOUND_LITERAL is being cast. */
2338 finish_compound_literal (tree type
, tree compound_literal
,
2339 tsubst_flags_t complain
)
2341 if (type
== error_mark_node
)
2342 return error_mark_node
;
2344 if (TREE_CODE (type
) == REFERENCE_TYPE
)
2347 = finish_compound_literal (TREE_TYPE (type
), compound_literal
,
2349 return cp_build_c_cast (type
, compound_literal
, complain
);
2352 if (!TYPE_OBJ_P (type
))
2354 if (complain
& tf_error
)
2355 error ("compound literal of non-object type %qT", type
);
2356 return error_mark_node
;
2359 if (processing_template_decl
)
2361 TREE_TYPE (compound_literal
) = type
;
2362 /* Mark the expression as a compound literal. */
2363 TREE_HAS_CONSTRUCTOR (compound_literal
) = 1;
2364 return compound_literal
;
2367 type
= complete_type (type
);
2369 if (TYPE_NON_AGGREGATE_CLASS (type
))
2371 /* Trying to deal with a CONSTRUCTOR instead of a TREE_LIST
2372 everywhere that deals with function arguments would be a pain, so
2373 just wrap it in a TREE_LIST. The parser set a flag so we know
2374 that it came from T{} rather than T({}). */
2375 CONSTRUCTOR_IS_DIRECT_INIT (compound_literal
) = 1;
2376 compound_literal
= build_tree_list (NULL_TREE
, compound_literal
);
2377 return build_functional_cast (type
, compound_literal
, complain
);
2380 if (TREE_CODE (type
) == ARRAY_TYPE
2381 && check_array_initializer (NULL_TREE
, type
, compound_literal
))
2382 return error_mark_node
;
2383 compound_literal
= reshape_init (type
, compound_literal
, complain
);
2384 if (SCALAR_TYPE_P (type
)
2385 && !BRACE_ENCLOSED_INITIALIZER_P (compound_literal
)
2386 && (complain
& tf_warning_or_error
))
2387 check_narrowing (type
, compound_literal
);
2388 if (TREE_CODE (type
) == ARRAY_TYPE
2389 && TYPE_DOMAIN (type
) == NULL_TREE
)
2391 cp_complete_array_type_or_error (&type
, compound_literal
,
2393 if (type
== error_mark_node
)
2394 return error_mark_node
;
2396 compound_literal
= digest_init (type
, compound_literal
, complain
);
2397 if (TREE_CODE (compound_literal
) == CONSTRUCTOR
)
2398 TREE_HAS_CONSTRUCTOR (compound_literal
) = true;
2399 /* Put static/constant array temporaries in static variables, but always
2400 represent class temporaries with TARGET_EXPR so we elide copies. */
2401 if ((!at_function_scope_p () || CP_TYPE_CONST_P (type
))
2402 && TREE_CODE (type
) == ARRAY_TYPE
2403 && !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
2404 && initializer_constant_valid_p (compound_literal
, type
))
2406 tree decl
= create_temporary_var (type
);
2407 DECL_INITIAL (decl
) = compound_literal
;
2408 TREE_STATIC (decl
) = 1;
2409 if (literal_type_p (type
) && CP_TYPE_CONST_NON_VOLATILE_P (type
))
2411 /* 5.19 says that a constant expression can include an
2412 lvalue-rvalue conversion applied to "a glvalue of literal type
2413 that refers to a non-volatile temporary object initialized
2414 with a constant expression". Rather than try to communicate
2415 that this VAR_DECL is a temporary, just mark it constexpr. */
2416 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
2417 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = true;
2418 TREE_CONSTANT (decl
) = true;
2420 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
2421 decl
= pushdecl_top_level (decl
);
2422 DECL_NAME (decl
) = make_anon_name ();
2423 SET_DECL_ASSEMBLER_NAME (decl
, DECL_NAME (decl
));
2427 return get_target_expr_sfinae (compound_literal
, complain
);
2430 /* Return the declaration for the function-name variable indicated by
2434 finish_fname (tree id
)
2438 decl
= fname_decl (input_location
, C_RID_CODE (id
), id
);
2439 if (processing_template_decl
&& current_function_decl
)
2440 decl
= DECL_NAME (decl
);
2444 /* Finish a translation unit. */
2447 finish_translation_unit (void)
2449 /* In case there were missing closebraces,
2450 get us back to the global binding level. */
2452 while (current_namespace
!= global_namespace
)
2455 /* Do file scope __FUNCTION__ et al. */
2456 finish_fname_decls ();
2459 /* Finish a template type parameter, specified as AGGR IDENTIFIER.
2460 Returns the parameter. */
2463 finish_template_type_parm (tree aggr
, tree identifier
)
2465 if (aggr
!= class_type_node
)
2467 permerror (input_location
, "template type parameters must use the keyword %<class%> or %<typename%>");
2468 aggr
= class_type_node
;
2471 return build_tree_list (aggr
, identifier
);
2474 /* Finish a template template parameter, specified as AGGR IDENTIFIER.
2475 Returns the parameter. */
2478 finish_template_template_parm (tree aggr
, tree identifier
)
2480 tree decl
= build_decl (input_location
,
2481 TYPE_DECL
, identifier
, NULL_TREE
);
2482 tree tmpl
= build_lang_decl (TEMPLATE_DECL
, identifier
, NULL_TREE
);
2483 DECL_TEMPLATE_PARMS (tmpl
) = current_template_parms
;
2484 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
2485 DECL_ARTIFICIAL (decl
) = 1;
2486 end_template_decl ();
2488 gcc_assert (DECL_TEMPLATE_PARMS (tmpl
));
2490 check_default_tmpl_args (decl
, DECL_TEMPLATE_PARMS (tmpl
),
2491 /*is_primary=*/true, /*is_partial=*/false,
2494 return finish_template_type_parm (aggr
, tmpl
);
2497 /* ARGUMENT is the default-argument value for a template template
2498 parameter. If ARGUMENT is invalid, issue error messages and return
2499 the ERROR_MARK_NODE. Otherwise, ARGUMENT itself is returned. */
2502 check_template_template_default_arg (tree argument
)
2504 if (TREE_CODE (argument
) != TEMPLATE_DECL
2505 && TREE_CODE (argument
) != TEMPLATE_TEMPLATE_PARM
2506 && TREE_CODE (argument
) != UNBOUND_CLASS_TEMPLATE
)
2508 if (TREE_CODE (argument
) == TYPE_DECL
)
2509 error ("invalid use of type %qT as a default value for a template "
2510 "template-parameter", TREE_TYPE (argument
));
2512 error ("invalid default argument for a template template parameter");
2513 return error_mark_node
;
2519 /* Begin a class definition, as indicated by T. */
2522 begin_class_definition (tree t
)
2524 if (error_operand_p (t
) || error_operand_p (TYPE_MAIN_DECL (t
)))
2525 return error_mark_node
;
2527 if (processing_template_parmlist
)
2529 error ("definition of %q#T inside template parameter list", t
);
2530 return error_mark_node
;
2533 /* According to the C++ ABI, decimal classes defined in ISO/IEC TR 24733
2534 are passed the same as decimal scalar types. */
2535 if (TREE_CODE (t
) == RECORD_TYPE
2536 && !processing_template_decl
)
2538 tree ns
= TYPE_CONTEXT (t
);
2539 if (ns
&& TREE_CODE (ns
) == NAMESPACE_DECL
2540 && DECL_CONTEXT (ns
) == std_node
2542 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (ns
)), "decimal"))
2544 const char *n
= TYPE_NAME_STRING (t
);
2545 if ((strcmp (n
, "decimal32") == 0)
2546 || (strcmp (n
, "decimal64") == 0)
2547 || (strcmp (n
, "decimal128") == 0))
2548 TYPE_TRANSPARENT_AGGR (t
) = 1;
2552 /* A non-implicit typename comes from code like:
2554 template <typename T> struct A {
2555 template <typename U> struct A<T>::B ...
2557 This is erroneous. */
2558 else if (TREE_CODE (t
) == TYPENAME_TYPE
)
2560 error ("invalid definition of qualified type %qT", t
);
2561 t
= error_mark_node
;
2564 if (t
== error_mark_node
|| ! MAYBE_CLASS_TYPE_P (t
))
2566 t
= make_class_type (RECORD_TYPE
);
2567 pushtag (make_anon_name (), t
, /*tag_scope=*/ts_current
);
2570 if (TYPE_BEING_DEFINED (t
))
2572 t
= make_class_type (TREE_CODE (t
));
2573 pushtag (TYPE_IDENTIFIER (t
), t
, /*tag_scope=*/ts_current
);
2575 maybe_process_partial_specialization (t
);
2577 TYPE_BEING_DEFINED (t
) = 1;
2579 if (flag_pack_struct
)
2582 TYPE_PACKED (t
) = 1;
2583 /* Even though the type is being defined for the first time
2584 here, there might have been a forward declaration, so there
2585 might be cv-qualified variants of T. */
2586 for (v
= TYPE_NEXT_VARIANT (t
); v
; v
= TYPE_NEXT_VARIANT (v
))
2587 TYPE_PACKED (v
) = 1;
2589 /* Reset the interface data, at the earliest possible
2590 moment, as it might have been set via a class foo;
2592 if (! TYPE_ANONYMOUS_P (t
))
2594 struct c_fileinfo
*finfo
= get_fileinfo (input_filename
);
2595 CLASSTYPE_INTERFACE_ONLY (t
) = finfo
->interface_only
;
2596 SET_CLASSTYPE_INTERFACE_UNKNOWN_X
2597 (t
, finfo
->interface_unknown
);
2599 reset_specialization();
2601 /* Make a declaration for this class in its own scope. */
2602 build_self_reference ();
2607 /* Finish the member declaration given by DECL. */
2610 finish_member_declaration (tree decl
)
2612 if (decl
== error_mark_node
|| decl
== NULL_TREE
)
2615 if (decl
== void_type_node
)
2616 /* The COMPONENT was a friend, not a member, and so there's
2617 nothing for us to do. */
2620 /* We should see only one DECL at a time. */
2621 gcc_assert (DECL_CHAIN (decl
) == NULL_TREE
);
2623 /* Set up access control for DECL. */
2625 = (current_access_specifier
== access_private_node
);
2626 TREE_PROTECTED (decl
)
2627 = (current_access_specifier
== access_protected_node
);
2628 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
2630 TREE_PRIVATE (DECL_TEMPLATE_RESULT (decl
)) = TREE_PRIVATE (decl
);
2631 TREE_PROTECTED (DECL_TEMPLATE_RESULT (decl
)) = TREE_PROTECTED (decl
);
2634 /* Mark the DECL as a member of the current class, unless it's
2635 a member of an enumeration. */
2636 if (TREE_CODE (decl
) != CONST_DECL
)
2637 DECL_CONTEXT (decl
) = current_class_type
;
2639 /* Check for bare parameter packs in the member variable declaration. */
2640 if (TREE_CODE (decl
) == FIELD_DECL
)
2642 if (check_for_bare_parameter_packs (TREE_TYPE (decl
)))
2643 TREE_TYPE (decl
) = error_mark_node
;
2644 if (check_for_bare_parameter_packs (DECL_ATTRIBUTES (decl
)))
2645 DECL_ATTRIBUTES (decl
) = NULL_TREE
;
2650 A C language linkage is ignored for the names of class members
2651 and the member function type of class member functions. */
2652 if (DECL_LANG_SPECIFIC (decl
) && DECL_LANGUAGE (decl
) == lang_c
)
2653 SET_DECL_LANGUAGE (decl
, lang_cplusplus
);
2655 /* Put functions on the TYPE_METHODS list and everything else on the
2656 TYPE_FIELDS list. Note that these are built up in reverse order.
2657 We reverse them (to obtain declaration order) in finish_struct. */
2658 if (TREE_CODE (decl
) == FUNCTION_DECL
2659 || DECL_FUNCTION_TEMPLATE_P (decl
))
2661 /* We also need to add this function to the
2662 CLASSTYPE_METHOD_VEC. */
2663 if (add_method (current_class_type
, decl
, NULL_TREE
))
2665 DECL_CHAIN (decl
) = TYPE_METHODS (current_class_type
);
2666 TYPE_METHODS (current_class_type
) = decl
;
2668 maybe_add_class_template_decl_list (current_class_type
, decl
,
2672 /* Enter the DECL into the scope of the class. */
2673 else if (pushdecl_class_level (decl
))
2675 if (TREE_CODE (decl
) == USING_DECL
)
2677 /* For now, ignore class-scope USING_DECLS, so that
2678 debugging backends do not see them. */
2679 DECL_IGNORED_P (decl
) = 1;
2682 /* All TYPE_DECLs go at the end of TYPE_FIELDS. Ordinary fields
2683 go at the beginning. The reason is that lookup_field_1
2684 searches the list in order, and we want a field name to
2685 override a type name so that the "struct stat hack" will
2686 work. In particular:
2688 struct S { enum E { }; int E } s;
2691 is valid. In addition, the FIELD_DECLs must be maintained in
2692 declaration order so that class layout works as expected.
2693 However, we don't need that order until class layout, so we
2694 save a little time by putting FIELD_DECLs on in reverse order
2695 here, and then reversing them in finish_struct_1. (We could
2696 also keep a pointer to the correct insertion points in the
2699 if (TREE_CODE (decl
) == TYPE_DECL
)
2700 TYPE_FIELDS (current_class_type
)
2701 = chainon (TYPE_FIELDS (current_class_type
), decl
);
2704 DECL_CHAIN (decl
) = TYPE_FIELDS (current_class_type
);
2705 TYPE_FIELDS (current_class_type
) = decl
;
2708 maybe_add_class_template_decl_list (current_class_type
, decl
,
2713 note_decl_for_pch (decl
);
2716 /* DECL has been declared while we are building a PCH file. Perform
2717 actions that we might normally undertake lazily, but which can be
2718 performed now so that they do not have to be performed in
2719 translation units which include the PCH file. */
2722 note_decl_for_pch (tree decl
)
2724 gcc_assert (pch_file
);
2726 /* There's a good chance that we'll have to mangle names at some
2727 point, even if only for emission in debugging information. */
2728 if ((TREE_CODE (decl
) == VAR_DECL
2729 || TREE_CODE (decl
) == FUNCTION_DECL
)
2730 && !processing_template_decl
)
2734 /* Finish processing a complete template declaration. The PARMS are
2735 the template parameters. */
2738 finish_template_decl (tree parms
)
2741 end_template_decl ();
2743 end_specialization ();
2746 /* Finish processing a template-id (which names a type) of the form
2747 NAME < ARGS >. Return the TYPE_DECL for the type named by the
2748 template-id. If ENTERING_SCOPE is nonzero we are about to enter
2749 the scope of template-id indicated. */
2752 finish_template_type (tree name
, tree args
, int entering_scope
)
2756 type
= lookup_template_class (name
, args
,
2757 NULL_TREE
, NULL_TREE
, entering_scope
,
2758 tf_warning_or_error
| tf_user
);
2759 if (type
== error_mark_node
)
2761 else if (CLASS_TYPE_P (type
) && !alias_type_or_template_p (type
))
2762 return TYPE_STUB_DECL (type
);
2764 return TYPE_NAME (type
);
2767 /* Finish processing a BASE_CLASS with the indicated ACCESS_SPECIFIER.
2768 Return a TREE_LIST containing the ACCESS_SPECIFIER and the
2769 BASE_CLASS, or NULL_TREE if an error occurred. The
2770 ACCESS_SPECIFIER is one of
2771 access_{default,public,protected_private}_node. For a virtual base
2772 we set TREE_TYPE. */
2775 finish_base_specifier (tree base
, tree access
, bool virtual_p
)
2779 if (base
== error_mark_node
)
2781 error ("invalid base-class specification");
2784 else if (! MAYBE_CLASS_TYPE_P (base
))
2786 error ("%qT is not a class type", base
);
2791 if (cp_type_quals (base
) != 0)
2793 /* DR 484: Can a base-specifier name a cv-qualified
2795 base
= TYPE_MAIN_VARIANT (base
);
2797 result
= build_tree_list (access
, base
);
2799 TREE_TYPE (result
) = integer_type_node
;
2805 /* If FNS is a member function, a set of member functions, or a
2806 template-id referring to one or more member functions, return a
2807 BASELINK for FNS, incorporating the current access context.
2808 Otherwise, return FNS unchanged. */
2811 baselink_for_fns (tree fns
)
2816 if (BASELINK_P (fns
)
2817 || error_operand_p (fns
))
2820 scope
= ovl_scope (fns
);
2821 if (!CLASS_TYPE_P (scope
))
2824 cl
= currently_open_derived_class (scope
);
2827 cl
= TYPE_BINFO (cl
);
2828 return build_baselink (cl
, cl
, fns
, /*optype=*/NULL_TREE
);
2831 /* Returns true iff DECL is an automatic variable from a function outside
2835 outer_automatic_var_p (tree decl
)
2837 return ((TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == PARM_DECL
)
2838 && DECL_FUNCTION_SCOPE_P (decl
)
2839 && !TREE_STATIC (decl
)
2840 && DECL_CONTEXT (decl
) != current_function_decl
);
2843 /* ID_EXPRESSION is a representation of parsed, but unprocessed,
2844 id-expression. (See cp_parser_id_expression for details.) SCOPE,
2845 if non-NULL, is the type or namespace used to explicitly qualify
2846 ID_EXPRESSION. DECL is the entity to which that name has been
2849 *CONSTANT_EXPRESSION_P is true if we are presently parsing a
2850 constant-expression. In that case, *NON_CONSTANT_EXPRESSION_P will
2851 be set to true if this expression isn't permitted in a
2852 constant-expression, but it is otherwise not set by this function.
2853 *ALLOW_NON_CONSTANT_EXPRESSION_P is true if we are parsing a
2854 constant-expression, but a non-constant expression is also
2857 DONE is true if this expression is a complete postfix-expression;
2858 it is false if this expression is followed by '->', '[', '(', etc.
2859 ADDRESS_P is true iff this expression is the operand of '&'.
2860 TEMPLATE_P is true iff the qualified-id was of the form
2861 "A::template B". TEMPLATE_ARG_P is true iff this qualified name
2862 appears as a template argument.
2864 If an error occurs, and it is the kind of error that might cause
2865 the parser to abort a tentative parse, *ERROR_MSG is filled in. It
2866 is the caller's responsibility to issue the message. *ERROR_MSG
2867 will be a string with static storage duration, so the caller need
2870 Return an expression for the entity, after issuing appropriate
2871 diagnostics. This function is also responsible for transforming a
2872 reference to a non-static member into a COMPONENT_REF that makes
2873 the use of "this" explicit.
2875 Upon return, *IDK will be filled in appropriately. */
2877 finish_id_expression (tree id_expression
,
2881 bool integral_constant_expression_p
,
2882 bool allow_non_integral_constant_expression_p
,
2883 bool *non_integral_constant_expression_p
,
2887 bool template_arg_p
,
2888 const char **error_msg
,
2889 location_t location
)
2891 decl
= strip_using_decl (decl
);
2893 /* Initialize the output parameters. */
2894 *idk
= CP_ID_KIND_NONE
;
2897 if (id_expression
== error_mark_node
)
2898 return error_mark_node
;
2899 /* If we have a template-id, then no further lookup is
2900 required. If the template-id was for a template-class, we
2901 will sometimes have a TYPE_DECL at this point. */
2902 else if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
2903 || TREE_CODE (decl
) == TYPE_DECL
)
2905 /* Look up the name. */
2908 if (decl
== error_mark_node
)
2910 /* Name lookup failed. */
2913 || (!dependent_type_p (scope
)
2914 && !(TREE_CODE (id_expression
) == IDENTIFIER_NODE
2915 && IDENTIFIER_TYPENAME_P (id_expression
)
2916 && dependent_type_p (TREE_TYPE (id_expression
))))))
2918 /* If the qualifying type is non-dependent (and the name
2919 does not name a conversion operator to a dependent
2920 type), issue an error. */
2921 qualified_name_lookup_error (scope
, id_expression
, decl
, location
);
2922 return error_mark_node
;
2926 /* It may be resolved via Koenig lookup. */
2927 *idk
= CP_ID_KIND_UNQUALIFIED
;
2928 return id_expression
;
2931 decl
= id_expression
;
2933 /* If DECL is a variable that would be out of scope under
2934 ANSI/ISO rules, but in scope in the ARM, name lookup
2935 will succeed. Issue a diagnostic here. */
2937 decl
= check_for_out_of_scope_variable (decl
);
2939 /* Remember that the name was used in the definition of
2940 the current class so that we can check later to see if
2941 the meaning would have been different after the class
2942 was entirely defined. */
2943 if (!scope
&& decl
!= error_mark_node
2944 && TREE_CODE (id_expression
) == IDENTIFIER_NODE
)
2945 maybe_note_name_used_in_class (id_expression
, decl
);
2947 /* Disallow uses of local variables from containing functions, except
2948 within lambda-expressions. */
2949 if (outer_automatic_var_p (decl
)
2950 /* It's not a use (3.2) if we're in an unevaluated context. */
2951 && !cp_unevaluated_operand
)
2953 tree context
= DECL_CONTEXT (decl
);
2954 tree containing_function
= current_function_decl
;
2955 tree lambda_stack
= NULL_TREE
;
2956 tree lambda_expr
= NULL_TREE
;
2957 tree initializer
= convert_from_reference (decl
);
2959 /* Mark it as used now even if the use is ill-formed. */
2962 /* Core issue 696: "[At the July 2009 meeting] the CWG expressed
2963 support for an approach in which a reference to a local
2964 [constant] automatic variable in a nested class or lambda body
2965 would enter the expression as an rvalue, which would reduce
2966 the complexity of the problem"
2968 FIXME update for final resolution of core issue 696. */
2969 if (decl_constant_var_p (decl
))
2970 return integral_constant_value (decl
);
2972 /* If we are in a lambda function, we can move out until we hit
2974 2. a non-lambda function, or
2975 3. a non-default capturing lambda function. */
2976 while (context
!= containing_function
2977 && LAMBDA_FUNCTION_P (containing_function
))
2979 lambda_expr
= CLASSTYPE_LAMBDA_EXPR
2980 (DECL_CONTEXT (containing_function
));
2982 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr
)
2986 lambda_stack
= tree_cons (NULL_TREE
,
2991 = decl_function_context (containing_function
);
2994 if (context
== containing_function
)
2996 decl
= add_default_capture (lambda_stack
,
2997 /*id=*/DECL_NAME (decl
),
3000 else if (lambda_expr
)
3002 error ("%qD is not captured", decl
);
3003 return error_mark_node
;
3007 error (TREE_CODE (decl
) == VAR_DECL
3008 ? G_("use of %<auto%> variable from containing function")
3009 : G_("use of parameter from containing function"));
3010 error (" %q+#D declared here", decl
);
3011 return error_mark_node
;
3015 /* Also disallow uses of function parameters outside the function
3016 body, except inside an unevaluated context (i.e. decltype). */
3017 if (TREE_CODE (decl
) == PARM_DECL
3018 && DECL_CONTEXT (decl
) == NULL_TREE
3019 && !cp_unevaluated_operand
)
3021 error ("use of parameter %qD outside function body", decl
);
3022 return error_mark_node
;
3026 /* If we didn't find anything, or what we found was a type,
3027 then this wasn't really an id-expression. */
3028 if (TREE_CODE (decl
) == TEMPLATE_DECL
3029 && !DECL_FUNCTION_TEMPLATE_P (decl
))
3031 *error_msg
= "missing template arguments";
3032 return error_mark_node
;
3034 else if (TREE_CODE (decl
) == TYPE_DECL
3035 || TREE_CODE (decl
) == NAMESPACE_DECL
)
3037 *error_msg
= "expected primary-expression";
3038 return error_mark_node
;
3041 /* If the name resolved to a template parameter, there is no
3042 need to look it up again later. */
3043 if ((TREE_CODE (decl
) == CONST_DECL
&& DECL_TEMPLATE_PARM_P (decl
))
3044 || TREE_CODE (decl
) == TEMPLATE_PARM_INDEX
)
3048 *idk
= CP_ID_KIND_NONE
;
3049 if (TREE_CODE (decl
) == TEMPLATE_PARM_INDEX
)
3050 decl
= TEMPLATE_PARM_DECL (decl
);
3051 r
= convert_from_reference (DECL_INITIAL (decl
));
3053 if (integral_constant_expression_p
3054 && !dependent_type_p (TREE_TYPE (decl
))
3055 && !(INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (r
))))
3057 if (!allow_non_integral_constant_expression_p
)
3058 error ("template parameter %qD of type %qT is not allowed in "
3059 "an integral constant expression because it is not of "
3060 "integral or enumeration type", decl
, TREE_TYPE (decl
));
3061 *non_integral_constant_expression_p
= true;
3069 /* If the declaration was explicitly qualified indicate
3070 that. The semantics of `A::f(3)' are different than
3071 `f(3)' if `f' is virtual. */
3073 ? CP_ID_KIND_QUALIFIED
3074 : (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
3075 ? CP_ID_KIND_TEMPLATE_ID
3076 : CP_ID_KIND_UNQUALIFIED
));
3081 An id-expression is type-dependent if it contains an
3082 identifier that was declared with a dependent type.
3084 The standard is not very specific about an id-expression that
3085 names a set of overloaded functions. What if some of them
3086 have dependent types and some of them do not? Presumably,
3087 such a name should be treated as a dependent name. */
3088 /* Assume the name is not dependent. */
3089 dependent_p
= false;
3090 if (!processing_template_decl
)
3091 /* No names are dependent outside a template. */
3093 else if (TREE_CODE (decl
) == CONST_DECL
)
3094 /* We don't want to treat enumerators as dependent. */
3096 /* A template-id where the name of the template was not resolved
3097 is definitely dependent. */
3098 else if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
3099 && (TREE_CODE (TREE_OPERAND (decl
, 0))
3100 == IDENTIFIER_NODE
))
3102 /* For anything except an overloaded function, just check its
3104 else if (!is_overloaded_fn (decl
))
3106 = dependent_type_p (TREE_TYPE (decl
));
3107 /* For a set of overloaded functions, check each of the
3113 if (BASELINK_P (fns
))
3114 fns
= BASELINK_FUNCTIONS (fns
);
3116 /* For a template-id, check to see if the template
3117 arguments are dependent. */
3118 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
3120 tree args
= TREE_OPERAND (fns
, 1);
3121 dependent_p
= any_dependent_template_arguments_p (args
);
3122 /* The functions are those referred to by the
3124 fns
= TREE_OPERAND (fns
, 0);
3127 /* If there are no dependent template arguments, go through
3128 the overloaded functions. */
3129 while (fns
&& !dependent_p
)
3131 tree fn
= OVL_CURRENT (fns
);
3133 /* Member functions of dependent classes are
3135 if (TREE_CODE (fn
) == FUNCTION_DECL
3136 && type_dependent_expression_p (fn
))
3138 else if (TREE_CODE (fn
) == TEMPLATE_DECL
3139 && dependent_template_p (fn
))
3142 fns
= OVL_NEXT (fns
);
3146 /* If the name was dependent on a template parameter, we will
3147 resolve the name at instantiation time. */
3150 /* Create a SCOPE_REF for qualified names, if the scope is
3156 if (address_p
&& done
)
3157 decl
= finish_qualified_id_expr (scope
, decl
,
3163 tree type
= NULL_TREE
;
3164 if (DECL_P (decl
) && !dependent_scope_p (scope
))
3165 type
= TREE_TYPE (decl
);
3166 decl
= build_qualified_name (type
,
3172 if (TREE_TYPE (decl
))
3173 decl
= convert_from_reference (decl
);
3176 /* A TEMPLATE_ID already contains all the information we
3178 if (TREE_CODE (id_expression
) == TEMPLATE_ID_EXPR
)
3179 return id_expression
;
3180 *idk
= CP_ID_KIND_UNQUALIFIED_DEPENDENT
;
3181 /* If we found a variable, then name lookup during the
3182 instantiation will always resolve to the same VAR_DECL
3183 (or an instantiation thereof). */
3184 if (TREE_CODE (decl
) == VAR_DECL
3185 || TREE_CODE (decl
) == PARM_DECL
)
3188 return convert_from_reference (decl
);
3190 /* The same is true for FIELD_DECL, but we also need to
3191 make sure that the syntax is correct. */
3192 else if (TREE_CODE (decl
) == FIELD_DECL
)
3194 /* Since SCOPE is NULL here, this is an unqualified name.
3195 Access checking has been performed during name lookup
3196 already. Turn off checking to avoid duplicate errors. */
3197 push_deferring_access_checks (dk_no_check
);
3198 decl
= finish_non_static_data_member
3200 /*qualifying_scope=*/NULL_TREE
);
3201 pop_deferring_access_checks ();
3204 return id_expression
;
3207 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
3209 error ("use of namespace %qD as expression", decl
);
3210 return error_mark_node
;
3212 else if (DECL_CLASS_TEMPLATE_P (decl
))
3214 error ("use of class template %qT as expression", decl
);
3215 return error_mark_node
;
3217 else if (TREE_CODE (decl
) == TREE_LIST
)
3219 /* Ambiguous reference to base members. */
3220 error ("request for member %qD is ambiguous in "
3221 "multiple inheritance lattice", id_expression
);
3222 print_candidates (decl
);
3223 return error_mark_node
;
3226 /* Mark variable-like entities as used. Functions are similarly
3227 marked either below or after overload resolution. */
3228 if (TREE_CODE (decl
) == VAR_DECL
3229 || TREE_CODE (decl
) == PARM_DECL
3230 || TREE_CODE (decl
) == CONST_DECL
3231 || TREE_CODE (decl
) == RESULT_DECL
)
3234 /* Only certain kinds of names are allowed in constant
3235 expression. Template parameters have already
3236 been handled above. */
3237 if (! error_operand_p (decl
)
3238 && integral_constant_expression_p
3239 && ! decl_constant_var_p (decl
)
3240 && TREE_CODE (decl
) != CONST_DECL
3241 && ! builtin_valid_in_constant_expr_p (decl
))
3243 if (!allow_non_integral_constant_expression_p
)
3245 error ("%qD cannot appear in a constant-expression", decl
);
3246 return error_mark_node
;
3248 *non_integral_constant_expression_p
= true;
3253 decl
= (adjust_result_of_qualified_name_lookup
3254 (decl
, scope
, current_nonlambda_class_type()));
3256 if (TREE_CODE (decl
) == FUNCTION_DECL
)
3259 if (TREE_CODE (decl
) == FIELD_DECL
|| BASELINK_P (decl
))
3260 decl
= finish_qualified_id_expr (scope
,
3268 tree r
= convert_from_reference (decl
);
3270 /* In a template, return a SCOPE_REF for most qualified-ids
3271 so that we can check access at instantiation time. But if
3272 we're looking at a member of the current instantiation, we
3273 know we have access and building up the SCOPE_REF confuses
3274 non-type template argument handling. */
3275 if (processing_template_decl
&& TYPE_P (scope
)
3276 && !currently_open_class (scope
))
3277 r
= build_qualified_name (TREE_TYPE (r
),
3283 else if (TREE_CODE (decl
) == FIELD_DECL
)
3285 /* Since SCOPE is NULL here, this is an unqualified name.
3286 Access checking has been performed during name lookup
3287 already. Turn off checking to avoid duplicate errors. */
3288 push_deferring_access_checks (dk_no_check
);
3289 decl
= finish_non_static_data_member (decl
, NULL_TREE
,
3290 /*qualifying_scope=*/NULL_TREE
);
3291 pop_deferring_access_checks ();
3293 else if (is_overloaded_fn (decl
))
3297 first_fn
= get_first_fn (decl
);
3298 if (TREE_CODE (first_fn
) == TEMPLATE_DECL
)
3299 first_fn
= DECL_TEMPLATE_RESULT (first_fn
);
3301 if (!really_overloaded_fn (decl
)
3302 && !mark_used (first_fn
))
3303 return error_mark_node
;
3306 && TREE_CODE (first_fn
) == FUNCTION_DECL
3307 && DECL_FUNCTION_MEMBER_P (first_fn
)
3308 && !shared_member_p (decl
))
3310 /* A set of member functions. */
3311 decl
= maybe_dummy_object (DECL_CONTEXT (first_fn
), 0);
3312 return finish_class_member_access_expr (decl
, id_expression
,
3313 /*template_p=*/false,
3314 tf_warning_or_error
);
3317 decl
= baselink_for_fns (decl
);
3321 if (DECL_P (decl
) && DECL_NONLOCAL (decl
)
3322 && DECL_CLASS_SCOPE_P (decl
))
3324 tree context
= context_for_name_lookup (decl
);
3325 if (context
!= current_class_type
)
3327 tree path
= currently_open_derived_class (context
);
3328 perform_or_defer_access_check (TYPE_BINFO (path
),
3333 decl
= convert_from_reference (decl
);
3337 if (TREE_DEPRECATED (decl
))
3338 warn_deprecated_use (decl
, NULL_TREE
);
3343 /* Implement the __typeof keyword: Return the type of EXPR, suitable for
3344 use as a type-specifier. */
3347 finish_typeof (tree expr
)
3351 if (type_dependent_expression_p (expr
))
3353 type
= cxx_make_type (TYPEOF_TYPE
);
3354 TYPEOF_TYPE_EXPR (type
) = expr
;
3355 SET_TYPE_STRUCTURAL_EQUALITY (type
);
3360 expr
= mark_type_use (expr
);
3362 type
= unlowered_expr_type (expr
);
3364 if (!type
|| type
== unknown_type_node
)
3366 error ("type of %qE is unknown", expr
);
3367 return error_mark_node
;
3373 /* Implement the __underlying_type keyword: Return the underlying
3374 type of TYPE, suitable for use as a type-specifier. */
3377 finish_underlying_type (tree type
)
3379 tree underlying_type
;
3381 if (processing_template_decl
)
3383 underlying_type
= cxx_make_type (UNDERLYING_TYPE
);
3384 UNDERLYING_TYPE_TYPE (underlying_type
) = type
;
3385 SET_TYPE_STRUCTURAL_EQUALITY (underlying_type
);
3387 return underlying_type
;
3390 complete_type (type
);
3392 if (TREE_CODE (type
) != ENUMERAL_TYPE
)
3394 error ("%qT is not an enumeration type", type
);
3395 return error_mark_node
;
3398 underlying_type
= ENUM_UNDERLYING_TYPE (type
);
3400 /* Fixup necessary in this case because ENUM_UNDERLYING_TYPE
3401 includes TYPE_MIN_VALUE and TYPE_MAX_VALUE information.
3402 See finish_enum_value_list for details. */
3403 if (!ENUM_FIXED_UNDERLYING_TYPE_P (type
))
3405 = c_common_type_for_mode (TYPE_MODE (underlying_type
),
3406 TYPE_UNSIGNED (underlying_type
));
3408 return underlying_type
;
3411 /* Implement the __direct_bases keyword: Return the direct base classes
3415 calculate_direct_bases (tree type
)
3417 VEC(tree
, gc
) *vector
= make_tree_vector();
3418 tree bases_vec
= NULL_TREE
;
3419 VEC(tree
, none
) *base_binfos
;
3423 complete_type (type
);
3425 if (!NON_UNION_CLASS_TYPE_P (type
))
3426 return make_tree_vec (0);
3428 base_binfos
= BINFO_BASE_BINFOS (TYPE_BINFO (type
));
3430 /* Virtual bases are initialized first */
3431 for (i
= 0; VEC_iterate (tree
, base_binfos
, i
, binfo
); i
++)
3433 if (BINFO_VIRTUAL_P (binfo
))
3435 VEC_safe_push (tree
, gc
, vector
, binfo
);
3439 /* Now non-virtuals */
3440 for (i
= 0; VEC_iterate (tree
, base_binfos
, i
, binfo
); i
++)
3442 if (!BINFO_VIRTUAL_P (binfo
))
3444 VEC_safe_push (tree
, gc
, vector
, binfo
);
3449 bases_vec
= make_tree_vec (VEC_length (tree
, vector
));
3451 for (i
= 0; i
< VEC_length (tree
, vector
); ++i
)
3453 TREE_VEC_ELT (bases_vec
, i
) = BINFO_TYPE (VEC_index (tree
, vector
, i
));
3458 /* Implement the __bases keyword: Return the base classes
3461 /* Find morally non-virtual base classes by walking binfo hierarchy */
3462 /* Virtual base classes are handled separately in finish_bases */
3465 dfs_calculate_bases_pre (tree binfo
, ATTRIBUTE_UNUSED
void *data_
)
3467 /* Don't walk bases of virtual bases */
3468 return BINFO_VIRTUAL_P (binfo
) ? dfs_skip_bases
: NULL_TREE
;
3472 dfs_calculate_bases_post (tree binfo
, void *data_
)
3474 VEC(tree
, gc
) **data
= (VEC(tree
, gc
) **) data_
;
3475 if (!BINFO_VIRTUAL_P (binfo
))
3477 VEC_safe_push (tree
, gc
, *data
, BINFO_TYPE (binfo
));
3482 /* Calculates the morally non-virtual base classes of a class */
3483 static VEC(tree
, gc
) *
3484 calculate_bases_helper (tree type
)
3486 VEC(tree
, gc
) *vector
= make_tree_vector();
3488 /* Now add non-virtual base classes in order of construction */
3489 dfs_walk_all (TYPE_BINFO (type
),
3490 dfs_calculate_bases_pre
, dfs_calculate_bases_post
, &vector
);
3495 calculate_bases (tree type
)
3497 VEC(tree
, gc
) *vector
= make_tree_vector();
3498 tree bases_vec
= NULL_TREE
;
3500 VEC(tree
, gc
) *vbases
;
3501 VEC(tree
, gc
) *nonvbases
;
3504 complete_type (type
);
3506 if (!NON_UNION_CLASS_TYPE_P (type
))
3507 return make_tree_vec (0);
3509 /* First go through virtual base classes */
3510 for (vbases
= CLASSTYPE_VBASECLASSES (type
), i
= 0;
3511 VEC_iterate (tree
, vbases
, i
, binfo
); i
++)
3513 VEC(tree
, gc
) *vbase_bases
= calculate_bases_helper (BINFO_TYPE (binfo
));
3514 VEC_safe_splice (tree
, gc
, vector
, vbase_bases
);
3515 release_tree_vector (vbase_bases
);
3518 /* Now for the non-virtual bases */
3519 nonvbases
= calculate_bases_helper (type
);
3520 VEC_safe_splice (tree
, gc
, vector
, nonvbases
);
3521 release_tree_vector (nonvbases
);
3523 /* Last element is entire class, so don't copy */
3524 bases_vec
= make_tree_vec (VEC_length (tree
, vector
) - 1);
3526 for (i
= 0; i
< VEC_length (tree
, vector
) - 1; ++i
)
3528 TREE_VEC_ELT (bases_vec
, i
) = VEC_index (tree
, vector
, i
);
3530 release_tree_vector (vector
);
3535 finish_bases (tree type
, bool direct
)
3537 tree bases
= NULL_TREE
;
3539 if (!processing_template_decl
)
3541 /* Parameter packs can only be used in templates */
3542 error ("Parameter pack __bases only valid in template declaration");
3543 return error_mark_node
;
3546 bases
= cxx_make_type (BASES
);
3547 BASES_TYPE (bases
) = type
;
3548 BASES_DIRECT (bases
) = direct
;
3549 SET_TYPE_STRUCTURAL_EQUALITY (bases
);
3554 /* Perform C++-specific checks for __builtin_offsetof before calling
3558 finish_offsetof (tree expr
)
3560 if (TREE_CODE (expr
) == PSEUDO_DTOR_EXPR
)
3562 error ("cannot apply %<offsetof%> to destructor %<~%T%>",
3563 TREE_OPERAND (expr
, 2));
3564 return error_mark_node
;
3566 if (TREE_CODE (TREE_TYPE (expr
)) == FUNCTION_TYPE
3567 || TREE_CODE (TREE_TYPE (expr
)) == METHOD_TYPE
3568 || TREE_TYPE (expr
) == unknown_type_node
)
3570 if (TREE_CODE (expr
) == COMPONENT_REF
3571 || TREE_CODE (expr
) == COMPOUND_EXPR
)
3572 expr
= TREE_OPERAND (expr
, 1);
3573 error ("cannot apply %<offsetof%> to member function %qD", expr
);
3574 return error_mark_node
;
3576 if (REFERENCE_REF_P (expr
))
3577 expr
= TREE_OPERAND (expr
, 0);
3578 if (TREE_CODE (expr
) == COMPONENT_REF
)
3580 tree object
= TREE_OPERAND (expr
, 0);
3581 if (!complete_type_or_else (TREE_TYPE (object
), object
))
3582 return error_mark_node
;
3584 return fold_offsetof (expr
);
3587 /* Replace the AGGR_INIT_EXPR at *TP with an equivalent CALL_EXPR. This
3588 function is broken out from the above for the benefit of the tree-ssa
3592 simplify_aggr_init_expr (tree
*tp
)
3594 tree aggr_init_expr
= *tp
;
3596 /* Form an appropriate CALL_EXPR. */
3597 tree fn
= AGGR_INIT_EXPR_FN (aggr_init_expr
);
3598 tree slot
= AGGR_INIT_EXPR_SLOT (aggr_init_expr
);
3599 tree type
= TREE_TYPE (slot
);
3602 enum style_t
{ ctor
, arg
, pcc
} style
;
3604 if (AGGR_INIT_VIA_CTOR_P (aggr_init_expr
))
3606 #ifdef PCC_STATIC_STRUCT_RETURN
3612 gcc_assert (TREE_ADDRESSABLE (type
));
3616 call_expr
= build_call_array_loc (input_location
,
3617 TREE_TYPE (TREE_TYPE (TREE_TYPE (fn
))),
3619 aggr_init_expr_nargs (aggr_init_expr
),
3620 AGGR_INIT_EXPR_ARGP (aggr_init_expr
));
3621 TREE_NOTHROW (call_expr
) = TREE_NOTHROW (aggr_init_expr
);
3625 /* Replace the first argument to the ctor with the address of the
3627 cxx_mark_addressable (slot
);
3628 CALL_EXPR_ARG (call_expr
, 0) =
3629 build1 (ADDR_EXPR
, build_pointer_type (type
), slot
);
3631 else if (style
== arg
)
3633 /* Just mark it addressable here, and leave the rest to
3634 expand_call{,_inline}. */
3635 cxx_mark_addressable (slot
);
3636 CALL_EXPR_RETURN_SLOT_OPT (call_expr
) = true;
3637 call_expr
= build2 (INIT_EXPR
, TREE_TYPE (call_expr
), slot
, call_expr
);
3639 else if (style
== pcc
)
3641 /* If we're using the non-reentrant PCC calling convention, then we
3642 need to copy the returned value out of the static buffer into the
3644 push_deferring_access_checks (dk_no_check
);
3645 call_expr
= build_aggr_init (slot
, call_expr
,
3646 DIRECT_BIND
| LOOKUP_ONLYCONVERTING
,
3647 tf_warning_or_error
);
3648 pop_deferring_access_checks ();
3649 call_expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (slot
), call_expr
, slot
);
3652 if (AGGR_INIT_ZERO_FIRST (aggr_init_expr
))
3654 tree init
= build_zero_init (type
, NULL_TREE
,
3655 /*static_storage_p=*/false);
3656 init
= build2 (INIT_EXPR
, void_type_node
, slot
, init
);
3657 call_expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (call_expr
),
3664 /* Emit all thunks to FN that should be emitted when FN is emitted. */
3667 emit_associated_thunks (tree fn
)
3669 /* When we use vcall offsets, we emit thunks with the virtual
3670 functions to which they thunk. The whole point of vcall offsets
3671 is so that you can know statically the entire set of thunks that
3672 will ever be needed for a given virtual function, thereby
3673 enabling you to output all the thunks with the function itself. */
3674 if (DECL_VIRTUAL_P (fn
)
3675 /* Do not emit thunks for extern template instantiations. */
3676 && ! DECL_REALLY_EXTERN (fn
))
3680 for (thunk
= DECL_THUNKS (fn
); thunk
; thunk
= DECL_CHAIN (thunk
))
3682 if (!THUNK_ALIAS (thunk
))
3684 use_thunk (thunk
, /*emit_p=*/1);
3685 if (DECL_RESULT_THUNK_P (thunk
))
3689 for (probe
= DECL_THUNKS (thunk
);
3690 probe
; probe
= DECL_CHAIN (probe
))
3691 use_thunk (probe
, /*emit_p=*/1);
3695 gcc_assert (!DECL_THUNKS (thunk
));
3700 /* Returns true iff FUN is an instantiation of a constexpr function
3704 is_instantiation_of_constexpr (tree fun
)
3706 return (DECL_TEMPLOID_INSTANTIATION (fun
)
3707 && DECL_DECLARED_CONSTEXPR_P (DECL_TEMPLATE_RESULT
3708 (DECL_TI_TEMPLATE (fun
))));
3711 /* Generate RTL for FN. */
3714 expand_or_defer_fn_1 (tree fn
)
3716 /* When the parser calls us after finishing the body of a template
3717 function, we don't really want to expand the body. */
3718 if (processing_template_decl
)
3720 /* Normally, collection only occurs in rest_of_compilation. So,
3721 if we don't collect here, we never collect junk generated
3722 during the processing of templates until we hit a
3723 non-template function. It's not safe to do this inside a
3724 nested class, though, as the parser may have local state that
3725 is not a GC root. */
3726 if (!function_depth
)
3731 gcc_assert (DECL_SAVED_TREE (fn
));
3733 /* If this is a constructor or destructor body, we have to clone
3735 if (maybe_clone_body (fn
))
3737 /* We don't want to process FN again, so pretend we've written
3738 it out, even though we haven't. */
3739 TREE_ASM_WRITTEN (fn
) = 1;
3740 /* If this is an instantiation of a constexpr function, keep
3741 DECL_SAVED_TREE for explain_invalid_constexpr_fn. */
3742 if (!is_instantiation_of_constexpr (fn
))
3743 DECL_SAVED_TREE (fn
) = NULL_TREE
;
3747 /* We make a decision about linkage for these functions at the end
3748 of the compilation. Until that point, we do not want the back
3749 end to output them -- but we do want it to see the bodies of
3750 these functions so that it can inline them as appropriate. */
3751 if (DECL_DECLARED_INLINE_P (fn
) || DECL_IMPLICIT_INSTANTIATION (fn
))
3753 if (DECL_INTERFACE_KNOWN (fn
))
3754 /* We've already made a decision as to how this function will
3758 DECL_EXTERNAL (fn
) = 1;
3759 DECL_NOT_REALLY_EXTERN (fn
) = 1;
3760 note_vague_linkage_fn (fn
);
3761 /* A non-template inline function with external linkage will
3762 always be COMDAT. As we must eventually determine the
3763 linkage of all functions, and as that causes writes to
3764 the data mapped in from the PCH file, it's advantageous
3765 to mark the functions at this point. */
3766 if (!DECL_IMPLICIT_INSTANTIATION (fn
))
3768 /* This function must have external linkage, as
3769 otherwise DECL_INTERFACE_KNOWN would have been
3771 gcc_assert (TREE_PUBLIC (fn
));
3772 comdat_linkage (fn
);
3773 DECL_INTERFACE_KNOWN (fn
) = 1;
3777 import_export_decl (fn
);
3779 /* If the user wants us to keep all inline functions, then mark
3780 this function as needed so that finish_file will make sure to
3781 output it later. Similarly, all dllexport'd functions must
3782 be emitted; there may be callers in other DLLs. */
3783 if ((flag_keep_inline_functions
3784 && DECL_DECLARED_INLINE_P (fn
)
3785 && !DECL_REALLY_EXTERN (fn
))
3786 || (flag_keep_inline_dllexport
3787 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (fn
))))
3790 DECL_EXTERNAL (fn
) = 0;
3794 /* There's no reason to do any of the work here if we're only doing
3795 semantic analysis; this code just generates RTL. */
3796 if (flag_syntax_only
)
3803 expand_or_defer_fn (tree fn
)
3805 if (expand_or_defer_fn_1 (fn
))
3809 /* Expand or defer, at the whim of the compilation unit manager. */
3810 cgraph_finalize_function (fn
, function_depth
> 1);
3811 emit_associated_thunks (fn
);
3824 /* Helper function for walk_tree, used by finalize_nrv below. */
3827 finalize_nrv_r (tree
* tp
, int* walk_subtrees
, void* data
)
3829 struct nrv_data
*dp
= (struct nrv_data
*)data
;
3832 /* No need to walk into types. There wouldn't be any need to walk into
3833 non-statements, except that we have to consider STMT_EXPRs. */
3836 /* Change all returns to just refer to the RESULT_DECL; this is a nop,
3837 but differs from using NULL_TREE in that it indicates that we care
3838 about the value of the RESULT_DECL. */
3839 else if (TREE_CODE (*tp
) == RETURN_EXPR
)
3840 TREE_OPERAND (*tp
, 0) = dp
->result
;
3841 /* Change all cleanups for the NRV to only run when an exception is
3843 else if (TREE_CODE (*tp
) == CLEANUP_STMT
3844 && CLEANUP_DECL (*tp
) == dp
->var
)
3845 CLEANUP_EH_ONLY (*tp
) = 1;
3846 /* Replace the DECL_EXPR for the NRV with an initialization of the
3847 RESULT_DECL, if needed. */
3848 else if (TREE_CODE (*tp
) == DECL_EXPR
3849 && DECL_EXPR_DECL (*tp
) == dp
->var
)
3852 if (DECL_INITIAL (dp
->var
)
3853 && DECL_INITIAL (dp
->var
) != error_mark_node
)
3854 init
= build2 (INIT_EXPR
, void_type_node
, dp
->result
,
3855 DECL_INITIAL (dp
->var
));
3857 init
= build_empty_stmt (EXPR_LOCATION (*tp
));
3858 DECL_INITIAL (dp
->var
) = NULL_TREE
;
3859 SET_EXPR_LOCATION (init
, EXPR_LOCATION (*tp
));
3862 /* And replace all uses of the NRV with the RESULT_DECL. */
3863 else if (*tp
== dp
->var
)
3866 /* Avoid walking into the same tree more than once. Unfortunately, we
3867 can't just use walk_tree_without duplicates because it would only call
3868 us for the first occurrence of dp->var in the function body. */
3869 slot
= htab_find_slot (dp
->visited
, *tp
, INSERT
);
3875 /* Keep iterating. */
3879 /* Called from finish_function to implement the named return value
3880 optimization by overriding all the RETURN_EXPRs and pertinent
3881 CLEANUP_STMTs and replacing all occurrences of VAR with RESULT, the
3882 RESULT_DECL for the function. */
3885 finalize_nrv (tree
*tp
, tree var
, tree result
)
3887 struct nrv_data data
;
3889 /* Copy name from VAR to RESULT. */
3890 DECL_NAME (result
) = DECL_NAME (var
);
3891 /* Don't forget that we take its address. */
3892 TREE_ADDRESSABLE (result
) = TREE_ADDRESSABLE (var
);
3893 /* Finally set DECL_VALUE_EXPR to avoid assigning
3894 a stack slot at -O0 for the original var and debug info
3895 uses RESULT location for VAR. */
3896 SET_DECL_VALUE_EXPR (var
, result
);
3897 DECL_HAS_VALUE_EXPR_P (var
) = 1;
3900 data
.result
= result
;
3901 data
.visited
= htab_create (37, htab_hash_pointer
, htab_eq_pointer
, NULL
);
3902 cp_walk_tree (tp
, finalize_nrv_r
, &data
, 0);
3903 htab_delete (data
.visited
);
3906 /* Create CP_OMP_CLAUSE_INFO for clause C. Returns true if it is invalid. */
3909 cxx_omp_create_clause_info (tree c
, tree type
, bool need_default_ctor
,
3910 bool need_copy_ctor
, bool need_copy_assignment
)
3912 int save_errorcount
= errorcount
;
3915 /* Always allocate 3 elements for simplicity. These are the
3916 function decls for the ctor, dtor, and assignment op.
3917 This layout is known to the three lang hooks,
3918 cxx_omp_clause_default_init, cxx_omp_clause_copy_init,
3919 and cxx_omp_clause_assign_op. */
3920 info
= make_tree_vec (3);
3921 CP_OMP_CLAUSE_INFO (c
) = info
;
3923 if (need_default_ctor
|| need_copy_ctor
)
3925 if (need_default_ctor
)
3926 t
= get_default_ctor (type
);
3928 t
= get_copy_ctor (type
, tf_warning_or_error
);
3930 if (t
&& !trivial_fn_p (t
))
3931 TREE_VEC_ELT (info
, 0) = t
;
3934 if ((need_default_ctor
|| need_copy_ctor
)
3935 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
3936 TREE_VEC_ELT (info
, 1) = get_dtor (type
, tf_warning_or_error
);
3938 if (need_copy_assignment
)
3940 t
= get_copy_assign (type
);
3942 if (t
&& !trivial_fn_p (t
))
3943 TREE_VEC_ELT (info
, 2) = t
;
3946 return errorcount
!= save_errorcount
;
3949 /* For all elements of CLAUSES, validate them vs OpenMP constraints.
3950 Remove any elements from the list that are invalid. */
3953 finish_omp_clauses (tree clauses
)
3955 bitmap_head generic_head
, firstprivate_head
, lastprivate_head
;
3956 tree c
, t
, *pc
= &clauses
;
3959 bitmap_obstack_initialize (NULL
);
3960 bitmap_initialize (&generic_head
, &bitmap_default_obstack
);
3961 bitmap_initialize (&firstprivate_head
, &bitmap_default_obstack
);
3962 bitmap_initialize (&lastprivate_head
, &bitmap_default_obstack
);
3964 for (pc
= &clauses
, c
= clauses
; c
; c
= *pc
)
3966 bool remove
= false;
3968 switch (OMP_CLAUSE_CODE (c
))
3970 case OMP_CLAUSE_SHARED
:
3972 goto check_dup_generic
;
3973 case OMP_CLAUSE_PRIVATE
:
3975 goto check_dup_generic
;
3976 case OMP_CLAUSE_REDUCTION
:
3978 goto check_dup_generic
;
3979 case OMP_CLAUSE_COPYPRIVATE
:
3980 name
= "copyprivate";
3981 goto check_dup_generic
;
3982 case OMP_CLAUSE_COPYIN
:
3984 goto check_dup_generic
;
3986 t
= OMP_CLAUSE_DECL (c
);
3987 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
3989 if (processing_template_decl
)
3992 error ("%qD is not a variable in clause %qs", t
, name
);
3994 error ("%qE is not a variable in clause %qs", t
, name
);
3997 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
3998 || bitmap_bit_p (&firstprivate_head
, DECL_UID (t
))
3999 || bitmap_bit_p (&lastprivate_head
, DECL_UID (t
)))
4001 error ("%qD appears more than once in data clauses", t
);
4005 bitmap_set_bit (&generic_head
, DECL_UID (t
));
4008 case OMP_CLAUSE_FIRSTPRIVATE
:
4009 t
= OMP_CLAUSE_DECL (c
);
4010 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
4012 if (processing_template_decl
)
4015 error ("%qD is not a variable in clause %<firstprivate%>", t
);
4017 error ("%qE is not a variable in clause %<firstprivate%>", t
);
4020 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
4021 || bitmap_bit_p (&firstprivate_head
, DECL_UID (t
)))
4023 error ("%qD appears more than once in data clauses", t
);
4027 bitmap_set_bit (&firstprivate_head
, DECL_UID (t
));
4030 case OMP_CLAUSE_LASTPRIVATE
:
4031 t
= OMP_CLAUSE_DECL (c
);
4032 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
4034 if (processing_template_decl
)
4037 error ("%qD is not a variable in clause %<lastprivate%>", t
);
4039 error ("%qE is not a variable in clause %<lastprivate%>", t
);
4042 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
4043 || bitmap_bit_p (&lastprivate_head
, DECL_UID (t
)))
4045 error ("%qD appears more than once in data clauses", t
);
4049 bitmap_set_bit (&lastprivate_head
, DECL_UID (t
));
4053 t
= OMP_CLAUSE_IF_EXPR (c
);
4054 t
= maybe_convert_cond (t
);
4055 if (t
== error_mark_node
)
4057 else if (!processing_template_decl
)
4058 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4059 OMP_CLAUSE_IF_EXPR (c
) = t
;
4062 case OMP_CLAUSE_FINAL
:
4063 t
= OMP_CLAUSE_FINAL_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_FINAL_EXPR (c
) = t
;
4072 case OMP_CLAUSE_NUM_THREADS
:
4073 t
= OMP_CLAUSE_NUM_THREADS_EXPR (c
);
4074 if (t
== error_mark_node
)
4076 else if (!type_dependent_expression_p (t
)
4077 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
4079 error ("num_threads expression must be integral");
4084 t
= mark_rvalue_use (t
);
4085 if (!processing_template_decl
)
4086 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4087 OMP_CLAUSE_NUM_THREADS_EXPR (c
) = t
;
4091 case OMP_CLAUSE_SCHEDULE
:
4092 t
= OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c
);
4095 else if (t
== error_mark_node
)
4097 else if (!type_dependent_expression_p (t
)
4098 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
4100 error ("schedule chunk size expression must be integral");
4105 t
= mark_rvalue_use (t
);
4106 if (!processing_template_decl
)
4107 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4108 OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c
) = t
;
4112 case OMP_CLAUSE_NOWAIT
:
4113 case OMP_CLAUSE_ORDERED
:
4114 case OMP_CLAUSE_DEFAULT
:
4115 case OMP_CLAUSE_UNTIED
:
4116 case OMP_CLAUSE_COLLAPSE
:
4117 case OMP_CLAUSE_MERGEABLE
:
4125 *pc
= OMP_CLAUSE_CHAIN (c
);
4127 pc
= &OMP_CLAUSE_CHAIN (c
);
4130 for (pc
= &clauses
, c
= clauses
; c
; c
= *pc
)
4132 enum omp_clause_code c_kind
= OMP_CLAUSE_CODE (c
);
4133 bool remove
= false;
4134 bool need_complete_non_reference
= false;
4135 bool need_default_ctor
= false;
4136 bool need_copy_ctor
= false;
4137 bool need_copy_assignment
= false;
4138 bool need_implicitly_determined
= false;
4139 tree type
, inner_type
;
4143 case OMP_CLAUSE_SHARED
:
4145 need_implicitly_determined
= true;
4147 case OMP_CLAUSE_PRIVATE
:
4149 need_complete_non_reference
= true;
4150 need_default_ctor
= true;
4151 need_implicitly_determined
= true;
4153 case OMP_CLAUSE_FIRSTPRIVATE
:
4154 name
= "firstprivate";
4155 need_complete_non_reference
= true;
4156 need_copy_ctor
= true;
4157 need_implicitly_determined
= true;
4159 case OMP_CLAUSE_LASTPRIVATE
:
4160 name
= "lastprivate";
4161 need_complete_non_reference
= true;
4162 need_copy_assignment
= true;
4163 need_implicitly_determined
= true;
4165 case OMP_CLAUSE_REDUCTION
:
4167 need_implicitly_determined
= true;
4169 case OMP_CLAUSE_COPYPRIVATE
:
4170 name
= "copyprivate";
4171 need_copy_assignment
= true;
4173 case OMP_CLAUSE_COPYIN
:
4175 need_copy_assignment
= true;
4178 pc
= &OMP_CLAUSE_CHAIN (c
);
4182 t
= OMP_CLAUSE_DECL (c
);
4183 if (processing_template_decl
4184 && TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
4186 pc
= &OMP_CLAUSE_CHAIN (c
);
4192 case OMP_CLAUSE_LASTPRIVATE
:
4193 if (!bitmap_bit_p (&firstprivate_head
, DECL_UID (t
)))
4194 need_default_ctor
= true;
4197 case OMP_CLAUSE_REDUCTION
:
4198 if (AGGREGATE_TYPE_P (TREE_TYPE (t
))
4199 || POINTER_TYPE_P (TREE_TYPE (t
)))
4201 error ("%qE has invalid type for %<reduction%>", t
);
4204 else if (FLOAT_TYPE_P (TREE_TYPE (t
)))
4206 enum tree_code r_code
= OMP_CLAUSE_REDUCTION_CODE (c
);
4216 error ("%qE has invalid type for %<reduction(%s)%>",
4217 t
, operator_name_info
[r_code
].name
);
4223 case OMP_CLAUSE_COPYIN
:
4224 if (TREE_CODE (t
) != VAR_DECL
|| !DECL_THREAD_LOCAL_P (t
))
4226 error ("%qE must be %<threadprivate%> for %<copyin%>", t
);
4235 if (need_complete_non_reference
|| need_copy_assignment
)
4237 t
= require_complete_type (t
);
4238 if (t
== error_mark_node
)
4240 else if (TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
4241 && need_complete_non_reference
)
4243 error ("%qE has reference type for %qs", t
, name
);
4247 if (need_implicitly_determined
)
4249 const char *share_name
= NULL
;
4251 if (TREE_CODE (t
) == VAR_DECL
&& DECL_THREAD_LOCAL_P (t
))
4252 share_name
= "threadprivate";
4253 else switch (cxx_omp_predetermined_sharing (t
))
4255 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
4257 case OMP_CLAUSE_DEFAULT_SHARED
:
4258 /* const vars may be specified in firstprivate clause. */
4259 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
4260 && cxx_omp_const_qual_no_mutable (t
))
4262 share_name
= "shared";
4264 case OMP_CLAUSE_DEFAULT_PRIVATE
:
4265 share_name
= "private";
4272 error ("%qE is predetermined %qs for %qs",
4273 t
, share_name
, name
);
4278 /* We're interested in the base element, not arrays. */
4279 inner_type
= type
= TREE_TYPE (t
);
4280 while (TREE_CODE (inner_type
) == ARRAY_TYPE
)
4281 inner_type
= TREE_TYPE (inner_type
);
4283 /* Check for special function availability by building a call to one.
4284 Save the results, because later we won't be in the right context
4285 for making these queries. */
4286 if (CLASS_TYPE_P (inner_type
)
4287 && COMPLETE_TYPE_P (inner_type
)
4288 && (need_default_ctor
|| need_copy_ctor
|| need_copy_assignment
)
4289 && !type_dependent_expression_p (t
)
4290 && cxx_omp_create_clause_info (c
, inner_type
, need_default_ctor
,
4291 need_copy_ctor
, need_copy_assignment
))
4295 *pc
= OMP_CLAUSE_CHAIN (c
);
4297 pc
= &OMP_CLAUSE_CHAIN (c
);
4300 bitmap_obstack_release (NULL
);
4304 /* For all variables in the tree_list VARS, mark them as thread local. */
4307 finish_omp_threadprivate (tree vars
)
4311 /* Mark every variable in VARS to be assigned thread local storage. */
4312 for (t
= vars
; t
; t
= TREE_CHAIN (t
))
4314 tree v
= TREE_PURPOSE (t
);
4316 if (error_operand_p (v
))
4318 else if (TREE_CODE (v
) != VAR_DECL
)
4319 error ("%<threadprivate%> %qD is not file, namespace "
4320 "or block scope variable", v
);
4321 /* If V had already been marked threadprivate, it doesn't matter
4322 whether it had been used prior to this point. */
4323 else if (TREE_USED (v
)
4324 && (DECL_LANG_SPECIFIC (v
) == NULL
4325 || !CP_DECL_THREADPRIVATE_P (v
)))
4326 error ("%qE declared %<threadprivate%> after first use", v
);
4327 else if (! TREE_STATIC (v
) && ! DECL_EXTERNAL (v
))
4328 error ("automatic variable %qE cannot be %<threadprivate%>", v
);
4329 else if (! COMPLETE_TYPE_P (TREE_TYPE (v
)))
4330 error ("%<threadprivate%> %qE has incomplete type", v
);
4331 else if (TREE_STATIC (v
) && TYPE_P (CP_DECL_CONTEXT (v
))
4332 && CP_DECL_CONTEXT (v
) != current_class_type
)
4333 error ("%<threadprivate%> %qE directive not "
4334 "in %qT definition", v
, CP_DECL_CONTEXT (v
));
4337 /* Allocate a LANG_SPECIFIC structure for V, if needed. */
4338 if (DECL_LANG_SPECIFIC (v
) == NULL
)
4340 retrofit_lang_decl (v
);
4342 /* Make sure that DECL_DISCRIMINATOR_P continues to be true
4343 after the allocation of the lang_decl structure. */
4344 if (DECL_DISCRIMINATOR_P (v
))
4345 DECL_LANG_SPECIFIC (v
)->u
.base
.u2sel
= 1;
4348 if (! DECL_THREAD_LOCAL_P (v
))
4350 DECL_TLS_MODEL (v
) = decl_default_tls_model (v
);
4351 /* If rtl has been already set for this var, call
4352 make_decl_rtl once again, so that encode_section_info
4353 has a chance to look at the new decl flags. */
4354 if (DECL_RTL_SET_P (v
))
4357 CP_DECL_THREADPRIVATE_P (v
) = 1;
4362 /* Build an OpenMP structured block. */
4365 begin_omp_structured_block (void)
4367 return do_pushlevel (sk_omp
);
4371 finish_omp_structured_block (tree block
)
4373 return do_poplevel (block
);
4376 /* Similarly, except force the retention of the BLOCK. */
4379 begin_omp_parallel (void)
4381 keep_next_level (true);
4382 return begin_omp_structured_block ();
4386 finish_omp_parallel (tree clauses
, tree body
)
4390 body
= finish_omp_structured_block (body
);
4392 stmt
= make_node (OMP_PARALLEL
);
4393 TREE_TYPE (stmt
) = void_type_node
;
4394 OMP_PARALLEL_CLAUSES (stmt
) = clauses
;
4395 OMP_PARALLEL_BODY (stmt
) = body
;
4397 return add_stmt (stmt
);
4401 begin_omp_task (void)
4403 keep_next_level (true);
4404 return begin_omp_structured_block ();
4408 finish_omp_task (tree clauses
, tree body
)
4412 body
= finish_omp_structured_block (body
);
4414 stmt
= make_node (OMP_TASK
);
4415 TREE_TYPE (stmt
) = void_type_node
;
4416 OMP_TASK_CLAUSES (stmt
) = clauses
;
4417 OMP_TASK_BODY (stmt
) = body
;
4419 return add_stmt (stmt
);
4422 /* Helper function for finish_omp_for. Convert Ith random access iterator
4423 into integral iterator. Return FALSE if successful. */
4426 handle_omp_for_class_iterator (int i
, location_t locus
, tree declv
, tree initv
,
4427 tree condv
, tree incrv
, tree
*body
,
4428 tree
*pre_body
, tree clauses
)
4430 tree diff
, iter_init
, iter_incr
= NULL
, last
;
4431 tree incr_var
= NULL
, orig_pre_body
, orig_body
, c
;
4432 tree decl
= TREE_VEC_ELT (declv
, i
);
4433 tree init
= TREE_VEC_ELT (initv
, i
);
4434 tree cond
= TREE_VEC_ELT (condv
, i
);
4435 tree incr
= TREE_VEC_ELT (incrv
, i
);
4437 location_t elocus
= locus
;
4439 if (init
&& EXPR_HAS_LOCATION (init
))
4440 elocus
= EXPR_LOCATION (init
);
4442 switch (TREE_CODE (cond
))
4448 if (TREE_OPERAND (cond
, 1) == iter
)
4449 cond
= build2 (swap_tree_comparison (TREE_CODE (cond
)),
4450 TREE_TYPE (cond
), iter
, TREE_OPERAND (cond
, 0));
4451 if (TREE_OPERAND (cond
, 0) != iter
)
4452 cond
= error_mark_node
;
4455 tree tem
= build_x_binary_op (EXPR_LOCATION (cond
),
4458 TREE_OPERAND (cond
, 1), ERROR_MARK
,
4459 NULL
, tf_warning_or_error
);
4460 if (error_operand_p (tem
))
4465 cond
= error_mark_node
;
4468 if (cond
== error_mark_node
)
4470 error_at (elocus
, "invalid controlling predicate");
4473 diff
= build_x_binary_op (elocus
, MINUS_EXPR
, TREE_OPERAND (cond
, 1),
4474 ERROR_MARK
, iter
, ERROR_MARK
, NULL
,
4475 tf_warning_or_error
);
4476 if (error_operand_p (diff
))
4478 if (TREE_CODE (TREE_TYPE (diff
)) != INTEGER_TYPE
)
4480 error_at (elocus
, "difference between %qE and %qD does not have integer type",
4481 TREE_OPERAND (cond
, 1), iter
);
4485 switch (TREE_CODE (incr
))
4487 case PREINCREMENT_EXPR
:
4488 case PREDECREMENT_EXPR
:
4489 case POSTINCREMENT_EXPR
:
4490 case POSTDECREMENT_EXPR
:
4491 if (TREE_OPERAND (incr
, 0) != iter
)
4493 incr
= error_mark_node
;
4496 iter_incr
= build_x_unary_op (EXPR_LOCATION (incr
),
4497 TREE_CODE (incr
), iter
,
4498 tf_warning_or_error
);
4499 if (error_operand_p (iter_incr
))
4501 else if (TREE_CODE (incr
) == PREINCREMENT_EXPR
4502 || TREE_CODE (incr
) == POSTINCREMENT_EXPR
)
4503 incr
= integer_one_node
;
4505 incr
= integer_minus_one_node
;
4508 if (TREE_OPERAND (incr
, 0) != iter
)
4509 incr
= error_mark_node
;
4510 else if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
4511 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
4513 tree rhs
= TREE_OPERAND (incr
, 1);
4514 if (TREE_OPERAND (rhs
, 0) == iter
)
4516 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs
, 1)))
4518 incr
= error_mark_node
;
4521 iter_incr
= build_x_modify_expr (EXPR_LOCATION (rhs
),
4522 iter
, TREE_CODE (rhs
),
4523 TREE_OPERAND (rhs
, 1),
4524 tf_warning_or_error
);
4525 if (error_operand_p (iter_incr
))
4527 incr
= TREE_OPERAND (rhs
, 1);
4528 incr
= cp_convert (TREE_TYPE (diff
), incr
,
4529 tf_warning_or_error
);
4530 if (TREE_CODE (rhs
) == MINUS_EXPR
)
4532 incr
= build1 (NEGATE_EXPR
, TREE_TYPE (diff
), incr
);
4533 incr
= fold_if_not_in_template (incr
);
4535 if (TREE_CODE (incr
) != INTEGER_CST
4536 && (TREE_CODE (incr
) != NOP_EXPR
4537 || (TREE_CODE (TREE_OPERAND (incr
, 0))
4542 else if (TREE_OPERAND (rhs
, 1) == iter
)
4544 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs
, 0))) != INTEGER_TYPE
4545 || TREE_CODE (rhs
) != PLUS_EXPR
)
4546 incr
= error_mark_node
;
4549 iter_incr
= build_x_binary_op (EXPR_LOCATION (rhs
),
4551 TREE_OPERAND (rhs
, 0),
4554 tf_warning_or_error
);
4555 if (error_operand_p (iter_incr
))
4557 iter_incr
= build_x_modify_expr (EXPR_LOCATION (rhs
),
4560 tf_warning_or_error
);
4561 if (error_operand_p (iter_incr
))
4563 incr
= TREE_OPERAND (rhs
, 0);
4568 incr
= error_mark_node
;
4571 incr
= error_mark_node
;
4574 incr
= error_mark_node
;
4578 if (incr
== error_mark_node
)
4580 error_at (elocus
, "invalid increment expression");
4584 incr
= cp_convert (TREE_TYPE (diff
), incr
, tf_warning_or_error
);
4585 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
4586 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
4587 && OMP_CLAUSE_DECL (c
) == iter
)
4590 decl
= create_temporary_var (TREE_TYPE (diff
));
4592 add_decl_expr (decl
);
4593 last
= create_temporary_var (TREE_TYPE (diff
));
4595 add_decl_expr (last
);
4596 if (c
&& iter_incr
== NULL
)
4598 incr_var
= create_temporary_var (TREE_TYPE (diff
));
4599 pushdecl (incr_var
);
4600 add_decl_expr (incr_var
);
4602 gcc_assert (stmts_are_full_exprs_p ());
4604 orig_pre_body
= *pre_body
;
4605 *pre_body
= push_stmt_list ();
4607 add_stmt (orig_pre_body
);
4609 finish_expr_stmt (build_x_modify_expr (elocus
,
4610 iter
, NOP_EXPR
, init
,
4611 tf_warning_or_error
));
4612 init
= build_int_cst (TREE_TYPE (diff
), 0);
4613 if (c
&& iter_incr
== NULL
)
4615 finish_expr_stmt (build_x_modify_expr (elocus
,
4617 incr
, tf_warning_or_error
));
4619 iter_incr
= build_x_modify_expr (elocus
,
4620 iter
, PLUS_EXPR
, incr
,
4621 tf_warning_or_error
);
4623 finish_expr_stmt (build_x_modify_expr (elocus
,
4624 last
, NOP_EXPR
, init
,
4625 tf_warning_or_error
));
4626 *pre_body
= pop_stmt_list (*pre_body
);
4628 cond
= cp_build_binary_op (elocus
,
4629 TREE_CODE (cond
), decl
, diff
,
4630 tf_warning_or_error
);
4631 incr
= build_modify_expr (elocus
, decl
, NULL_TREE
, PLUS_EXPR
,
4632 elocus
, incr
, NULL_TREE
);
4635 *body
= push_stmt_list ();
4636 iter_init
= build2 (MINUS_EXPR
, TREE_TYPE (diff
), decl
, last
);
4637 iter_init
= build_x_modify_expr (elocus
,
4638 iter
, PLUS_EXPR
, iter_init
,
4639 tf_warning_or_error
);
4640 iter_init
= build1 (NOP_EXPR
, void_type_node
, iter_init
);
4641 finish_expr_stmt (iter_init
);
4642 finish_expr_stmt (build_x_modify_expr (elocus
,
4643 last
, NOP_EXPR
, decl
,
4644 tf_warning_or_error
));
4645 add_stmt (orig_body
);
4646 *body
= pop_stmt_list (*body
);
4650 OMP_CLAUSE_LASTPRIVATE_STMT (c
) = push_stmt_list ();
4651 finish_expr_stmt (iter_incr
);
4652 OMP_CLAUSE_LASTPRIVATE_STMT (c
)
4653 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (c
));
4656 TREE_VEC_ELT (declv
, i
) = decl
;
4657 TREE_VEC_ELT (initv
, i
) = init
;
4658 TREE_VEC_ELT (condv
, i
) = cond
;
4659 TREE_VEC_ELT (incrv
, i
) = incr
;
4664 /* Build and validate an OMP_FOR statement. CLAUSES, BODY, COND, INCR
4665 are directly for their associated operands in the statement. DECL
4666 and INIT are a combo; if DECL is NULL then INIT ought to be a
4667 MODIFY_EXPR, and the DECL should be extracted. PRE_BODY are
4668 optional statements that need to go before the loop into its
4672 finish_omp_for (location_t locus
, tree declv
, tree initv
, tree condv
,
4673 tree incrv
, tree body
, tree pre_body
, tree clauses
)
4675 tree omp_for
= NULL
, orig_incr
= NULL
;
4676 tree decl
, init
, cond
, incr
;
4680 gcc_assert (TREE_VEC_LENGTH (declv
) == TREE_VEC_LENGTH (initv
));
4681 gcc_assert (TREE_VEC_LENGTH (declv
) == TREE_VEC_LENGTH (condv
));
4682 gcc_assert (TREE_VEC_LENGTH (declv
) == TREE_VEC_LENGTH (incrv
));
4683 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
4685 decl
= TREE_VEC_ELT (declv
, i
);
4686 init
= TREE_VEC_ELT (initv
, i
);
4687 cond
= TREE_VEC_ELT (condv
, i
);
4688 incr
= TREE_VEC_ELT (incrv
, i
);
4694 switch (TREE_CODE (init
))
4697 decl
= TREE_OPERAND (init
, 0);
4698 init
= TREE_OPERAND (init
, 1);
4701 if (TREE_CODE (TREE_OPERAND (init
, 1)) == NOP_EXPR
)
4703 decl
= TREE_OPERAND (init
, 0);
4704 init
= TREE_OPERAND (init
, 2);
4714 "expected iteration declaration or initialization");
4719 if (init
&& EXPR_HAS_LOCATION (init
))
4720 elocus
= EXPR_LOCATION (init
);
4724 error_at (elocus
, "missing controlling predicate");
4730 error_at (elocus
, "missing increment expression");
4734 TREE_VEC_ELT (declv
, i
) = decl
;
4735 TREE_VEC_ELT (initv
, i
) = init
;
4738 if (dependent_omp_for_p (declv
, initv
, condv
, incrv
))
4742 stmt
= make_node (OMP_FOR
);
4744 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
4746 /* This is really just a place-holder. We'll be decomposing this
4747 again and going through the cp_build_modify_expr path below when
4748 we instantiate the thing. */
4749 TREE_VEC_ELT (initv
, i
)
4750 = build2 (MODIFY_EXPR
, void_type_node
, TREE_VEC_ELT (declv
, i
),
4751 TREE_VEC_ELT (initv
, i
));
4754 TREE_TYPE (stmt
) = void_type_node
;
4755 OMP_FOR_INIT (stmt
) = initv
;
4756 OMP_FOR_COND (stmt
) = condv
;
4757 OMP_FOR_INCR (stmt
) = incrv
;
4758 OMP_FOR_BODY (stmt
) = body
;
4759 OMP_FOR_PRE_BODY (stmt
) = pre_body
;
4760 OMP_FOR_CLAUSES (stmt
) = clauses
;
4762 SET_EXPR_LOCATION (stmt
, locus
);
4763 return add_stmt (stmt
);
4766 if (processing_template_decl
)
4767 orig_incr
= make_tree_vec (TREE_VEC_LENGTH (incrv
));
4769 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); )
4771 decl
= TREE_VEC_ELT (declv
, i
);
4772 init
= TREE_VEC_ELT (initv
, i
);
4773 cond
= TREE_VEC_ELT (condv
, i
);
4774 incr
= TREE_VEC_ELT (incrv
, i
);
4776 TREE_VEC_ELT (orig_incr
, i
) = incr
;
4779 if (init
&& EXPR_HAS_LOCATION (init
))
4780 elocus
= EXPR_LOCATION (init
);
4784 error_at (elocus
, "expected iteration declaration or initialization");
4788 if (incr
&& TREE_CODE (incr
) == MODOP_EXPR
)
4791 TREE_VEC_ELT (orig_incr
, i
) = incr
;
4792 incr
= cp_build_modify_expr (TREE_OPERAND (incr
, 0),
4793 TREE_CODE (TREE_OPERAND (incr
, 1)),
4794 TREE_OPERAND (incr
, 2),
4795 tf_warning_or_error
);
4798 if (CLASS_TYPE_P (TREE_TYPE (decl
)))
4800 if (handle_omp_for_class_iterator (i
, locus
, declv
, initv
, condv
,
4801 incrv
, &body
, &pre_body
, clauses
))
4806 if (!INTEGRAL_TYPE_P (TREE_TYPE (decl
))
4807 && TREE_CODE (TREE_TYPE (decl
)) != POINTER_TYPE
)
4809 error_at (elocus
, "invalid type for iteration variable %qE", decl
);
4813 if (!processing_template_decl
)
4815 init
= fold_build_cleanup_point_expr (TREE_TYPE (init
), init
);
4816 init
= cp_build_modify_expr (decl
, NOP_EXPR
, init
, tf_warning_or_error
);
4819 init
= build2 (MODIFY_EXPR
, void_type_node
, decl
, init
);
4821 && TREE_SIDE_EFFECTS (cond
)
4822 && COMPARISON_CLASS_P (cond
)
4823 && !processing_template_decl
)
4825 tree t
= TREE_OPERAND (cond
, 0);
4826 if (TREE_SIDE_EFFECTS (t
)
4828 && (TREE_CODE (t
) != NOP_EXPR
4829 || TREE_OPERAND (t
, 0) != decl
))
4830 TREE_OPERAND (cond
, 0)
4831 = fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4833 t
= TREE_OPERAND (cond
, 1);
4834 if (TREE_SIDE_EFFECTS (t
)
4836 && (TREE_CODE (t
) != NOP_EXPR
4837 || TREE_OPERAND (t
, 0) != decl
))
4838 TREE_OPERAND (cond
, 1)
4839 = fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4841 if (decl
== error_mark_node
|| init
== error_mark_node
)
4844 TREE_VEC_ELT (declv
, i
) = decl
;
4845 TREE_VEC_ELT (initv
, i
) = init
;
4846 TREE_VEC_ELT (condv
, i
) = cond
;
4847 TREE_VEC_ELT (incrv
, i
) = incr
;
4851 if (IS_EMPTY_STMT (pre_body
))
4854 omp_for
= c_finish_omp_for (locus
, declv
, initv
, condv
, incrv
,
4857 if (omp_for
== NULL
)
4860 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INCR (omp_for
)); i
++)
4862 decl
= TREE_OPERAND (TREE_VEC_ELT (OMP_FOR_INIT (omp_for
), i
), 0);
4863 incr
= TREE_VEC_ELT (OMP_FOR_INCR (omp_for
), i
);
4865 if (TREE_CODE (incr
) != MODIFY_EXPR
)
4868 if (TREE_SIDE_EFFECTS (TREE_OPERAND (incr
, 1))
4869 && BINARY_CLASS_P (TREE_OPERAND (incr
, 1))
4870 && !processing_template_decl
)
4872 tree t
= TREE_OPERAND (TREE_OPERAND (incr
, 1), 0);
4873 if (TREE_SIDE_EFFECTS (t
)
4875 && (TREE_CODE (t
) != NOP_EXPR
4876 || TREE_OPERAND (t
, 0) != decl
))
4877 TREE_OPERAND (TREE_OPERAND (incr
, 1), 0)
4878 = fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4880 t
= TREE_OPERAND (TREE_OPERAND (incr
, 1), 1);
4881 if (TREE_SIDE_EFFECTS (t
)
4883 && (TREE_CODE (t
) != NOP_EXPR
4884 || TREE_OPERAND (t
, 0) != decl
))
4885 TREE_OPERAND (TREE_OPERAND (incr
, 1), 1)
4886 = fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4890 TREE_VEC_ELT (OMP_FOR_INCR (omp_for
), i
) = TREE_VEC_ELT (orig_incr
, i
);
4892 if (omp_for
!= NULL
)
4893 OMP_FOR_CLAUSES (omp_for
) = clauses
;
4898 finish_omp_atomic (enum tree_code code
, enum tree_code opcode
, tree lhs
,
4899 tree rhs
, tree v
, tree lhs1
, tree rhs1
)
4914 dependent_p
= false;
4917 /* Even in a template, we can detect invalid uses of the atomic
4918 pragma if neither LHS nor RHS is type-dependent. */
4919 if (processing_template_decl
)
4921 dependent_p
= (type_dependent_expression_p (lhs
)
4922 || (rhs
&& type_dependent_expression_p (rhs
))
4923 || (v
&& type_dependent_expression_p (v
))
4924 || (lhs1
&& type_dependent_expression_p (lhs1
))
4925 || (rhs1
&& type_dependent_expression_p (rhs1
)));
4928 lhs
= build_non_dependent_expr (lhs
);
4930 rhs
= build_non_dependent_expr (rhs
);
4932 v
= build_non_dependent_expr (v
);
4934 lhs1
= build_non_dependent_expr (lhs1
);
4936 rhs1
= build_non_dependent_expr (rhs1
);
4941 stmt
= c_finish_omp_atomic (input_location
, code
, opcode
, lhs
, rhs
,
4943 if (stmt
== error_mark_node
)
4946 if (processing_template_decl
)
4948 if (code
== OMP_ATOMIC_READ
)
4950 stmt
= build_min_nt_loc (EXPR_LOCATION (orig_lhs
),
4951 OMP_ATOMIC_READ
, orig_lhs
);
4952 stmt
= build2 (MODIFY_EXPR
, void_type_node
, orig_v
, stmt
);
4956 if (opcode
== NOP_EXPR
)
4957 stmt
= build2 (MODIFY_EXPR
, void_type_node
, orig_lhs
, orig_rhs
);
4959 stmt
= build2 (opcode
, void_type_node
, orig_lhs
, orig_rhs
);
4961 stmt
= build_min_nt_loc (EXPR_LOCATION (orig_rhs1
),
4962 COMPOUND_EXPR
, orig_rhs1
, stmt
);
4963 if (code
!= OMP_ATOMIC
)
4965 stmt
= build_min_nt_loc (EXPR_LOCATION (orig_lhs1
),
4966 code
, orig_lhs1
, stmt
);
4967 stmt
= build2 (MODIFY_EXPR
, void_type_node
, orig_v
, stmt
);
4970 stmt
= build2 (OMP_ATOMIC
, void_type_node
, integer_zero_node
, stmt
);
4976 finish_omp_barrier (void)
4978 tree fn
= builtin_decl_explicit (BUILT_IN_GOMP_BARRIER
);
4979 VEC(tree
,gc
) *vec
= make_tree_vector ();
4980 tree stmt
= finish_call_expr (fn
, &vec
, false, false, tf_warning_or_error
);
4981 release_tree_vector (vec
);
4982 finish_expr_stmt (stmt
);
4986 finish_omp_flush (void)
4988 tree fn
= builtin_decl_explicit (BUILT_IN_SYNC_SYNCHRONIZE
);
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_taskwait (void)
4998 tree fn
= builtin_decl_explicit (BUILT_IN_GOMP_TASKWAIT
);
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_taskyield (void)
5008 tree fn
= builtin_decl_explicit (BUILT_IN_GOMP_TASKYIELD
);
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
);
5015 /* Begin a __transaction_atomic or __transaction_relaxed statement.
5016 If PCOMPOUND is non-null, this is for a function-transaction-block, and we
5017 should create an extra compound stmt. */
5020 begin_transaction_stmt (location_t loc
, tree
*pcompound
, int flags
)
5025 *pcompound
= begin_compound_stmt (0);
5027 r
= build_stmt (loc
, TRANSACTION_EXPR
, NULL_TREE
);
5029 /* Only add the statement to the function if support enabled. */
5033 error_at (loc
, ((flags
& TM_STMT_ATTR_RELAXED
) != 0
5034 ? G_("%<__transaction_relaxed%> without "
5035 "transactional memory support enabled")
5036 : G_("%<__transaction_atomic%> without "
5037 "transactional memory support enabled")));
5039 TRANSACTION_EXPR_BODY (r
) = push_stmt_list ();
5043 /* End a __transaction_atomic or __transaction_relaxed statement.
5044 If COMPOUND_STMT is non-null, this is for a function-transaction-block,
5045 and we should end the compound. If NOEX is non-NULL, we wrap the body in
5046 a MUST_NOT_THROW_EXPR with NOEX as condition. */
5049 finish_transaction_stmt (tree stmt
, tree compound_stmt
, int flags
, tree noex
)
5051 TRANSACTION_EXPR_BODY (stmt
) = pop_stmt_list (TRANSACTION_EXPR_BODY (stmt
));
5052 TRANSACTION_EXPR_OUTER (stmt
) = (flags
& TM_STMT_ATTR_OUTER
) != 0;
5053 TRANSACTION_EXPR_RELAXED (stmt
) = (flags
& TM_STMT_ATTR_RELAXED
) != 0;
5054 TRANSACTION_EXPR_IS_STMT (stmt
) = 1;
5056 /* noexcept specifications are not allowed for function transactions. */
5057 gcc_assert (!(noex
&& compound_stmt
));
5060 tree body
= build_must_not_throw_expr (TRANSACTION_EXPR_BODY (stmt
),
5062 SET_EXPR_LOCATION (body
, EXPR_LOCATION (TRANSACTION_EXPR_BODY (stmt
)));
5063 TREE_SIDE_EFFECTS (body
) = 1;
5064 TRANSACTION_EXPR_BODY (stmt
) = body
;
5068 finish_compound_stmt (compound_stmt
);
5072 /* Build a __transaction_atomic or __transaction_relaxed expression. If
5073 NOEX is non-NULL, we wrap the body in a MUST_NOT_THROW_EXPR with NOEX as
5077 build_transaction_expr (location_t loc
, tree expr
, int flags
, tree noex
)
5082 expr
= build_must_not_throw_expr (expr
, noex
);
5083 SET_EXPR_LOCATION (expr
, loc
);
5084 TREE_SIDE_EFFECTS (expr
) = 1;
5086 ret
= build1 (TRANSACTION_EXPR
, TREE_TYPE (expr
), expr
);
5087 if (flags
& TM_STMT_ATTR_RELAXED
)
5088 TRANSACTION_EXPR_RELAXED (ret
) = 1;
5089 SET_EXPR_LOCATION (ret
, loc
);
5094 init_cp_semantics (void)
5098 /* Build a STATIC_ASSERT for a static assertion with the condition
5099 CONDITION and the message text MESSAGE. LOCATION is the location
5100 of the static assertion in the source code. When MEMBER_P, this
5101 static assertion is a member of a class. */
5103 finish_static_assert (tree condition
, tree message
, location_t location
,
5106 if (check_for_bare_parameter_packs (condition
))
5107 condition
= error_mark_node
;
5109 if (type_dependent_expression_p (condition
)
5110 || value_dependent_expression_p (condition
))
5112 /* We're in a template; build a STATIC_ASSERT and put it in
5116 assertion
= make_node (STATIC_ASSERT
);
5117 STATIC_ASSERT_CONDITION (assertion
) = condition
;
5118 STATIC_ASSERT_MESSAGE (assertion
) = message
;
5119 STATIC_ASSERT_SOURCE_LOCATION (assertion
) = location
;
5122 maybe_add_class_template_decl_list (current_class_type
,
5126 add_stmt (assertion
);
5131 /* Fold the expression and convert it to a boolean value. */
5132 condition
= fold_non_dependent_expr (condition
);
5133 condition
= cp_convert (boolean_type_node
, condition
, tf_warning_or_error
);
5134 condition
= maybe_constant_value (condition
);
5136 if (TREE_CODE (condition
) == INTEGER_CST
&& !integer_zerop (condition
))
5137 /* Do nothing; the condition is satisfied. */
5141 location_t saved_loc
= input_location
;
5143 input_location
= location
;
5144 if (TREE_CODE (condition
) == INTEGER_CST
5145 && integer_zerop (condition
))
5146 /* Report the error. */
5147 error ("static assertion failed: %s", TREE_STRING_POINTER (message
));
5148 else if (condition
&& condition
!= error_mark_node
)
5150 error ("non-constant condition for static assertion");
5151 cxx_constant_value (condition
);
5153 input_location
= saved_loc
;
5157 /* Implements the C++0x decltype keyword. Returns the type of EXPR,
5158 suitable for use as a type-specifier.
5160 ID_EXPRESSION_OR_MEMBER_ACCESS_P is true when EXPR was parsed as an
5161 id-expression or a class member access, FALSE when it was parsed as
5162 a full expression. */
5165 finish_decltype_type (tree expr
, bool id_expression_or_member_access_p
,
5166 tsubst_flags_t complain
)
5168 tree type
= NULL_TREE
;
5170 if (!expr
|| error_operand_p (expr
))
5171 return error_mark_node
;
5174 || TREE_CODE (expr
) == TYPE_DECL
5175 || (TREE_CODE (expr
) == BIT_NOT_EXPR
5176 && TYPE_P (TREE_OPERAND (expr
, 0))))
5178 if (complain
& tf_error
)
5179 error ("argument to decltype must be an expression");
5180 return error_mark_node
;
5183 /* FIXME instantiation-dependent */
5184 if (type_dependent_expression_p (expr
)
5185 /* In a template, a COMPONENT_REF has an IDENTIFIER_NODE for op1 even
5186 if it isn't dependent, so that we can check access control at
5187 instantiation time, so defer the decltype as well (PR 42277). */
5188 || (id_expression_or_member_access_p
5189 && processing_template_decl
5190 && TREE_CODE (expr
) == COMPONENT_REF
))
5192 type
= cxx_make_type (DECLTYPE_TYPE
);
5193 DECLTYPE_TYPE_EXPR (type
) = expr
;
5194 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type
)
5195 = id_expression_or_member_access_p
;
5196 SET_TYPE_STRUCTURAL_EQUALITY (type
);
5201 /* The type denoted by decltype(e) is defined as follows: */
5203 expr
= resolve_nondeduced_context (expr
);
5205 if (type_unknown_p (expr
))
5207 if (complain
& tf_error
)
5208 error ("decltype cannot resolve address of overloaded function");
5209 return error_mark_node
;
5212 if (invalid_nonstatic_memfn_p (expr
, complain
))
5213 return error_mark_node
;
5215 /* To get the size of a static data member declared as an array of
5216 unknown bound, we need to instantiate it. */
5217 if (TREE_CODE (expr
) == VAR_DECL
5218 && VAR_HAD_UNKNOWN_BOUND (expr
)
5219 && DECL_TEMPLATE_INSTANTIATION (expr
))
5220 instantiate_decl (expr
, /*defer_ok*/true, /*expl_inst_mem*/false);
5222 if (id_expression_or_member_access_p
)
5224 /* If e is an id-expression or a class member access (5.2.5
5225 [expr.ref]), decltype(e) is defined as the type of the entity
5226 named by e. If there is no such entity, or e names a set of
5227 overloaded functions, the program is ill-formed. */
5228 if (TREE_CODE (expr
) == IDENTIFIER_NODE
)
5229 expr
= lookup_name (expr
);
5231 if (TREE_CODE (expr
) == INDIRECT_REF
)
5232 /* This can happen when the expression is, e.g., "a.b". Just
5233 look at the underlying operand. */
5234 expr
= TREE_OPERAND (expr
, 0);
5236 if (TREE_CODE (expr
) == OFFSET_REF
5237 || TREE_CODE (expr
) == MEMBER_REF
)
5238 /* We're only interested in the field itself. If it is a
5239 BASELINK, we will need to see through it in the next
5241 expr
= TREE_OPERAND (expr
, 1);
5243 if (BASELINK_P (expr
))
5244 /* See through BASELINK nodes to the underlying function. */
5245 expr
= BASELINK_FUNCTIONS (expr
);
5247 switch (TREE_CODE (expr
))
5250 if (DECL_BIT_FIELD_TYPE (expr
))
5252 type
= DECL_BIT_FIELD_TYPE (expr
);
5255 /* Fall through for fields that aren't bitfields. */
5262 case TEMPLATE_PARM_INDEX
:
5263 expr
= mark_type_use (expr
);
5264 type
= TREE_TYPE (expr
);
5268 type
= error_mark_node
;
5272 mark_type_use (expr
);
5273 type
= is_bitfield_expr_with_lowered_type (expr
);
5275 type
= TREE_TYPE (TREE_OPERAND (expr
, 1));
5283 /* We can get here when the id-expression refers to an
5284 enumerator or non-type template parameter. */
5285 type
= TREE_TYPE (expr
);
5290 return error_mark_node
;
5295 /* Within a lambda-expression:
5297 Every occurrence of decltype((x)) where x is a possibly
5298 parenthesized id-expression that names an entity of
5299 automatic storage duration is treated as if x were
5300 transformed into an access to a corresponding data member
5301 of the closure type that would have been declared if x
5302 were a use of the denoted entity. */
5303 if (outer_automatic_var_p (expr
)
5304 && current_function_decl
5305 && LAMBDA_FUNCTION_P (current_function_decl
))
5306 type
= capture_decltype (expr
);
5307 else if (error_operand_p (expr
))
5308 type
= error_mark_node
;
5309 else if (expr
== current_class_ptr
)
5310 /* If the expression is just "this", we want the
5311 cv-unqualified pointer for the "this" type. */
5312 type
= TYPE_MAIN_VARIANT (TREE_TYPE (expr
));
5315 /* Otherwise, where T is the type of e, if e is an lvalue,
5316 decltype(e) is defined as T&; if an xvalue, T&&; otherwise, T. */
5317 cp_lvalue_kind clk
= lvalue_kind (expr
);
5318 type
= unlowered_expr_type (expr
);
5319 gcc_assert (TREE_CODE (type
) != REFERENCE_TYPE
);
5320 if (clk
!= clk_none
&& !(clk
& clk_class
))
5321 type
= cp_build_reference_type (type
, (clk
& clk_rvalueref
));
5328 /* Called from trait_expr_value to evaluate either __has_nothrow_assign or
5329 __has_nothrow_copy, depending on assign_p. */
5332 classtype_has_nothrow_assign_or_copy_p (tree type
, bool assign_p
)
5339 ix
= lookup_fnfields_1 (type
, ansi_assopname (NOP_EXPR
));
5342 fns
= VEC_index (tree
, CLASSTYPE_METHOD_VEC (type
), ix
);
5344 else if (TYPE_HAS_COPY_CTOR (type
))
5346 /* If construction of the copy constructor was postponed, create
5348 if (CLASSTYPE_LAZY_COPY_CTOR (type
))
5349 lazily_declare_fn (sfk_copy_constructor
, type
);
5350 if (CLASSTYPE_LAZY_MOVE_CTOR (type
))
5351 lazily_declare_fn (sfk_move_constructor
, type
);
5352 fns
= CLASSTYPE_CONSTRUCTORS (type
);
5357 for (; fns
; fns
= OVL_NEXT (fns
))
5359 tree fn
= OVL_CURRENT (fns
);
5363 if (copy_fn_p (fn
) == 0)
5366 else if (copy_fn_p (fn
) <= 0)
5369 if (!TYPE_NOTHROW_P (TREE_TYPE (fn
)))
5376 /* Actually evaluates the trait. */
5379 trait_expr_value (cp_trait_kind kind
, tree type1
, tree type2
)
5381 enum tree_code type_code1
;
5384 type_code1
= TREE_CODE (type1
);
5388 case CPTK_HAS_NOTHROW_ASSIGN
:
5389 type1
= strip_array_types (type1
);
5390 return (!CP_TYPE_CONST_P (type1
) && type_code1
!= REFERENCE_TYPE
5391 && (trait_expr_value (CPTK_HAS_TRIVIAL_ASSIGN
, type1
, type2
)
5392 || (CLASS_TYPE_P (type1
)
5393 && classtype_has_nothrow_assign_or_copy_p (type1
,
5396 case CPTK_HAS_TRIVIAL_ASSIGN
:
5397 /* ??? The standard seems to be missing the "or array of such a class
5398 type" wording for this trait. */
5399 type1
= strip_array_types (type1
);
5400 return (!CP_TYPE_CONST_P (type1
) && type_code1
!= REFERENCE_TYPE
5401 && (trivial_type_p (type1
)
5402 || (CLASS_TYPE_P (type1
)
5403 && TYPE_HAS_TRIVIAL_COPY_ASSIGN (type1
))));
5405 case CPTK_HAS_NOTHROW_CONSTRUCTOR
:
5406 type1
= strip_array_types (type1
);
5407 return (trait_expr_value (CPTK_HAS_TRIVIAL_CONSTRUCTOR
, type1
, type2
)
5408 || (CLASS_TYPE_P (type1
)
5409 && (t
= locate_ctor (type1
))
5410 && TYPE_NOTHROW_P (TREE_TYPE (t
))));
5412 case CPTK_HAS_TRIVIAL_CONSTRUCTOR
:
5413 type1
= strip_array_types (type1
);
5414 return (trivial_type_p (type1
)
5415 || (CLASS_TYPE_P (type1
) && TYPE_HAS_TRIVIAL_DFLT (type1
)));
5417 case CPTK_HAS_NOTHROW_COPY
:
5418 type1
= strip_array_types (type1
);
5419 return (trait_expr_value (CPTK_HAS_TRIVIAL_COPY
, type1
, type2
)
5420 || (CLASS_TYPE_P (type1
)
5421 && classtype_has_nothrow_assign_or_copy_p (type1
, false)));
5423 case CPTK_HAS_TRIVIAL_COPY
:
5424 /* ??? The standard seems to be missing the "or array of such a class
5425 type" wording for this trait. */
5426 type1
= strip_array_types (type1
);
5427 return (trivial_type_p (type1
) || type_code1
== REFERENCE_TYPE
5428 || (CLASS_TYPE_P (type1
) && TYPE_HAS_TRIVIAL_COPY_CTOR (type1
)));
5430 case CPTK_HAS_TRIVIAL_DESTRUCTOR
:
5431 type1
= strip_array_types (type1
);
5432 return (trivial_type_p (type1
) || type_code1
== REFERENCE_TYPE
5433 || (CLASS_TYPE_P (type1
)
5434 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type1
)));
5436 case CPTK_HAS_VIRTUAL_DESTRUCTOR
:
5437 return type_has_virtual_destructor (type1
);
5439 case CPTK_IS_ABSTRACT
:
5440 return (ABSTRACT_CLASS_TYPE_P (type1
));
5442 case CPTK_IS_BASE_OF
:
5443 return (NON_UNION_CLASS_TYPE_P (type1
) && NON_UNION_CLASS_TYPE_P (type2
)
5444 && DERIVED_FROM_P (type1
, type2
));
5447 return (NON_UNION_CLASS_TYPE_P (type1
));
5449 case CPTK_IS_CONVERTIBLE_TO
:
5454 return (NON_UNION_CLASS_TYPE_P (type1
) && CLASSTYPE_EMPTY_P (type1
));
5457 return (type_code1
== ENUMERAL_TYPE
);
5460 return (CLASS_TYPE_P (type1
) && CLASSTYPE_FINAL (type1
));
5462 case CPTK_IS_LITERAL_TYPE
:
5463 return (literal_type_p (type1
));
5466 return (pod_type_p (type1
));
5468 case CPTK_IS_POLYMORPHIC
:
5469 return (CLASS_TYPE_P (type1
) && TYPE_POLYMORPHIC_P (type1
));
5471 case CPTK_IS_STD_LAYOUT
:
5472 return (std_layout_type_p (type1
));
5474 case CPTK_IS_TRIVIAL
:
5475 return (trivial_type_p (type1
));
5478 return (type_code1
== UNION_TYPE
);
5486 /* If TYPE is an array of unknown bound, or (possibly cv-qualified)
5487 void, or a complete type, returns it, otherwise NULL_TREE. */
5490 check_trait_type (tree type
)
5492 if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
)
5493 && COMPLETE_TYPE_P (TREE_TYPE (type
)))
5496 if (VOID_TYPE_P (type
))
5499 return complete_type_or_else (strip_array_types (type
), NULL_TREE
);
5502 /* Process a trait expression. */
5505 finish_trait_expr (cp_trait_kind kind
, tree type1
, tree type2
)
5507 gcc_assert (kind
== CPTK_HAS_NOTHROW_ASSIGN
5508 || kind
== CPTK_HAS_NOTHROW_CONSTRUCTOR
5509 || kind
== CPTK_HAS_NOTHROW_COPY
5510 || kind
== CPTK_HAS_TRIVIAL_ASSIGN
5511 || kind
== CPTK_HAS_TRIVIAL_CONSTRUCTOR
5512 || kind
== CPTK_HAS_TRIVIAL_COPY
5513 || kind
== CPTK_HAS_TRIVIAL_DESTRUCTOR
5514 || kind
== CPTK_HAS_VIRTUAL_DESTRUCTOR
5515 || kind
== CPTK_IS_ABSTRACT
5516 || kind
== CPTK_IS_BASE_OF
5517 || kind
== CPTK_IS_CLASS
5518 || kind
== CPTK_IS_CONVERTIBLE_TO
5519 || kind
== CPTK_IS_EMPTY
5520 || kind
== CPTK_IS_ENUM
5521 || kind
== CPTK_IS_FINAL
5522 || kind
== CPTK_IS_LITERAL_TYPE
5523 || kind
== CPTK_IS_POD
5524 || kind
== CPTK_IS_POLYMORPHIC
5525 || kind
== CPTK_IS_STD_LAYOUT
5526 || kind
== CPTK_IS_TRIVIAL
5527 || kind
== CPTK_IS_UNION
);
5529 if (kind
== CPTK_IS_CONVERTIBLE_TO
)
5531 sorry ("__is_convertible_to");
5532 return error_mark_node
;
5535 if (type1
== error_mark_node
5536 || ((kind
== CPTK_IS_BASE_OF
|| kind
== CPTK_IS_CONVERTIBLE_TO
)
5537 && type2
== error_mark_node
))
5538 return error_mark_node
;
5540 if (processing_template_decl
)
5542 tree trait_expr
= make_node (TRAIT_EXPR
);
5543 TREE_TYPE (trait_expr
) = boolean_type_node
;
5544 TRAIT_EXPR_TYPE1 (trait_expr
) = type1
;
5545 TRAIT_EXPR_TYPE2 (trait_expr
) = type2
;
5546 TRAIT_EXPR_KIND (trait_expr
) = kind
;
5552 case CPTK_HAS_NOTHROW_ASSIGN
:
5553 case CPTK_HAS_TRIVIAL_ASSIGN
:
5554 case CPTK_HAS_NOTHROW_CONSTRUCTOR
:
5555 case CPTK_HAS_TRIVIAL_CONSTRUCTOR
:
5556 case CPTK_HAS_NOTHROW_COPY
:
5557 case CPTK_HAS_TRIVIAL_COPY
:
5558 case CPTK_HAS_TRIVIAL_DESTRUCTOR
:
5559 case CPTK_HAS_VIRTUAL_DESTRUCTOR
:
5560 case CPTK_IS_ABSTRACT
:
5563 case CPTK_IS_LITERAL_TYPE
:
5565 case CPTK_IS_POLYMORPHIC
:
5566 case CPTK_IS_STD_LAYOUT
:
5567 case CPTK_IS_TRIVIAL
:
5568 if (!check_trait_type (type1
))
5569 return error_mark_node
;
5572 case CPTK_IS_BASE_OF
:
5573 if (NON_UNION_CLASS_TYPE_P (type1
) && NON_UNION_CLASS_TYPE_P (type2
)
5574 && !same_type_ignoring_top_level_qualifiers_p (type1
, type2
)
5575 && !complete_type_or_else (type2
, NULL_TREE
))
5576 /* We already issued an error. */
5577 return error_mark_node
;
5585 case CPTK_IS_CONVERTIBLE_TO
:
5590 return (trait_expr_value (kind
, type1
, type2
)
5591 ? boolean_true_node
: boolean_false_node
);
5594 /* Do-nothing variants of functions to handle pragma FLOAT_CONST_DECIMAL64,
5595 which is ignored for C++. */
5598 set_float_const_decimal64 (void)
5603 clear_float_const_decimal64 (void)
5608 float_const_decimal64_p (void)
5614 /* Return true if T is a literal type. */
5617 literal_type_p (tree t
)
5619 if (SCALAR_TYPE_P (t
)
5620 || TREE_CODE (t
) == VECTOR_TYPE
5621 || TREE_CODE (t
) == REFERENCE_TYPE
)
5623 if (CLASS_TYPE_P (t
))
5625 t
= complete_type (t
);
5626 gcc_assert (COMPLETE_TYPE_P (t
) || errorcount
);
5627 return CLASSTYPE_LITERAL_P (t
);
5629 if (TREE_CODE (t
) == ARRAY_TYPE
)
5630 return literal_type_p (strip_array_types (t
));
5634 /* If DECL is a variable declared `constexpr', require its type
5635 be literal. Return the DECL if OK, otherwise NULL. */
5638 ensure_literal_type_for_constexpr_object (tree decl
)
5640 tree type
= TREE_TYPE (decl
);
5641 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_DECLARED_CONSTEXPR_P (decl
)
5642 && !processing_template_decl
)
5644 if (CLASS_TYPE_P (type
) && !COMPLETE_TYPE_P (complete_type (type
)))
5645 /* Don't complain here, we'll complain about incompleteness
5646 when we try to initialize the variable. */;
5647 else if (!literal_type_p (type
))
5649 error ("the type %qT of constexpr variable %qD is not literal",
5651 explain_non_literal_class (type
);
5658 /* Representation of entries in the constexpr function definition table. */
5660 typedef struct GTY(()) constexpr_fundef
{
5665 /* This table holds all constexpr function definitions seen in
5666 the current translation unit. */
5668 static GTY ((param_is (constexpr_fundef
))) htab_t constexpr_fundef_table
;
5670 /* Utility function used for managing the constexpr function table.
5671 Return true if the entries pointed to by P and Q are for the
5672 same constexpr function. */
5675 constexpr_fundef_equal (const void *p
, const void *q
)
5677 const constexpr_fundef
*lhs
= (const constexpr_fundef
*) p
;
5678 const constexpr_fundef
*rhs
= (const constexpr_fundef
*) q
;
5679 return lhs
->decl
== rhs
->decl
;
5682 /* Utility function used for managing the constexpr function table.
5683 Return a hash value for the entry pointed to by Q. */
5685 static inline hashval_t
5686 constexpr_fundef_hash (const void *p
)
5688 const constexpr_fundef
*fundef
= (const constexpr_fundef
*) p
;
5689 return DECL_UID (fundef
->decl
);
5692 /* Return a previously saved definition of function FUN. */
5694 static constexpr_fundef
*
5695 retrieve_constexpr_fundef (tree fun
)
5697 constexpr_fundef fundef
= { NULL
, NULL
};
5698 if (constexpr_fundef_table
== NULL
)
5702 return (constexpr_fundef
*) htab_find (constexpr_fundef_table
, &fundef
);
5705 /* Check whether the parameter and return types of FUN are valid for a
5706 constexpr function, and complain if COMPLAIN. */
5709 is_valid_constexpr_fn (tree fun
, bool complain
)
5711 tree parm
= FUNCTION_FIRST_USER_PARM (fun
);
5713 for (; parm
!= NULL
; parm
= TREE_CHAIN (parm
))
5714 if (!literal_type_p (TREE_TYPE (parm
)))
5719 error ("invalid type for parameter %d of constexpr "
5720 "function %q+#D", DECL_PARM_INDEX (parm
), fun
);
5721 explain_non_literal_class (TREE_TYPE (parm
));
5725 if (!DECL_CONSTRUCTOR_P (fun
))
5727 tree rettype
= TREE_TYPE (TREE_TYPE (fun
));
5728 if (!literal_type_p (rettype
))
5733 error ("invalid return type %qT of constexpr function %q+D",
5735 explain_non_literal_class (rettype
);
5739 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
5740 && !CLASSTYPE_LITERAL_P (DECL_CONTEXT (fun
)))
5745 error ("enclosing class of constexpr non-static member "
5746 "function %q+#D is not a literal type", fun
);
5747 explain_non_literal_class (DECL_CONTEXT (fun
));
5751 else if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fun
)))
5755 error ("%q#T has virtual base classes", DECL_CONTEXT (fun
));
5761 /* Subroutine of build_constexpr_constructor_member_initializers.
5762 The expression tree T represents a data member initialization
5763 in a (constexpr) constructor definition. Build a pairing of
5764 the data member with its initializer, and prepend that pair
5765 to the existing initialization pair INITS. */
5768 build_data_member_initialization (tree t
, VEC(constructor_elt
,gc
) **vec
)
5771 if (TREE_CODE (t
) == CLEANUP_POINT_EXPR
)
5772 t
= TREE_OPERAND (t
, 0);
5773 if (TREE_CODE (t
) == EXPR_STMT
)
5774 t
= TREE_OPERAND (t
, 0);
5775 if (t
== error_mark_node
)
5777 if (TREE_CODE (t
) == STATEMENT_LIST
)
5779 tree_stmt_iterator i
;
5780 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
5782 if (! build_data_member_initialization (tsi_stmt (i
), vec
))
5787 if (TREE_CODE (t
) == CLEANUP_STMT
)
5789 /* We can't see a CLEANUP_STMT in a constructor for a literal class,
5790 but we can in a constexpr constructor for a non-literal class. Just
5791 ignore it; either all the initialization will be constant, in which
5792 case the cleanup can't run, or it can't be constexpr.
5793 Still recurse into CLEANUP_BODY. */
5794 return build_data_member_initialization (CLEANUP_BODY (t
), vec
);
5796 if (TREE_CODE (t
) == CONVERT_EXPR
)
5797 t
= TREE_OPERAND (t
, 0);
5798 if (TREE_CODE (t
) == INIT_EXPR
5799 || TREE_CODE (t
) == MODIFY_EXPR
)
5801 member
= TREE_OPERAND (t
, 0);
5802 init
= unshare_expr (TREE_OPERAND (t
, 1));
5806 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
5807 member
= CALL_EXPR_ARG (t
, 0);
5808 /* We don't use build_cplus_new here because it complains about
5809 abstract bases. Leaving the call unwrapped means that it has the
5810 wrong type, but cxx_eval_constant_expression doesn't care. */
5811 init
= unshare_expr (t
);
5813 if (TREE_CODE (member
) == INDIRECT_REF
)
5814 member
= TREE_OPERAND (member
, 0);
5815 if (TREE_CODE (member
) == NOP_EXPR
)
5819 if (TREE_CODE (op
) == ADDR_EXPR
)
5821 gcc_assert (same_type_ignoring_top_level_qualifiers_p
5822 (TREE_TYPE (TREE_TYPE (op
)),
5823 TREE_TYPE (TREE_TYPE (member
))));
5824 /* Initializing a cv-qualified member; we need to look through
5828 else if (op
== current_class_ptr
5829 && (same_type_ignoring_top_level_qualifiers_p
5830 (TREE_TYPE (TREE_TYPE (member
)),
5831 current_class_type
)))
5832 /* Delegating constructor. */
5836 /* This is an initializer for an empty base; keep it for now so
5837 we can check it in cxx_eval_bare_aggregate. */
5838 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member
))));
5841 if (TREE_CODE (member
) == ADDR_EXPR
)
5842 member
= TREE_OPERAND (member
, 0);
5843 if (TREE_CODE (member
) == COMPONENT_REF
5844 /* If we're initializing a member of a subaggregate, it's a vtable
5845 pointer. Leave it as COMPONENT_REF so we remember the path to get
5847 && TREE_CODE (TREE_OPERAND (member
, 0)) != COMPONENT_REF
)
5848 member
= TREE_OPERAND (member
, 1);
5849 CONSTRUCTOR_APPEND_ELT (*vec
, member
, init
);
5853 /* Make sure that there are no statements after LAST in the constructor
5854 body represented by LIST. */
5857 check_constexpr_ctor_body (tree last
, tree list
)
5860 if (TREE_CODE (list
) == STATEMENT_LIST
)
5862 tree_stmt_iterator i
= tsi_last (list
);
5863 for (; !tsi_end_p (i
); tsi_prev (&i
))
5865 tree t
= tsi_stmt (i
);
5868 if (TREE_CODE (t
) == BIND_EXPR
)
5870 if (!check_constexpr_ctor_body (last
, BIND_EXPR_BODY (t
)))
5875 /* We currently allow typedefs and static_assert.
5876 FIXME allow them in the standard, too. */
5877 if (TREE_CODE (t
) != STATIC_ASSERT
)
5884 else if (list
!= last
5885 && TREE_CODE (list
) != STATIC_ASSERT
)
5889 error ("constexpr constructor does not have empty body");
5890 DECL_DECLARED_CONSTEXPR_P (current_function_decl
) = false;
5895 /* Build compile-time evalable representations of member-initializer list
5896 for a constexpr constructor. */
5899 build_constexpr_constructor_member_initializers (tree type
, tree body
)
5901 VEC(constructor_elt
,gc
) *vec
= NULL
;
5903 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
5904 || TREE_CODE (body
) == EH_SPEC_BLOCK
)
5905 body
= TREE_OPERAND (body
, 0);
5906 if (TREE_CODE (body
) == STATEMENT_LIST
)
5907 body
= STATEMENT_LIST_HEAD (body
)->stmt
;
5908 body
= BIND_EXPR_BODY (body
);
5909 if (TREE_CODE (body
) == CLEANUP_POINT_EXPR
)
5911 body
= TREE_OPERAND (body
, 0);
5912 if (TREE_CODE (body
) == EXPR_STMT
)
5913 body
= TREE_OPERAND (body
, 0);
5914 if (TREE_CODE (body
) == INIT_EXPR
5915 && (same_type_ignoring_top_level_qualifiers_p
5916 (TREE_TYPE (TREE_OPERAND (body
, 0)),
5917 current_class_type
)))
5920 return TREE_OPERAND (body
, 1);
5922 ok
= build_data_member_initialization (body
, &vec
);
5924 else if (TREE_CODE (body
) == STATEMENT_LIST
)
5926 tree_stmt_iterator i
;
5927 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
5929 ok
= build_data_member_initialization (tsi_stmt (i
), &vec
);
5934 else if (TREE_CODE (body
) == TRY_BLOCK
)
5936 error ("body of %<constexpr%> constructor cannot be "
5937 "a function-try-block");
5938 return error_mark_node
;
5940 else if (EXPR_P (body
))
5941 ok
= build_data_member_initialization (body
, &vec
);
5943 gcc_assert (errorcount
> 0);
5946 if (VEC_length (constructor_elt
, vec
) > 0)
5948 /* In a delegating constructor, return the target. */
5949 constructor_elt
*ce
= VEC_index (constructor_elt
, vec
, 0);
5950 if (ce
->index
== current_class_ptr
)
5953 VEC_free (constructor_elt
, gc
, vec
);
5957 return build_constructor (type
, vec
);
5960 return error_mark_node
;
5963 /* Subroutine of register_constexpr_fundef. BODY is the body of a function
5964 declared to be constexpr, or a sub-statement thereof. Returns the
5965 return value if suitable, error_mark_node for a statement not allowed in
5966 a constexpr function, or NULL_TREE if no return value was found. */
5969 constexpr_fn_retval (tree body
)
5971 switch (TREE_CODE (body
))
5973 case STATEMENT_LIST
:
5975 tree_stmt_iterator i
;
5976 tree expr
= NULL_TREE
;
5977 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
5979 tree s
= constexpr_fn_retval (tsi_stmt (i
));
5980 if (s
== error_mark_node
)
5981 return error_mark_node
;
5982 else if (s
== NULL_TREE
)
5983 /* Keep iterating. */;
5985 /* Multiple return statements. */
5986 return error_mark_node
;
5994 return unshare_expr (TREE_OPERAND (body
, 0));
5997 if (TREE_CODE (DECL_EXPR_DECL (body
)) == USING_DECL
)
5999 return error_mark_node
;
6001 case CLEANUP_POINT_EXPR
:
6002 return constexpr_fn_retval (TREE_OPERAND (body
, 0));
6008 return error_mark_node
;
6012 /* Subroutine of register_constexpr_fundef. BODY is the DECL_SAVED_TREE of
6013 FUN; do the necessary transformations to turn it into a single expression
6014 that we can store in the hash table. */
6017 massage_constexpr_body (tree fun
, tree body
)
6019 if (DECL_CONSTRUCTOR_P (fun
))
6020 body
= build_constexpr_constructor_member_initializers
6021 (DECL_CONTEXT (fun
), body
);
6024 if (TREE_CODE (body
) == EH_SPEC_BLOCK
)
6025 body
= EH_SPEC_STMTS (body
);
6026 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
6027 body
= TREE_OPERAND (body
, 0);
6028 if (TREE_CODE (body
) == BIND_EXPR
)
6029 body
= BIND_EXPR_BODY (body
);
6030 body
= constexpr_fn_retval (body
);
6035 /* FUN is a constexpr constructor with massaged body BODY. Return true
6036 if some bases/fields are uninitialized, and complain if COMPLAIN. */
6039 cx_check_missing_mem_inits (tree fun
, tree body
, bool complain
)
6046 if (TREE_CODE (body
) != CONSTRUCTOR
)
6049 nelts
= CONSTRUCTOR_NELTS (body
);
6050 ctype
= DECL_CONTEXT (fun
);
6051 field
= TYPE_FIELDS (ctype
);
6053 if (TREE_CODE (ctype
) == UNION_TYPE
)
6055 if (nelts
== 0 && next_initializable_field (field
))
6058 error ("%<constexpr%> constructor for union %qT must "
6059 "initialize exactly one non-static data member", ctype
);
6066 for (i
= 0; i
<= nelts
; ++i
)
6073 index
= CONSTRUCTOR_ELT (body
, i
)->index
;
6074 /* Skip base and vtable inits. */
6075 if (TREE_CODE (index
) != FIELD_DECL
)
6078 for (; field
!= index
; field
= DECL_CHAIN (field
))
6081 if (TREE_CODE (field
) != FIELD_DECL
6082 || (DECL_C_BIT_FIELD (field
) && !DECL_NAME (field
)))
6084 ftype
= strip_array_types (TREE_TYPE (field
));
6085 if (type_has_constexpr_default_constructor (ftype
))
6087 /* It's OK to skip a member with a trivial constexpr ctor.
6088 A constexpr ctor that isn't trivial should have been
6090 gcc_checking_assert (!TYPE_HAS_COMPLEX_DFLT (ftype
)
6091 || errorcount
!= 0);
6096 error ("uninitialized member %qD in %<constexpr%> constructor",
6100 if (field
== NULL_TREE
)
6102 field
= DECL_CHAIN (field
);
6108 /* We are processing the definition of the constexpr function FUN.
6109 Check that its BODY fulfills the propriate requirements and
6110 enter it in the constexpr function definition table.
6111 For constructor BODY is actually the TREE_LIST of the
6112 member-initializer list. */
6115 register_constexpr_fundef (tree fun
, tree body
)
6117 constexpr_fundef entry
;
6118 constexpr_fundef
**slot
;
6120 if (!is_valid_constexpr_fn (fun
, !DECL_GENERATED_P (fun
)))
6123 body
= massage_constexpr_body (fun
, body
);
6124 if (body
== NULL_TREE
|| body
== error_mark_node
)
6126 if (!DECL_CONSTRUCTOR_P (fun
))
6127 error ("body of constexpr function %qD not a return-statement", fun
);
6131 if (!potential_rvalue_constant_expression (body
))
6133 if (!DECL_GENERATED_P (fun
))
6134 require_potential_rvalue_constant_expression (body
);
6138 if (DECL_CONSTRUCTOR_P (fun
)
6139 && cx_check_missing_mem_inits (fun
, body
, !DECL_GENERATED_P (fun
)))
6142 /* Create the constexpr function table if necessary. */
6143 if (constexpr_fundef_table
== NULL
)
6144 constexpr_fundef_table
= htab_create_ggc (101,
6145 constexpr_fundef_hash
,
6146 constexpr_fundef_equal
,
6150 slot
= (constexpr_fundef
**)
6151 htab_find_slot (constexpr_fundef_table
, &entry
, INSERT
);
6153 gcc_assert (*slot
== NULL
);
6154 *slot
= ggc_alloc_constexpr_fundef ();
6160 /* FUN is a non-constexpr function called in a context that requires a
6161 constant expression. If it comes from a constexpr template, explain why
6162 the instantiation isn't constexpr. */
6165 explain_invalid_constexpr_fn (tree fun
)
6167 static struct pointer_set_t
*diagnosed
;
6169 location_t save_loc
;
6170 /* Only diagnose defaulted functions or instantiations. */
6171 if (!DECL_DEFAULTED_FN (fun
)
6172 && !is_instantiation_of_constexpr (fun
))
6174 if (diagnosed
== NULL
)
6175 diagnosed
= pointer_set_create ();
6176 if (pointer_set_insert (diagnosed
, fun
) != 0)
6177 /* Already explained. */
6180 save_loc
= input_location
;
6181 input_location
= DECL_SOURCE_LOCATION (fun
);
6182 inform (0, "%q+D is not usable as a constexpr function because:", fun
);
6183 /* First check the declaration. */
6184 if (is_valid_constexpr_fn (fun
, true))
6186 /* Then if it's OK, the body. */
6187 if (DECL_DEFAULTED_FN (fun
))
6188 explain_implicit_non_constexpr (fun
);
6191 body
= massage_constexpr_body (fun
, DECL_SAVED_TREE (fun
));
6192 require_potential_rvalue_constant_expression (body
);
6193 if (DECL_CONSTRUCTOR_P (fun
))
6194 cx_check_missing_mem_inits (fun
, body
, true);
6197 input_location
= save_loc
;
6200 /* Objects of this type represent calls to constexpr functions
6201 along with the bindings of parameters to their arguments, for
6202 the purpose of compile time evaluation. */
6204 typedef struct GTY(()) constexpr_call
{
6205 /* Description of the constexpr function definition. */
6206 constexpr_fundef
*fundef
;
6207 /* Parameter bindings environment. A TREE_LIST where each TREE_PURPOSE
6208 is a parameter _DECL and the TREE_VALUE is the value of the parameter.
6209 Note: This arrangement is made to accomodate the use of
6210 iterative_hash_template_arg (see pt.c). If you change this
6211 representation, also change the hash calculation in
6212 cxx_eval_call_expression. */
6214 /* Result of the call.
6215 NULL means the call is being evaluated.
6216 error_mark_node means that the evaluation was erroneous;
6217 otherwise, the actuall value of the call. */
6219 /* The hash of this call; we remember it here to avoid having to
6220 recalculate it when expanding the hash table. */
6224 /* A table of all constexpr calls that have been evaluated by the
6225 compiler in this translation unit. */
6227 static GTY ((param_is (constexpr_call
))) htab_t constexpr_call_table
;
6229 static tree
cxx_eval_constant_expression (const constexpr_call
*, tree
,
6230 bool, bool, bool *);
6231 static tree
cxx_eval_vec_perm_expr (const constexpr_call
*, tree
, bool, bool,
6235 /* Compute a hash value for a constexpr call representation. */
6238 constexpr_call_hash (const void *p
)
6240 const constexpr_call
*info
= (const constexpr_call
*) p
;
6244 /* Return 1 if the objects pointed to by P and Q represent calls
6245 to the same constexpr function with the same arguments.
6246 Otherwise, return 0. */
6249 constexpr_call_equal (const void *p
, const void *q
)
6251 const constexpr_call
*lhs
= (const constexpr_call
*) p
;
6252 const constexpr_call
*rhs
= (const constexpr_call
*) q
;
6257 if (!constexpr_fundef_equal (lhs
->fundef
, rhs
->fundef
))
6259 lhs_bindings
= lhs
->bindings
;
6260 rhs_bindings
= rhs
->bindings
;
6261 while (lhs_bindings
!= NULL
&& rhs_bindings
!= NULL
)
6263 tree lhs_arg
= TREE_VALUE (lhs_bindings
);
6264 tree rhs_arg
= TREE_VALUE (rhs_bindings
);
6265 gcc_assert (TREE_TYPE (lhs_arg
) == TREE_TYPE (rhs_arg
));
6266 if (!cp_tree_equal (lhs_arg
, rhs_arg
))
6268 lhs_bindings
= TREE_CHAIN (lhs_bindings
);
6269 rhs_bindings
= TREE_CHAIN (rhs_bindings
);
6271 return lhs_bindings
== rhs_bindings
;
6274 /* Initialize the constexpr call table, if needed. */
6277 maybe_initialize_constexpr_call_table (void)
6279 if (constexpr_call_table
== NULL
)
6280 constexpr_call_table
= htab_create_ggc (101,
6281 constexpr_call_hash
,
6282 constexpr_call_equal
,
6286 /* Return true if T designates the implied `this' parameter. */
6289 is_this_parameter (tree t
)
6291 return t
== current_class_ptr
;
6294 /* We have an expression tree T that represents a call, either CALL_EXPR
6295 or AGGR_INIT_EXPR. If the call is lexically to a named function,
6296 retrun the _DECL for that function. */
6299 get_function_named_in_call (tree t
)
6302 switch (TREE_CODE (t
))
6305 fun
= CALL_EXPR_FN (t
);
6308 case AGGR_INIT_EXPR
:
6309 fun
= AGGR_INIT_EXPR_FN (t
);
6316 if (TREE_CODE (fun
) == ADDR_EXPR
6317 && TREE_CODE (TREE_OPERAND (fun
, 0)) == FUNCTION_DECL
)
6318 fun
= TREE_OPERAND (fun
, 0);
6322 /* We have an expression tree T that represents a call, either CALL_EXPR
6323 or AGGR_INIT_EXPR. Return the Nth argument. */
6326 get_nth_callarg (tree t
, int n
)
6328 switch (TREE_CODE (t
))
6331 return CALL_EXPR_ARG (t
, n
);
6333 case AGGR_INIT_EXPR
:
6334 return AGGR_INIT_EXPR_ARG (t
, n
);
6342 /* Look up the binding of the function parameter T in a constexpr
6343 function call context CALL. */
6346 lookup_parameter_binding (const constexpr_call
*call
, tree t
)
6348 tree b
= purpose_member (t
, call
->bindings
);
6349 return TREE_VALUE (b
);
6352 /* Attempt to evaluate T which represents a call to a builtin function.
6353 We assume here that all builtin functions evaluate to scalar types
6354 represented by _CST nodes. */
6357 cxx_eval_builtin_function_call (const constexpr_call
*call
, tree t
,
6358 bool allow_non_constant
, bool addr
,
6359 bool *non_constant_p
)
6361 const int nargs
= call_expr_nargs (t
);
6362 tree
*args
= (tree
*) alloca (nargs
* sizeof (tree
));
6365 for (i
= 0; i
< nargs
; ++i
)
6367 args
[i
] = cxx_eval_constant_expression (call
, CALL_EXPR_ARG (t
, i
),
6368 allow_non_constant
, addr
,
6370 if (allow_non_constant
&& *non_constant_p
)
6373 if (*non_constant_p
)
6375 new_call
= build_call_array_loc (EXPR_LOCATION (t
), TREE_TYPE (t
),
6376 CALL_EXPR_FN (t
), nargs
, args
);
6377 return fold (new_call
);
6380 /* TEMP is the constant value of a temporary object of type TYPE. Adjust
6381 the type of the value to match. */
6384 adjust_temp_type (tree type
, tree temp
)
6386 if (TREE_TYPE (temp
) == type
)
6388 /* Avoid wrapping an aggregate value in a NOP_EXPR. */
6389 if (TREE_CODE (temp
) == CONSTRUCTOR
)
6390 return build_constructor (type
, CONSTRUCTOR_ELTS (temp
));
6391 gcc_assert (SCALAR_TYPE_P (type
));
6392 return cp_fold_convert (type
, temp
);
6395 /* Subroutine of cxx_eval_call_expression.
6396 We are processing a call expression (either CALL_EXPR or
6397 AGGR_INIT_EXPR) in the call context of OLD_CALL. Evaluate
6398 all arguments and bind their values to correspondings
6399 parameters, making up the NEW_CALL context. */
6402 cxx_bind_parameters_in_call (const constexpr_call
*old_call
, tree t
,
6403 constexpr_call
*new_call
,
6404 bool allow_non_constant
,
6405 bool *non_constant_p
)
6407 const int nargs
= call_expr_nargs (t
);
6408 tree fun
= new_call
->fundef
->decl
;
6409 tree parms
= DECL_ARGUMENTS (fun
);
6411 for (i
= 0; i
< nargs
; ++i
)
6414 tree type
= parms
? TREE_TYPE (parms
) : void_type_node
;
6415 /* For member function, the first argument is a pointer to the implied
6416 object. And for an object contruction, don't bind `this' before
6417 it is fully constructed. */
6418 if (i
== 0 && DECL_CONSTRUCTOR_P (fun
))
6420 x
= get_nth_callarg (t
, i
);
6421 arg
= cxx_eval_constant_expression (old_call
, x
, allow_non_constant
,
6422 TREE_CODE (type
) == REFERENCE_TYPE
,
6424 /* Don't VERIFY_CONSTANT here. */
6425 if (*non_constant_p
&& allow_non_constant
)
6427 /* Just discard ellipsis args after checking their constantitude. */
6430 if (*non_constant_p
)
6431 /* Don't try to adjust the type of non-constant args. */
6434 /* Make sure the binding has the same type as the parm. */
6435 if (TREE_CODE (type
) != REFERENCE_TYPE
)
6436 arg
= adjust_temp_type (type
, arg
);
6437 new_call
->bindings
= tree_cons (parms
, arg
, new_call
->bindings
);
6439 parms
= TREE_CHAIN (parms
);
6443 /* Variables and functions to manage constexpr call expansion context.
6444 These do not need to be marked for PCH or GC. */
6446 /* FIXME remember and print actual constant arguments. */
6447 static VEC(tree
,heap
) *call_stack
= NULL
;
6448 static int call_stack_tick
;
6449 static int last_cx_error_tick
;
6452 push_cx_call_context (tree call
)
6455 if (!EXPR_HAS_LOCATION (call
))
6456 SET_EXPR_LOCATION (call
, input_location
);
6457 VEC_safe_push (tree
, heap
, call_stack
, call
);
6458 if (VEC_length (tree
, call_stack
) > (unsigned) max_constexpr_depth
)
6464 pop_cx_call_context (void)
6467 VEC_pop (tree
, call_stack
);
6471 cx_error_context (void)
6473 VEC(tree
,heap
) *r
= NULL
;
6474 if (call_stack_tick
!= last_cx_error_tick
6475 && !VEC_empty (tree
, call_stack
))
6477 last_cx_error_tick
= call_stack_tick
;
6481 /* Subroutine of cxx_eval_constant_expression.
6482 Evaluate the call expression tree T in the context of OLD_CALL expression
6486 cxx_eval_call_expression (const constexpr_call
*old_call
, tree t
,
6487 bool allow_non_constant
, bool addr
,
6488 bool *non_constant_p
)
6490 location_t loc
= EXPR_LOC_OR_HERE (t
);
6491 tree fun
= get_function_named_in_call (t
);
6493 constexpr_call new_call
= { NULL
, NULL
, NULL
, 0 };
6494 constexpr_call
**slot
;
6495 constexpr_call
*entry
;
6498 if (TREE_CODE (fun
) != FUNCTION_DECL
)
6500 /* Might be a constexpr function pointer. */
6501 fun
= cxx_eval_constant_expression (old_call
, fun
, allow_non_constant
,
6502 /*addr*/false, non_constant_p
);
6503 if (TREE_CODE (fun
) == ADDR_EXPR
)
6504 fun
= TREE_OPERAND (fun
, 0);
6506 if (TREE_CODE (fun
) != FUNCTION_DECL
)
6508 if (!allow_non_constant
&& !*non_constant_p
)
6509 error_at (loc
, "expression %qE does not designate a constexpr "
6511 *non_constant_p
= true;
6514 if (DECL_CLONED_FUNCTION_P (fun
))
6515 fun
= DECL_CLONED_FUNCTION (fun
);
6516 if (is_builtin_fn (fun
))
6517 return cxx_eval_builtin_function_call (old_call
, t
, allow_non_constant
,
6518 addr
, non_constant_p
);
6519 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
6521 if (!allow_non_constant
)
6523 error_at (loc
, "call to non-constexpr function %qD", fun
);
6524 explain_invalid_constexpr_fn (fun
);
6526 *non_constant_p
= true;
6530 /* Shortcut trivial copy constructor/op=. */
6531 if (call_expr_nargs (t
) == 2 && trivial_fn_p (fun
))
6533 tree arg
= convert_from_reference (get_nth_callarg (t
, 1));
6534 return cxx_eval_constant_expression (old_call
, arg
, allow_non_constant
,
6535 addr
, non_constant_p
);
6538 /* If in direct recursive call, optimize definition search. */
6539 if (old_call
!= NULL
&& old_call
->fundef
->decl
== fun
)
6540 new_call
.fundef
= old_call
->fundef
;
6543 new_call
.fundef
= retrieve_constexpr_fundef (fun
);
6544 if (new_call
.fundef
== NULL
|| new_call
.fundef
->body
== NULL
)
6546 if (!allow_non_constant
)
6548 if (DECL_INITIAL (fun
))
6550 /* The definition of fun was somehow unsuitable. */
6551 error_at (loc
, "%qD called in a constant expression", fun
);
6552 explain_invalid_constexpr_fn (fun
);
6555 error_at (loc
, "%qD used before its definition", fun
);
6557 *non_constant_p
= true;
6561 cxx_bind_parameters_in_call (old_call
, t
, &new_call
,
6562 allow_non_constant
, non_constant_p
);
6563 if (*non_constant_p
)
6566 depth_ok
= push_cx_call_context (t
);
6569 = iterative_hash_template_arg (new_call
.bindings
,
6570 constexpr_fundef_hash (new_call
.fundef
));
6572 /* If we have seen this call before, we are done. */
6573 maybe_initialize_constexpr_call_table ();
6574 slot
= (constexpr_call
**)
6575 htab_find_slot (constexpr_call_table
, &new_call
, INSERT
);
6579 /* We need to keep a pointer to the entry, not just the slot, as the
6580 slot can move in the call to cxx_eval_builtin_function_call. */
6581 *slot
= entry
= ggc_alloc_constexpr_call ();
6584 /* Calls which are in progress have their result set to NULL
6585 so that we can detect circular dependencies. */
6586 else if (entry
->result
== NULL
)
6588 if (!allow_non_constant
)
6589 error ("call has circular dependency");
6590 *non_constant_p
= true;
6591 entry
->result
= result
= error_mark_node
;
6596 if (!allow_non_constant
)
6597 error ("constexpr evaluation depth exceeds maximum of %d (use "
6598 "-fconstexpr-depth= to increase the maximum)",
6599 max_constexpr_depth
);
6600 *non_constant_p
= true;
6601 entry
->result
= result
= error_mark_node
;
6605 result
= entry
->result
;
6606 if (!result
|| result
== error_mark_node
)
6607 result
= (cxx_eval_constant_expression
6608 (&new_call
, new_call
.fundef
->body
,
6609 allow_non_constant
, addr
,
6611 if (result
== error_mark_node
)
6612 *non_constant_p
= true;
6613 if (*non_constant_p
)
6614 entry
->result
= result
= error_mark_node
;
6617 /* If this was a call to initialize an object, set the type of
6618 the CONSTRUCTOR to the type of that object. */
6619 if (DECL_CONSTRUCTOR_P (fun
))
6621 tree ob_arg
= get_nth_callarg (t
, 0);
6622 STRIP_NOPS (ob_arg
);
6623 gcc_assert (TREE_CODE (TREE_TYPE (ob_arg
)) == POINTER_TYPE
6624 && CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (ob_arg
))));
6625 result
= adjust_temp_type (TREE_TYPE (TREE_TYPE (ob_arg
)),
6628 entry
->result
= result
;
6632 pop_cx_call_context ();
6633 return unshare_expr (result
);
6636 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
6639 reduced_constant_expression_p (tree t
)
6641 if (TREE_OVERFLOW_P (t
))
6642 /* Integer overflow makes this not a constant expression. */
6644 /* FIXME are we calling this too much? */
6645 return initializer_constant_valid_p (t
, TREE_TYPE (t
)) != NULL_TREE
;
6648 /* Some expressions may have constant operands but are not constant
6649 themselves, such as 1/0. Call this function (or rather, the macro
6650 following it) to check for that condition.
6652 We only call this in places that require an arithmetic constant, not in
6653 places where we might have a non-constant expression that can be a
6654 component of a constant expression, such as the address of a constexpr
6655 variable that might be dereferenced later. */
6658 verify_constant (tree t
, bool allow_non_constant
, bool *non_constant_p
)
6660 if (!*non_constant_p
&& !reduced_constant_expression_p (t
))
6662 if (!allow_non_constant
)
6664 /* If T was already folded to a _CST with TREE_OVERFLOW set,
6665 printing the folded constant isn't helpful. */
6666 if (TREE_OVERFLOW_P (t
))
6668 permerror (input_location
, "overflow in constant expression");
6669 /* If we're being permissive (and are in an enforcing
6670 context), consider this constant. */
6671 if (flag_permissive
)
6675 error ("%q+E is not a constant expression", t
);
6677 *non_constant_p
= true;
6679 return *non_constant_p
;
6681 #define VERIFY_CONSTANT(X) \
6683 if (verify_constant ((X), allow_non_constant, non_constant_p)) \
6687 /* Subroutine of cxx_eval_constant_expression.
6688 Attempt to reduce the unary expression tree T to a compile time value.
6689 If successful, return the value. Otherwise issue a diagnostic
6690 and return error_mark_node. */
6693 cxx_eval_unary_expression (const constexpr_call
*call
, tree t
,
6694 bool allow_non_constant
, bool addr
,
6695 bool *non_constant_p
)
6698 tree orig_arg
= TREE_OPERAND (t
, 0);
6699 tree arg
= cxx_eval_constant_expression (call
, orig_arg
, allow_non_constant
,
6700 addr
, non_constant_p
);
6701 VERIFY_CONSTANT (arg
);
6702 if (arg
== orig_arg
)
6704 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), arg
);
6705 VERIFY_CONSTANT (r
);
6709 /* Subroutine of cxx_eval_constant_expression.
6710 Like cxx_eval_unary_expression, except for binary expressions. */
6713 cxx_eval_binary_expression (const constexpr_call
*call
, tree t
,
6714 bool allow_non_constant
, bool addr
,
6715 bool *non_constant_p
)
6718 tree orig_lhs
= TREE_OPERAND (t
, 0);
6719 tree orig_rhs
= TREE_OPERAND (t
, 1);
6721 lhs
= cxx_eval_constant_expression (call
, orig_lhs
,
6722 allow_non_constant
, addr
,
6724 VERIFY_CONSTANT (lhs
);
6725 rhs
= cxx_eval_constant_expression (call
, orig_rhs
,
6726 allow_non_constant
, addr
,
6728 VERIFY_CONSTANT (rhs
);
6729 if (lhs
== orig_lhs
&& rhs
== orig_rhs
)
6731 r
= fold_build2 (TREE_CODE (t
), TREE_TYPE (t
), lhs
, rhs
);
6732 VERIFY_CONSTANT (r
);
6736 /* Subroutine of cxx_eval_constant_expression.
6737 Attempt to evaluate condition expressions. Dead branches are not
6741 cxx_eval_conditional_expression (const constexpr_call
*call
, tree t
,
6742 bool allow_non_constant
, bool addr
,
6743 bool *non_constant_p
)
6745 tree val
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 0),
6746 allow_non_constant
, addr
,
6748 VERIFY_CONSTANT (val
);
6749 /* Don't VERIFY_CONSTANT the other operands. */
6750 if (integer_zerop (val
))
6751 return cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 2),
6752 allow_non_constant
, addr
,
6754 return cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 1),
6755 allow_non_constant
, addr
,
6759 /* Subroutine of cxx_eval_constant_expression.
6760 Attempt to reduce a reference to an array slot. */
6763 cxx_eval_array_reference (const constexpr_call
*call
, tree t
,
6764 bool allow_non_constant
, bool addr
,
6765 bool *non_constant_p
)
6767 tree oldary
= TREE_OPERAND (t
, 0);
6768 tree ary
= cxx_eval_constant_expression (call
, oldary
,
6769 allow_non_constant
, addr
,
6774 unsigned len
, elem_nchars
= 1;
6775 if (*non_constant_p
)
6777 oldidx
= TREE_OPERAND (t
, 1);
6778 index
= cxx_eval_constant_expression (call
, oldidx
,
6779 allow_non_constant
, false,
6781 VERIFY_CONSTANT (index
);
6782 if (addr
&& ary
== oldary
&& index
== oldidx
)
6785 return build4 (ARRAY_REF
, TREE_TYPE (t
), ary
, index
, NULL
, NULL
);
6786 elem_type
= TREE_TYPE (TREE_TYPE (ary
));
6787 if (TREE_CODE (ary
) == CONSTRUCTOR
)
6788 len
= CONSTRUCTOR_NELTS (ary
);
6789 else if (TREE_CODE (ary
) == STRING_CST
)
6791 elem_nchars
= (TYPE_PRECISION (elem_type
)
6792 / TYPE_PRECISION (char_type_node
));
6793 len
= (unsigned) TREE_STRING_LENGTH (ary
) / elem_nchars
;
6797 /* We can't do anything with other tree codes, so use
6798 VERIFY_CONSTANT to complain and fail. */
6799 VERIFY_CONSTANT (ary
);
6802 if (compare_tree_int (index
, len
) >= 0)
6804 if (tree_int_cst_lt (index
, array_type_nelts_top (TREE_TYPE (ary
))))
6806 /* If it's within the array bounds but doesn't have an explicit
6807 initializer, it's value-initialized. */
6808 tree val
= build_value_init (elem_type
, tf_warning_or_error
);
6809 return cxx_eval_constant_expression (call
, val
,
6810 allow_non_constant
, addr
,
6814 if (!allow_non_constant
)
6815 error ("array subscript out of bound");
6816 *non_constant_p
= true;
6819 i
= tree_low_cst (index
, 0);
6820 if (TREE_CODE (ary
) == CONSTRUCTOR
)
6821 return VEC_index (constructor_elt
, CONSTRUCTOR_ELTS (ary
), i
)->value
;
6822 else if (elem_nchars
== 1)
6823 return build_int_cst (cv_unqualified (TREE_TYPE (TREE_TYPE (ary
))),
6824 TREE_STRING_POINTER (ary
)[i
]);
6827 tree type
= cv_unqualified (TREE_TYPE (TREE_TYPE (ary
)));
6828 return native_interpret_expr (type
, (const unsigned char *)
6829 TREE_STRING_POINTER (ary
)
6830 + i
* elem_nchars
, elem_nchars
);
6832 /* Don't VERIFY_CONSTANT here. */
6835 /* Subroutine of cxx_eval_constant_expression.
6836 Attempt to reduce a field access of a value of class type. */
6839 cxx_eval_component_reference (const constexpr_call
*call
, tree t
,
6840 bool allow_non_constant
, bool addr
,
6841 bool *non_constant_p
)
6843 unsigned HOST_WIDE_INT i
;
6846 tree part
= TREE_OPERAND (t
, 1);
6847 tree orig_whole
= TREE_OPERAND (t
, 0);
6848 tree whole
= cxx_eval_constant_expression (call
, orig_whole
,
6849 allow_non_constant
, addr
,
6851 if (whole
== orig_whole
)
6854 return fold_build3 (COMPONENT_REF
, TREE_TYPE (t
),
6855 whole
, part
, NULL_TREE
);
6856 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
6858 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
6860 if (!allow_non_constant
)
6861 error ("%qE is not a constant expression", orig_whole
);
6862 *non_constant_p
= true;
6864 if (DECL_MUTABLE_P (part
))
6866 if (!allow_non_constant
)
6867 error ("mutable %qD is not usable in a constant expression", part
);
6868 *non_constant_p
= true;
6870 if (*non_constant_p
)
6872 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
6877 if (TREE_CODE (TREE_TYPE (whole
)) == UNION_TYPE
6878 && CONSTRUCTOR_NELTS (whole
) > 0)
6880 /* DR 1188 says we don't have to deal with this. */
6881 if (!allow_non_constant
)
6882 error ("accessing %qD member instead of initialized %qD member in "
6883 "constant expression", part
, CONSTRUCTOR_ELT (whole
, 0)->index
);
6884 *non_constant_p
= true;
6888 /* If there's no explicit init for this field, it's value-initialized. */
6889 value
= build_value_init (TREE_TYPE (t
), tf_warning_or_error
);
6890 return cxx_eval_constant_expression (call
, value
,
6891 allow_non_constant
, addr
,
6895 /* Subroutine of cxx_eval_constant_expression.
6896 Attempt to reduce a field access of a value of class type that is
6897 expressed as a BIT_FIELD_REF. */
6900 cxx_eval_bit_field_ref (const constexpr_call
*call
, tree t
,
6901 bool allow_non_constant
, bool addr
,
6902 bool *non_constant_p
)
6904 tree orig_whole
= TREE_OPERAND (t
, 0);
6905 tree retval
, fldval
, utype
, mask
;
6906 bool fld_seen
= false;
6907 HOST_WIDE_INT istart
, isize
;
6908 tree whole
= cxx_eval_constant_expression (call
, orig_whole
,
6909 allow_non_constant
, addr
,
6911 tree start
, field
, value
;
6912 unsigned HOST_WIDE_INT i
;
6914 if (whole
== orig_whole
)
6916 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
6918 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
6920 if (!allow_non_constant
)
6921 error ("%qE is not a constant expression", orig_whole
);
6922 *non_constant_p
= true;
6924 if (*non_constant_p
)
6927 start
= TREE_OPERAND (t
, 2);
6928 istart
= tree_low_cst (start
, 0);
6929 isize
= tree_low_cst (TREE_OPERAND (t
, 1), 0);
6930 utype
= TREE_TYPE (t
);
6931 if (!TYPE_UNSIGNED (utype
))
6932 utype
= build_nonstandard_integer_type (TYPE_PRECISION (utype
), 1);
6933 retval
= build_int_cst (utype
, 0);
6934 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
6936 tree bitpos
= bit_position (field
);
6937 if (bitpos
== start
&& DECL_SIZE (field
) == TREE_OPERAND (t
, 1))
6939 if (TREE_CODE (TREE_TYPE (field
)) == INTEGER_TYPE
6940 && TREE_CODE (value
) == INTEGER_CST
6941 && host_integerp (bitpos
, 0)
6942 && host_integerp (DECL_SIZE (field
), 0))
6944 HOST_WIDE_INT bit
= tree_low_cst (bitpos
, 0);
6945 HOST_WIDE_INT sz
= tree_low_cst (DECL_SIZE (field
), 0);
6946 HOST_WIDE_INT shift
;
6947 if (bit
>= istart
&& bit
+ sz
<= istart
+ isize
)
6949 fldval
= fold_convert (utype
, value
);
6950 mask
= build_int_cst_type (utype
, -1);
6951 mask
= fold_build2 (LSHIFT_EXPR
, utype
, mask
,
6952 size_int (TYPE_PRECISION (utype
) - sz
));
6953 mask
= fold_build2 (RSHIFT_EXPR
, utype
, mask
,
6954 size_int (TYPE_PRECISION (utype
) - sz
));
6955 fldval
= fold_build2 (BIT_AND_EXPR
, utype
, fldval
, mask
);
6956 shift
= bit
- istart
;
6957 if (BYTES_BIG_ENDIAN
)
6958 shift
= TYPE_PRECISION (utype
) - shift
- sz
;
6959 fldval
= fold_build2 (LSHIFT_EXPR
, utype
, fldval
,
6961 retval
= fold_build2 (BIT_IOR_EXPR
, utype
, retval
, fldval
);
6967 return fold_convert (TREE_TYPE (t
), retval
);
6969 return error_mark_node
;
6972 /* Subroutine of cxx_eval_constant_expression.
6973 Evaluate a short-circuited logical expression T in the context
6974 of a given constexpr CALL. BAILOUT_VALUE is the value for
6975 early return. CONTINUE_VALUE is used here purely for
6976 sanity check purposes. */
6979 cxx_eval_logical_expression (const constexpr_call
*call
, tree t
,
6980 tree bailout_value
, tree continue_value
,
6981 bool allow_non_constant
, bool addr
,
6982 bool *non_constant_p
)
6985 tree lhs
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 0),
6986 allow_non_constant
, addr
,
6988 VERIFY_CONSTANT (lhs
);
6989 if (tree_int_cst_equal (lhs
, bailout_value
))
6991 gcc_assert (tree_int_cst_equal (lhs
, continue_value
));
6992 r
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 1),
6993 allow_non_constant
, addr
, non_constant_p
);
6994 VERIFY_CONSTANT (r
);
6998 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
6999 CONSTRUCTOR elements to initialize (part of) an object containing that
7000 field. Return a pointer to the constructor_elt corresponding to the
7001 initialization of the field. */
7003 static constructor_elt
*
7004 base_field_constructor_elt (VEC(constructor_elt
,gc
) *v
, tree ref
)
7006 tree aggr
= TREE_OPERAND (ref
, 0);
7007 tree field
= TREE_OPERAND (ref
, 1);
7009 constructor_elt
*ce
;
7011 gcc_assert (TREE_CODE (ref
) == COMPONENT_REF
);
7013 if (TREE_CODE (aggr
) == COMPONENT_REF
)
7015 constructor_elt
*base_ce
7016 = base_field_constructor_elt (v
, aggr
);
7017 v
= CONSTRUCTOR_ELTS (base_ce
->value
);
7020 for (i
= 0; VEC_iterate (constructor_elt
, v
, i
, ce
); ++i
)
7021 if (ce
->index
== field
)
7028 /* Subroutine of cxx_eval_constant_expression.
7029 The expression tree T denotes a C-style array or a C-style
7030 aggregate. Reduce it to a constant expression. */
7033 cxx_eval_bare_aggregate (const constexpr_call
*call
, tree t
,
7034 bool allow_non_constant
, bool addr
,
7035 bool *non_constant_p
)
7037 VEC(constructor_elt
,gc
) *v
= CONSTRUCTOR_ELTS (t
);
7038 VEC(constructor_elt
,gc
) *n
= VEC_alloc (constructor_elt
, gc
,
7039 VEC_length (constructor_elt
, v
));
7040 constructor_elt
*ce
;
7042 bool changed
= false;
7043 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t
));
7044 for (i
= 0; VEC_iterate (constructor_elt
, v
, i
, ce
); ++i
)
7046 tree elt
= cxx_eval_constant_expression (call
, ce
->value
,
7047 allow_non_constant
, addr
,
7049 /* Don't VERIFY_CONSTANT here. */
7050 if (allow_non_constant
&& *non_constant_p
)
7052 if (elt
!= ce
->value
)
7054 if (TREE_CODE (ce
->index
) == COMPONENT_REF
)
7056 /* This is an initialization of a vfield inside a base
7057 subaggregate that we already initialized; push this
7058 initialization into the previous initialization. */
7059 constructor_elt
*inner
= base_field_constructor_elt (n
, ce
->index
);
7062 else if (TREE_CODE (ce
->index
) == NOP_EXPR
)
7064 /* This is an initializer for an empty base; now that we've
7065 checked that it's constant, we can ignore it. */
7066 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (ce
->index
))));
7069 CONSTRUCTOR_APPEND_ELT (n
, ce
->index
, elt
);
7071 if (*non_constant_p
|| !changed
)
7074 VEC_free (constructor_elt
, gc
, n
);
7077 t
= build_constructor (TREE_TYPE (t
), n
);
7078 TREE_CONSTANT (t
) = true;
7082 /* Subroutine of cxx_eval_constant_expression.
7083 The expression tree T is a VEC_INIT_EXPR which denotes the desired
7084 initialization of a non-static data member of array type. Reduce it to a
7087 Note that apart from value-initialization (when VALUE_INIT is true),
7088 this is only intended to support value-initialization and the
7089 initializations done by defaulted constructors for classes with
7090 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
7091 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
7092 for the copy/move constructor. */
7095 cxx_eval_vec_init_1 (const constexpr_call
*call
, tree atype
, tree init
,
7096 bool value_init
, bool allow_non_constant
, bool addr
,
7097 bool *non_constant_p
)
7099 tree elttype
= TREE_TYPE (atype
);
7100 int max
= tree_low_cst (array_type_nelts (atype
), 0);
7101 VEC(constructor_elt
,gc
) *n
= VEC_alloc (constructor_elt
, gc
, max
+ 1);
7102 bool pre_init
= false;
7105 /* For the default constructor, build up a call to the default
7106 constructor of the element type. We only need to handle class types
7107 here, as for a constructor to be constexpr, all members must be
7108 initialized, which for a defaulted default constructor means they must
7109 be of a class type with a constexpr default constructor. */
7110 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
7111 /* We only do this at the lowest level. */;
7112 else if (value_init
)
7114 init
= build_value_init (elttype
, tf_warning_or_error
);
7115 init
= cxx_eval_constant_expression
7116 (call
, init
, allow_non_constant
, addr
, non_constant_p
);
7121 VEC(tree
,gc
) *argvec
= make_tree_vector ();
7122 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
7123 &argvec
, elttype
, LOOKUP_NORMAL
,
7124 tf_warning_or_error
);
7125 release_tree_vector (argvec
);
7126 init
= cxx_eval_constant_expression (call
, init
, allow_non_constant
,
7127 addr
, non_constant_p
);
7131 if (*non_constant_p
&& !allow_non_constant
)
7134 for (i
= 0; i
<= max
; ++i
)
7136 tree idx
= build_int_cst (size_type_node
, i
);
7138 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
7140 /* A multidimensional array; recurse. */
7141 if (value_init
|| init
== NULL_TREE
)
7142 eltinit
= NULL_TREE
;
7144 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
7145 tf_warning_or_error
);
7146 eltinit
= cxx_eval_vec_init_1 (call
, elttype
, eltinit
, value_init
,
7147 allow_non_constant
, addr
,
7152 /* Initializing an element using value or default initialization
7153 we just pre-built above. */
7157 eltinit
= unshare_expr (init
);
7161 /* Copying an element. */
7162 VEC(tree
,gc
) *argvec
;
7163 gcc_assert (same_type_ignoring_top_level_qualifiers_p
7164 (atype
, TREE_TYPE (init
)));
7165 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
7166 tf_warning_or_error
);
7167 if (!real_lvalue_p (init
))
7168 eltinit
= move (eltinit
);
7169 argvec
= make_tree_vector ();
7170 VEC_quick_push (tree
, argvec
, eltinit
);
7171 eltinit
= (build_special_member_call
7172 (NULL_TREE
, complete_ctor_identifier
, &argvec
,
7173 elttype
, LOOKUP_NORMAL
, tf_warning_or_error
));
7174 release_tree_vector (argvec
);
7175 eltinit
= cxx_eval_constant_expression
7176 (call
, eltinit
, allow_non_constant
, addr
, non_constant_p
);
7178 if (*non_constant_p
&& !allow_non_constant
)
7180 CONSTRUCTOR_APPEND_ELT (n
, idx
, eltinit
);
7183 if (!*non_constant_p
)
7185 init
= build_constructor (atype
, n
);
7186 TREE_CONSTANT (init
) = true;
7191 VEC_free (constructor_elt
, gc
, n
);
7196 cxx_eval_vec_init (const constexpr_call
*call
, tree t
,
7197 bool allow_non_constant
, bool addr
,
7198 bool *non_constant_p
)
7200 tree atype
= TREE_TYPE (t
);
7201 tree init
= VEC_INIT_EXPR_INIT (t
);
7202 tree r
= cxx_eval_vec_init_1 (call
, atype
, init
,
7203 VEC_INIT_EXPR_VALUE_INIT (t
),
7204 allow_non_constant
, addr
, non_constant_p
);
7205 if (*non_constant_p
)
7211 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
7212 match. We want to be less strict for simple *& folding; if we have a
7213 non-const temporary that we access through a const pointer, that should
7214 work. We handle this here rather than change fold_indirect_ref_1
7215 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
7216 don't really make sense outside of constant expression evaluation. Also
7217 we want to allow folding to COMPONENT_REF, which could cause trouble
7218 with TBAA in fold_indirect_ref_1.
7220 Try to keep this function synced with fold_indirect_ref_1. */
7223 cxx_fold_indirect_ref (location_t loc
, tree type
, tree op0
, bool *empty_base
)
7229 subtype
= TREE_TYPE (sub
);
7230 if (!POINTER_TYPE_P (subtype
))
7233 if (TREE_CODE (sub
) == ADDR_EXPR
)
7235 tree op
= TREE_OPERAND (sub
, 0);
7236 tree optype
= TREE_TYPE (op
);
7238 /* *&CONST_DECL -> to the value of the const decl. */
7239 if (TREE_CODE (op
) == CONST_DECL
)
7240 return DECL_INITIAL (op
);
7241 /* *&p => p; make sure to handle *&"str"[cst] here. */
7242 if (same_type_ignoring_top_level_qualifiers_p (optype
, type
))
7244 tree fop
= fold_read_from_constant_string (op
);
7250 /* *(foo *)&fooarray => fooarray[0] */
7251 else if (TREE_CODE (optype
) == ARRAY_TYPE
7252 && (same_type_ignoring_top_level_qualifiers_p
7253 (type
, TREE_TYPE (optype
))))
7255 tree type_domain
= TYPE_DOMAIN (optype
);
7256 tree min_val
= size_zero_node
;
7257 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
7258 min_val
= TYPE_MIN_VALUE (type_domain
);
7259 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
7260 NULL_TREE
, NULL_TREE
);
7262 /* *(foo *)&complexfoo => __real__ complexfoo */
7263 else if (TREE_CODE (optype
) == COMPLEX_TYPE
7264 && (same_type_ignoring_top_level_qualifiers_p
7265 (type
, TREE_TYPE (optype
))))
7266 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
7267 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
7268 else if (TREE_CODE (optype
) == VECTOR_TYPE
7269 && (same_type_ignoring_top_level_qualifiers_p
7270 (type
, TREE_TYPE (optype
))))
7272 tree part_width
= TYPE_SIZE (type
);
7273 tree index
= bitsize_int (0);
7274 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
, index
);
7276 /* Also handle conversion to an empty base class, which
7277 is represented with a NOP_EXPR. */
7278 else if (is_empty_class (type
)
7279 && CLASS_TYPE_P (optype
)
7280 && DERIVED_FROM_P (type
, optype
))
7285 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
7286 else if (RECORD_OR_UNION_TYPE_P (optype
))
7288 tree field
= TYPE_FIELDS (optype
);
7289 for (; field
; field
= DECL_CHAIN (field
))
7290 if (TREE_CODE (field
) == FIELD_DECL
7291 && integer_zerop (byte_position (field
))
7292 && (same_type_ignoring_top_level_qualifiers_p
7293 (TREE_TYPE (field
), type
)))
7295 return fold_build3 (COMPONENT_REF
, type
, op
, field
, NULL_TREE
);
7300 else if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
7301 && TREE_CODE (TREE_OPERAND (sub
, 1)) == INTEGER_CST
)
7303 tree op00
= TREE_OPERAND (sub
, 0);
7304 tree op01
= TREE_OPERAND (sub
, 1);
7307 if (TREE_CODE (op00
) == ADDR_EXPR
)
7310 op00
= TREE_OPERAND (op00
, 0);
7311 op00type
= TREE_TYPE (op00
);
7313 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
7314 if (TREE_CODE (op00type
) == VECTOR_TYPE
7315 && (same_type_ignoring_top_level_qualifiers_p
7316 (type
, TREE_TYPE (op00type
))))
7318 HOST_WIDE_INT offset
= tree_low_cst (op01
, 0);
7319 tree part_width
= TYPE_SIZE (type
);
7320 unsigned HOST_WIDE_INT part_widthi
= tree_low_cst (part_width
, 0)/BITS_PER_UNIT
;
7321 unsigned HOST_WIDE_INT indexi
= offset
* BITS_PER_UNIT
;
7322 tree index
= bitsize_int (indexi
);
7324 if (offset
/part_widthi
<= TYPE_VECTOR_SUBPARTS (op00type
))
7325 return fold_build3_loc (loc
,
7326 BIT_FIELD_REF
, type
, op00
,
7330 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
7331 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
7332 && (same_type_ignoring_top_level_qualifiers_p
7333 (type
, TREE_TYPE (op00type
))))
7335 tree size
= TYPE_SIZE_UNIT (type
);
7336 if (tree_int_cst_equal (size
, op01
))
7337 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
7339 /* ((foo *)&fooarray)[1] => fooarray[1] */
7340 else if (TREE_CODE (op00type
) == ARRAY_TYPE
7341 && (same_type_ignoring_top_level_qualifiers_p
7342 (type
, TREE_TYPE (op00type
))))
7344 tree type_domain
= TYPE_DOMAIN (op00type
);
7345 tree min_val
= size_zero_node
;
7346 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
7347 min_val
= TYPE_MIN_VALUE (type_domain
);
7348 op01
= size_binop_loc (loc
, EXACT_DIV_EXPR
, op01
,
7349 TYPE_SIZE_UNIT (type
));
7350 op01
= size_binop_loc (loc
, PLUS_EXPR
, op01
, min_val
);
7351 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
7352 NULL_TREE
, NULL_TREE
);
7354 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
7355 else if (RECORD_OR_UNION_TYPE_P (op00type
))
7357 tree field
= TYPE_FIELDS (op00type
);
7358 for (; field
; field
= DECL_CHAIN (field
))
7359 if (TREE_CODE (field
) == FIELD_DECL
7360 && tree_int_cst_equal (byte_position (field
), op01
)
7361 && (same_type_ignoring_top_level_qualifiers_p
7362 (TREE_TYPE (field
), type
)))
7364 return fold_build3 (COMPONENT_REF
, type
, op00
,
7371 /* *(foo *)fooarrptreturn> (*fooarrptr)[0] */
7372 else if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
7373 && (same_type_ignoring_top_level_qualifiers_p
7374 (type
, TREE_TYPE (TREE_TYPE (subtype
)))))
7377 tree min_val
= size_zero_node
;
7378 sub
= cxx_fold_indirect_ref (loc
, TREE_TYPE (subtype
), sub
, NULL
);
7380 sub
= build1_loc (loc
, INDIRECT_REF
, TREE_TYPE (subtype
), sub
);
7381 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
7382 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
7383 min_val
= TYPE_MIN_VALUE (type_domain
);
7384 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
7392 cxx_eval_indirect_ref (const constexpr_call
*call
, tree t
,
7393 bool allow_non_constant
, bool addr
,
7394 bool *non_constant_p
)
7396 tree orig_op0
= TREE_OPERAND (t
, 0);
7397 tree op0
= cxx_eval_constant_expression (call
, orig_op0
, allow_non_constant
,
7398 /*addr*/false, non_constant_p
);
7399 bool empty_base
= false;
7402 /* Don't VERIFY_CONSTANT here. */
7403 if (*non_constant_p
)
7406 r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), op0
,
7410 r
= cxx_eval_constant_expression (call
, r
, allow_non_constant
,
7411 addr
, non_constant_p
);
7416 if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
)
7418 sub
= TREE_OPERAND (sub
, 0);
7421 if (TREE_CODE (sub
) == ADDR_EXPR
)
7423 /* We couldn't fold to a constant value. Make sure it's not
7424 something we should have been able to fold. */
7425 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
7426 (TREE_TYPE (TREE_TYPE (sub
)), TREE_TYPE (t
)));
7427 /* DR 1188 says we don't have to deal with this. */
7428 if (!allow_non_constant
)
7429 error ("accessing value of %qE through a %qT glvalue in a "
7430 "constant expression", build_fold_indirect_ref (sub
),
7432 *non_constant_p
= true;
7437 /* If we're pulling out the value of an empty base, make sure
7438 that the whole object is constant and then return an empty
7442 VERIFY_CONSTANT (r
);
7443 r
= build_constructor (TREE_TYPE (t
), NULL
);
7444 TREE_CONSTANT (r
) = true;
7452 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
7453 Shared between potential_constant_expression and
7454 cxx_eval_constant_expression. */
7457 non_const_var_error (tree r
)
7459 tree type
= TREE_TYPE (r
);
7460 error ("the value of %qD is not usable in a constant "
7462 /* Avoid error cascade. */
7463 if (DECL_INITIAL (r
) == error_mark_node
)
7465 if (DECL_DECLARED_CONSTEXPR_P (r
))
7466 inform (DECL_SOURCE_LOCATION (r
),
7467 "%qD used in its own initializer", r
);
7468 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
7470 if (!CP_TYPE_CONST_P (type
))
7471 inform (DECL_SOURCE_LOCATION (r
),
7472 "%q#D is not const", r
);
7473 else if (CP_TYPE_VOLATILE_P (type
))
7474 inform (DECL_SOURCE_LOCATION (r
),
7475 "%q#D is volatile", r
);
7476 else if (!DECL_INITIAL (r
)
7477 || !TREE_CONSTANT (DECL_INITIAL (r
)))
7478 inform (DECL_SOURCE_LOCATION (r
),
7479 "%qD was not initialized with a constant "
7486 if (cxx_dialect
>= cxx0x
&& !DECL_DECLARED_CONSTEXPR_P (r
))
7487 inform (DECL_SOURCE_LOCATION (r
),
7488 "%qD was not declared %<constexpr%>", r
);
7490 inform (DECL_SOURCE_LOCATION (r
),
7491 "%qD does not have integral or enumeration type",
7496 /* Evaluate VEC_PERM_EXPR (v1, v2, mask). */
7498 cxx_eval_vec_perm_expr (const constexpr_call
*call
, tree t
,
7499 bool allow_non_constant
, bool addr
,
7500 bool * non_constant_p
)
7505 tree elttype
= TREE_TYPE (t
);
7507 for (i
= 0; i
< 3; i
++)
7509 args
[i
] = cxx_eval_constant_expression (call
, TREE_OPERAND (t
, i
),
7510 allow_non_constant
, addr
,
7512 if (*non_constant_p
)
7516 gcc_assert (TREE_CODE (TREE_TYPE (args
[0])) == VECTOR_TYPE
);
7517 gcc_assert (TREE_CODE (TREE_TYPE (args
[1])) == VECTOR_TYPE
);
7518 gcc_assert (TREE_CODE (TREE_TYPE (args
[2])) == VECTOR_TYPE
);
7520 val
= fold_ternary_loc (EXPR_LOCATION (t
), VEC_PERM_EXPR
, elttype
,
7521 args
[0], args
[1], args
[2]);
7522 if (val
!= NULL_TREE
)
7529 /* Attempt to reduce the expression T to a constant value.
7530 On failure, issue diagnostic and return error_mark_node. */
7531 /* FIXME unify with c_fully_fold */
7534 cxx_eval_constant_expression (const constexpr_call
*call
, tree t
,
7535 bool allow_non_constant
, bool addr
,
7536 bool *non_constant_p
)
7540 if (t
== error_mark_node
)
7542 *non_constant_p
= true;
7545 if (CONSTANT_CLASS_P (t
))
7547 if (TREE_CODE (t
) == PTRMEM_CST
)
7548 t
= cplus_expand_constant (t
);
7551 if (TREE_CODE (t
) != NOP_EXPR
7552 && reduced_constant_expression_p (t
))
7555 switch (TREE_CODE (t
))
7560 /* else fall through. */
7562 r
= integral_constant_value (t
);
7563 if (TREE_CODE (r
) == TARGET_EXPR
7564 && TREE_CODE (TARGET_EXPR_INITIAL (r
)) == CONSTRUCTOR
)
7565 r
= TARGET_EXPR_INITIAL (r
);
7568 if (!allow_non_constant
)
7569 non_const_var_error (r
);
7570 *non_constant_p
= true;
7580 if (call
&& DECL_CONTEXT (t
) == call
->fundef
->decl
)
7582 if (DECL_ARTIFICIAL (t
) && DECL_CONSTRUCTOR_P (DECL_CONTEXT (t
)))
7584 if (!allow_non_constant
)
7585 sorry ("use of the value of the object being constructed "
7586 "in a constant expression");
7587 *non_constant_p
= true;
7590 r
= lookup_parameter_binding (call
, t
);
7593 /* Defer in case this is only used for its type. */;
7596 if (!allow_non_constant
)
7597 error ("%qE is not a constant expression", t
);
7598 *non_constant_p
= true;
7603 case AGGR_INIT_EXPR
:
7604 r
= cxx_eval_call_expression (call
, t
, allow_non_constant
, addr
,
7609 if (!literal_type_p (TREE_TYPE (t
)))
7611 if (!allow_non_constant
)
7613 error ("temporary of non-literal type %qT in a "
7614 "constant expression", TREE_TYPE (t
));
7615 explain_non_literal_class (TREE_TYPE (t
));
7617 *non_constant_p
= true;
7620 /* else fall through. */
7622 /* Pass false for 'addr' because these codes indicate
7623 initialization of a temporary. */
7624 r
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 1),
7625 allow_non_constant
, false,
7627 if (!*non_constant_p
)
7628 /* Adjust the type of the result to the type of the temporary. */
7629 r
= adjust_temp_type (TREE_TYPE (t
), r
);
7633 r
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 1),
7634 allow_non_constant
, addr
,
7639 case NON_LVALUE_EXPR
:
7640 case TRY_CATCH_EXPR
:
7641 case CLEANUP_POINT_EXPR
:
7642 case MUST_NOT_THROW_EXPR
:
7644 r
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 0),
7645 allow_non_constant
, addr
,
7649 /* These differ from cxx_eval_unary_expression in that this doesn't
7650 check for a constant operand or result; an address can be
7651 constant without its operand being, and vice versa. */
7653 r
= cxx_eval_indirect_ref (call
, t
, allow_non_constant
, addr
,
7659 tree oldop
= TREE_OPERAND (t
, 0);
7660 tree op
= cxx_eval_constant_expression (call
, oldop
,
7664 /* Don't VERIFY_CONSTANT here. */
7665 if (*non_constant_p
)
7667 /* This function does more aggressive folding than fold itself. */
7668 r
= build_fold_addr_expr_with_type (op
, TREE_TYPE (t
));
7669 if (TREE_CODE (r
) == ADDR_EXPR
&& TREE_OPERAND (r
, 0) == oldop
)
7677 case FIX_TRUNC_EXPR
:
7682 case TRUTH_NOT_EXPR
:
7683 case FIXED_CONVERT_EXPR
:
7684 r
= cxx_eval_unary_expression (call
, t
, allow_non_constant
, addr
,
7690 /* check_return_expr sometimes wraps a TARGET_EXPR in a
7691 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
7692 introduced by build_call_a. */
7693 tree op0
= TREE_OPERAND (t
, 0);
7694 tree op1
= TREE_OPERAND (t
, 1);
7696 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
7697 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
7698 r
= cxx_eval_constant_expression (call
, op0
, allow_non_constant
,
7699 addr
, non_constant_p
);
7702 /* Check that the LHS is constant and then discard it. */
7703 cxx_eval_constant_expression (call
, op0
, allow_non_constant
,
7704 false, non_constant_p
);
7705 r
= cxx_eval_constant_expression (call
, op1
, allow_non_constant
,
7706 addr
, non_constant_p
);
7711 case POINTER_PLUS_EXPR
:
7715 case TRUNC_DIV_EXPR
:
7717 case FLOOR_DIV_EXPR
:
7718 case ROUND_DIV_EXPR
:
7719 case TRUNC_MOD_EXPR
:
7721 case ROUND_MOD_EXPR
:
7723 case EXACT_DIV_EXPR
:
7733 case TRUTH_XOR_EXPR
:
7740 case UNORDERED_EXPR
:
7749 r
= cxx_eval_binary_expression (call
, t
, allow_non_constant
, addr
,
7753 /* fold can introduce non-IF versions of these; still treat them as
7754 short-circuiting. */
7755 case TRUTH_AND_EXPR
:
7756 case TRUTH_ANDIF_EXPR
:
7757 r
= cxx_eval_logical_expression (call
, t
, boolean_false_node
,
7759 allow_non_constant
, addr
,
7764 case TRUTH_ORIF_EXPR
:
7765 r
= cxx_eval_logical_expression (call
, t
, boolean_true_node
,
7767 allow_non_constant
, addr
,
7772 r
= cxx_eval_array_reference (call
, t
, allow_non_constant
, addr
,
7777 r
= cxx_eval_component_reference (call
, t
, allow_non_constant
, addr
,
7782 r
= cxx_eval_bit_field_ref (call
, t
, allow_non_constant
, addr
,
7788 r
= cxx_eval_conditional_expression (call
, t
, allow_non_constant
, addr
,
7793 r
= cxx_eval_bare_aggregate (call
, t
, allow_non_constant
, addr
,
7798 /* We can get this in a defaulted constructor for a class with a
7799 non-static data member of array type. Either the initializer will
7800 be NULL, meaning default-initialization, or it will be an lvalue
7801 or xvalue of the same type, meaning direct-initialization from the
7802 corresponding member. */
7803 r
= cxx_eval_vec_init (call
, t
, allow_non_constant
, addr
,
7808 r
= cxx_eval_vec_perm_expr (call
, t
, allow_non_constant
, addr
,
7813 case VIEW_CONVERT_EXPR
:
7816 tree oldop
= TREE_OPERAND (t
, 0);
7817 tree op
= cxx_eval_constant_expression (call
, oldop
,
7818 allow_non_constant
, addr
,
7820 if (*non_constant_p
)
7823 /* We didn't fold at the top so we could check for ptr-int
7826 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), op
);
7827 /* Conversion of an out-of-range value has implementation-defined
7828 behavior; the language considers it different from arithmetic
7829 overflow, which is undefined. */
7830 if (TREE_OVERFLOW_P (r
) && !TREE_OVERFLOW_P (op
))
7831 TREE_OVERFLOW (r
) = false;
7835 case EMPTY_CLASS_EXPR
:
7836 /* This is good enough for a function argument that might not get
7837 used, and they can't do anything with it, so just return it. */
7841 case PREINCREMENT_EXPR
:
7842 case POSTINCREMENT_EXPR
:
7843 case PREDECREMENT_EXPR
:
7844 case POSTDECREMENT_EXPR
:
7848 case VEC_DELETE_EXPR
:
7852 /* GCC internal stuff. */
7855 case WITH_CLEANUP_EXPR
:
7856 case STATEMENT_LIST
:
7858 case NON_DEPENDENT_EXPR
:
7862 if (!allow_non_constant
)
7863 error_at (EXPR_LOC_OR_HERE (t
),
7864 "expression %qE is not a constant-expression", t
);
7865 *non_constant_p
= true;
7869 internal_error ("unexpected expression %qE of kind %s", t
,
7870 tree_code_name
[TREE_CODE (t
)]);
7871 *non_constant_p
= true;
7875 if (r
== error_mark_node
)
7876 *non_constant_p
= true;
7878 if (*non_constant_p
)
7885 cxx_eval_outermost_constant_expr (tree t
, bool allow_non_constant
)
7887 bool non_constant_p
= false;
7888 tree r
= cxx_eval_constant_expression (NULL
, t
, allow_non_constant
,
7889 false, &non_constant_p
);
7891 verify_constant (r
, allow_non_constant
, &non_constant_p
);
7893 if (TREE_CODE (t
) != CONSTRUCTOR
7894 && cp_has_mutable_p (TREE_TYPE (t
)))
7896 /* We allow a mutable type if the original expression was a
7897 CONSTRUCTOR so that we can do aggregate initialization of
7898 constexpr variables. */
7899 if (!allow_non_constant
)
7900 error ("%qT cannot be the type of a complete constant expression "
7901 "because it has mutable sub-objects", TREE_TYPE (t
));
7902 non_constant_p
= true;
7905 /* Technically we should check this for all subexpressions, but that
7906 runs into problems with our internal representation of pointer
7907 subtraction and the 5.19 rules are still in flux. */
7908 if (CONVERT_EXPR_CODE_P (TREE_CODE (r
))
7909 && ARITHMETIC_TYPE_P (TREE_TYPE (r
))
7910 && TREE_CODE (TREE_OPERAND (r
, 0)) == ADDR_EXPR
)
7912 if (!allow_non_constant
)
7913 error ("conversion from pointer type %qT "
7914 "to arithmetic type %qT in a constant-expression",
7915 TREE_TYPE (TREE_OPERAND (r
, 0)), TREE_TYPE (r
));
7916 non_constant_p
= true;
7919 if (non_constant_p
&& !allow_non_constant
)
7920 return error_mark_node
;
7921 else if (non_constant_p
&& TREE_CONSTANT (t
))
7923 /* This isn't actually constant, so unset TREE_CONSTANT. */
7924 if (EXPR_P (t
) || TREE_CODE (t
) == CONSTRUCTOR
)
7927 r
= build_nop (TREE_TYPE (t
), t
);
7928 TREE_CONSTANT (r
) = false;
7931 else if (non_constant_p
|| r
== t
)
7933 else if (TREE_CODE (r
) == CONSTRUCTOR
&& CLASS_TYPE_P (TREE_TYPE (r
)))
7935 if (TREE_CODE (t
) == TARGET_EXPR
7936 && TARGET_EXPR_INITIAL (t
) == r
)
7940 r
= get_target_expr (r
);
7941 TREE_CONSTANT (r
) = true;
7949 /* Returns true if T is a valid subexpression of a constant expression,
7950 even if it isn't itself a constant expression. */
7953 is_sub_constant_expr (tree t
)
7955 bool non_constant_p
= false;
7956 cxx_eval_constant_expression (NULL
, t
, true, false, &non_constant_p
);
7957 return !non_constant_p
;
7960 /* If T represents a constant expression returns its reduced value.
7961 Otherwise return error_mark_node. If T is dependent, then
7965 cxx_constant_value (tree t
)
7967 return cxx_eval_outermost_constant_expr (t
, false);
7970 /* If T is a constant expression, returns its reduced value.
7971 Otherwise, if T does not have TREE_CONSTANT set, returns T.
7972 Otherwise, returns a version of T without TREE_CONSTANT. */
7975 maybe_constant_value (tree t
)
7979 if (type_dependent_expression_p (t
)
7980 || type_unknown_p (t
)
7981 || BRACE_ENCLOSED_INITIALIZER_P (t
)
7982 || !potential_constant_expression (t
)
7983 || value_dependent_expression_p (t
))
7985 if (TREE_OVERFLOW_P (t
))
7987 t
= build_nop (TREE_TYPE (t
), t
);
7988 TREE_CONSTANT (t
) = false;
7993 r
= cxx_eval_outermost_constant_expr (t
, true);
7994 #ifdef ENABLE_CHECKING
7995 /* cp_tree_equal looks through NOPs, so allow them. */
7997 || CONVERT_EXPR_P (t
)
7998 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
7999 || !cp_tree_equal (r
, t
));
8004 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
8005 than wrapped in a TARGET_EXPR. */
8008 maybe_constant_init (tree t
)
8010 t
= maybe_constant_value (t
);
8011 if (TREE_CODE (t
) == TARGET_EXPR
)
8013 tree init
= TARGET_EXPR_INITIAL (t
);
8014 if (TREE_CODE (init
) == CONSTRUCTOR
8015 && TREE_CONSTANT (init
))
8022 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
8023 /* Return true if the object referred to by REF has automatic or thread
8026 enum { ck_ok
, ck_bad
, ck_unknown
};
8028 check_automatic_or_tls (tree ref
)
8030 enum machine_mode mode
;
8031 HOST_WIDE_INT bitsize
, bitpos
;
8033 int volatilep
= 0, unsignedp
= 0;
8034 tree decl
= get_inner_reference (ref
, &bitsize
, &bitpos
, &offset
,
8035 &mode
, &unsignedp
, &volatilep
, false);
8038 /* If there isn't a decl in the middle, we don't know the linkage here,
8039 and this isn't a constant expression anyway. */
8042 dk
= decl_storage_duration (decl
);
8043 return (dk
== dk_auto
|| dk
== dk_thread
) ? ck_bad
: ck_ok
;
8047 /* Return true if T denotes a potentially constant expression. Issue
8048 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
8049 an lvalue-rvalue conversion is implied.
8051 C++0x [expr.const] used to say
8053 6 An expression is a potential constant expression if it is
8054 a constant expression where all occurences of function
8055 parameters are replaced by arbitrary constant expressions
8056 of the appropriate type.
8058 2 A conditional expression is a constant expression unless it
8059 involves one of the following as a potentially evaluated
8060 subexpression (3.2), but subexpressions of logical AND (5.14),
8061 logical OR (5.15), and conditional (5.16) operations that are
8062 not evaluated are not considered. */
8065 potential_constant_expression_1 (tree t
, bool want_rval
, tsubst_flags_t flags
)
8067 enum { any
= false, rval
= true };
8071 /* C++98 has different rules for the form of a constant expression that
8072 are enforced in the parser, so we can assume that anything that gets
8073 this far is suitable. */
8074 if (cxx_dialect
< cxx0x
)
8077 if (t
== error_mark_node
)
8081 if (TREE_THIS_VOLATILE (t
))
8083 if (flags
& tf_error
)
8084 error ("expression %qE has side-effects", t
);
8087 if (CONSTANT_CLASS_P (t
))
8089 if (TREE_OVERFLOW (t
))
8091 if (flags
& tf_error
)
8093 permerror (EXPR_LOC_OR_HERE (t
),
8094 "overflow in constant expression");
8095 if (flag_permissive
)
8103 switch (TREE_CODE (t
))
8109 case TEMPLATE_ID_EXPR
:
8116 case TEMPLATE_PARM_INDEX
:
8118 case IDENTIFIER_NODE
:
8119 case USERDEF_LITERAL
:
8120 /* We can see a FIELD_DECL in a pointer-to-member expression. */
8126 case AGGR_INIT_EXPR
:
8128 /* -- an invocation of a function other than a constexpr function
8129 or a constexpr constructor. */
8131 tree fun
= get_function_named_in_call (t
);
8132 const int nargs
= call_expr_nargs (t
);
8135 if (is_overloaded_fn (fun
))
8137 if (TREE_CODE (fun
) == FUNCTION_DECL
)
8139 if (builtin_valid_in_constant_expr_p (fun
))
8141 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
8142 /* Allow any built-in function; if the expansion
8143 isn't constant, we'll deal with that then. */
8144 && !is_builtin_fn (fun
))
8146 if (flags
& tf_error
)
8148 error_at (EXPR_LOC_OR_HERE (t
),
8149 "call to non-constexpr function %qD", fun
);
8150 explain_invalid_constexpr_fn (fun
);
8154 /* A call to a non-static member function takes the address
8155 of the object as the first argument. But in a constant
8156 expression the address will be folded away, so look
8158 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
8159 && !DECL_CONSTRUCTOR_P (fun
))
8161 tree x
= get_nth_callarg (t
, 0);
8162 if (is_this_parameter (x
))
8164 if (DECL_CONSTRUCTOR_P (DECL_CONTEXT (x
)))
8166 if (flags
& tf_error
)
8167 sorry ("calling a member function of the "
8168 "object being constructed in a constant "
8172 /* Otherwise OK. */;
8174 else if (!potential_constant_expression_1 (x
, rval
, flags
))
8180 fun
= get_first_fn (fun
);
8181 /* Skip initial arguments to base constructors. */
8182 if (DECL_BASE_CONSTRUCTOR_P (fun
))
8183 i
= num_artificial_parms_for (fun
);
8184 fun
= DECL_ORIGIN (fun
);
8188 if (potential_constant_expression_1 (fun
, rval
, flags
))
8189 /* Might end up being a constant function pointer. */;
8193 for (; i
< nargs
; ++i
)
8195 tree x
= get_nth_callarg (t
, i
);
8196 if (!potential_constant_expression_1 (x
, rval
, flags
))
8202 case NON_LVALUE_EXPR
:
8203 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
8204 -- an lvalue of integral type that refers to a non-volatile
8205 const variable or static data member initialized with
8206 constant expressions, or
8208 -- an lvalue of literal type that refers to non-volatile
8209 object defined with constexpr, or that refers to a
8210 sub-object of such an object; */
8211 return potential_constant_expression_1 (TREE_OPERAND (t
, 0), rval
, flags
);
8214 if (want_rval
&& !decl_constant_var_p (t
)
8215 && !dependent_type_p (TREE_TYPE (t
)))
8217 if (flags
& tf_error
)
8218 non_const_var_error (t
);
8225 case VIEW_CONVERT_EXPR
:
8226 /* -- a reinterpret_cast. FIXME not implemented, and this rule
8227 may change to something more specific to type-punning (DR 1312). */
8229 tree from
= TREE_OPERAND (t
, 0);
8230 return (potential_constant_expression_1
8231 (from
, TREE_CODE (t
) != VIEW_CONVERT_EXPR
, flags
));
8235 /* -- a unary operator & that is applied to an lvalue that
8236 designates an object with thread or automatic storage
8238 t
= TREE_OPERAND (t
, 0);
8240 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
8241 any checking here, as we might dereference the pointer later. If
8242 we remove this code, also remove check_automatic_or_tls. */
8243 i
= check_automatic_or_tls (t
);
8248 if (flags
& tf_error
)
8249 error ("address-of an object %qE with thread local or "
8250 "automatic storage is not a constant expression", t
);
8254 return potential_constant_expression_1 (t
, any
, flags
);
8260 /* -- a class member access unless its postfix-expression is
8261 of literal type or of pointer to literal type. */
8262 /* This test would be redundant, as it follows from the
8263 postfix-expression being a potential constant expression. */
8264 return potential_constant_expression_1 (TREE_OPERAND (t
, 0),
8267 case EXPR_PACK_EXPANSION
:
8268 return potential_constant_expression_1 (PACK_EXPANSION_PATTERN (t
),
8273 tree x
= TREE_OPERAND (t
, 0);
8275 if (is_this_parameter (x
))
8277 if (want_rval
&& DECL_CONTEXT (x
)
8278 && DECL_CONSTRUCTOR_P (DECL_CONTEXT (x
)))
8280 if (flags
& tf_error
)
8281 sorry ("use of the value of the object being constructed "
8282 "in a constant expression");
8287 return potential_constant_expression_1 (x
, rval
, flags
);
8291 case DYNAMIC_CAST_EXPR
:
8292 case PSEUDO_DTOR_EXPR
:
8293 case PREINCREMENT_EXPR
:
8294 case POSTINCREMENT_EXPR
:
8295 case PREDECREMENT_EXPR
:
8296 case POSTDECREMENT_EXPR
:
8300 case VEC_DELETE_EXPR
:
8304 /* GCC internal stuff. */
8307 case WITH_CLEANUP_EXPR
:
8308 case CLEANUP_POINT_EXPR
:
8309 case MUST_NOT_THROW_EXPR
:
8310 case TRY_CATCH_EXPR
:
8311 case STATEMENT_LIST
:
8312 /* Don't bother trying to define a subset of statement-expressions to
8313 be constant-expressions, at least for now. */
8317 case TRANSACTION_EXPR
:
8322 if (flags
& tf_error
)
8323 error ("expression %qE is not a constant-expression", t
);
8327 /* -- a typeid expression whose operand is of polymorphic
8330 tree e
= TREE_OPERAND (t
, 0);
8331 if (!TYPE_P (e
) && !type_dependent_expression_p (e
)
8332 && TYPE_POLYMORPHIC_P (TREE_TYPE (e
)))
8334 if (flags
& tf_error
)
8335 error ("typeid-expression is not a constant expression "
8336 "because %qE is of polymorphic type", e
);
8343 /* -- a subtraction where both operands are pointers. */
8344 if (TYPE_PTR_P (TREE_OPERAND (t
, 0))
8345 && TYPE_PTR_P (TREE_OPERAND (t
, 1)))
8347 if (flags
& tf_error
)
8348 error ("difference of two pointer expressions is not "
8349 "a constant expression");
8361 /* -- a relational or equality operator where at least
8362 one of the operands is a pointer. */
8363 if (TYPE_PTR_P (TREE_OPERAND (t
, 0))
8364 || TYPE_PTR_P (TREE_OPERAND (t
, 1)))
8366 if (flags
& tf_error
)
8367 error ("pointer comparison expression is not a "
8368 "constant expression");
8376 if (TYPE_P (TREE_OPERAND (t
, 0)))
8378 /* else fall through. */
8384 case FIX_TRUNC_EXPR
:
8388 case TRUTH_NOT_EXPR
:
8389 case FIXED_CONVERT_EXPR
:
8390 case UNARY_PLUS_EXPR
:
8391 return potential_constant_expression_1 (TREE_OPERAND (t
, 0), rval
,
8395 case CONST_CAST_EXPR
:
8396 case STATIC_CAST_EXPR
:
8397 case REINTERPRET_CAST_EXPR
:
8398 case IMPLICIT_CONV_EXPR
:
8399 return (potential_constant_expression_1
8400 (TREE_OPERAND (t
, 0),
8401 TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
, flags
));
8404 case NON_DEPENDENT_EXPR
:
8405 /* For convenience. */
8407 return potential_constant_expression_1 (TREE_OPERAND (t
, 0),
8411 return potential_constant_expression_1 (TREE_OPERAND (t
, 1),
8415 if (!literal_type_p (TREE_TYPE (t
)))
8417 if (flags
& tf_error
)
8419 error ("temporary of non-literal type %qT in a "
8420 "constant expression", TREE_TYPE (t
));
8421 explain_non_literal_class (TREE_TYPE (t
));
8426 return potential_constant_expression_1 (TREE_OPERAND (t
, 1),
8431 VEC(constructor_elt
, gc
) *v
= CONSTRUCTOR_ELTS (t
);
8432 constructor_elt
*ce
;
8433 for (i
= 0; VEC_iterate (constructor_elt
, v
, i
, ce
); ++i
)
8434 if (!potential_constant_expression_1 (ce
->value
, want_rval
, flags
))
8441 gcc_assert (TREE_PURPOSE (t
) == NULL_TREE
8442 || DECL_P (TREE_PURPOSE (t
)));
8443 if (!potential_constant_expression_1 (TREE_VALUE (t
), want_rval
,
8446 if (TREE_CHAIN (t
) == NULL_TREE
)
8448 return potential_constant_expression_1 (TREE_CHAIN (t
), want_rval
,
8452 case TRUNC_DIV_EXPR
:
8454 case FLOOR_DIV_EXPR
:
8455 case ROUND_DIV_EXPR
:
8456 case TRUNC_MOD_EXPR
:
8458 case ROUND_MOD_EXPR
:
8460 tree denom
= TREE_OPERAND (t
, 1);
8461 /* We can't call maybe_constant_value on an expression
8462 that hasn't been through fold_non_dependent_expr yet. */
8463 if (!processing_template_decl
)
8464 denom
= maybe_constant_value (denom
);
8465 if (integer_zerop (denom
))
8467 if (flags
& tf_error
)
8468 error ("division by zero is not a constant-expression");
8480 /* check_return_expr sometimes wraps a TARGET_EXPR in a
8481 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
8482 introduced by build_call_a. */
8483 tree op0
= TREE_OPERAND (t
, 0);
8484 tree op1
= TREE_OPERAND (t
, 1);
8486 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
8487 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
8488 return potential_constant_expression_1 (op0
, want_rval
, flags
);
8493 /* If the first operand is the non-short-circuit constant, look at
8494 the second operand; otherwise we only care about the first one for
8496 case TRUTH_AND_EXPR
:
8497 case TRUTH_ANDIF_EXPR
:
8498 tmp
= boolean_true_node
;
8501 case TRUTH_ORIF_EXPR
:
8502 tmp
= boolean_false_node
;
8504 if (TREE_OPERAND (t
, 0) == tmp
)
8505 return potential_constant_expression_1 (TREE_OPERAND (t
, 1), rval
, flags
);
8507 return potential_constant_expression_1 (TREE_OPERAND (t
, 0), rval
, flags
);
8511 case POINTER_PLUS_EXPR
:
8513 case EXACT_DIV_EXPR
:
8523 case TRUTH_XOR_EXPR
:
8524 case UNORDERED_EXPR
:
8537 case ARRAY_RANGE_REF
:
8541 for (i
= 0; i
< 2; ++i
)
8542 if (!potential_constant_expression_1 (TREE_OPERAND (t
, i
),
8549 for (i
= 0; i
< 3; ++i
)
8550 if (!potential_constant_expression_1 (TREE_OPERAND (t
, i
),
8557 /* If the condition is a known constant, we know which of the legs we
8558 care about; otherwise we only require that the condition and
8559 either of the legs be potentially constant. */
8560 tmp
= TREE_OPERAND (t
, 0);
8561 if (!potential_constant_expression_1 (tmp
, rval
, flags
))
8563 else if (integer_zerop (tmp
))
8564 return potential_constant_expression_1 (TREE_OPERAND (t
, 2),
8566 else if (TREE_CODE (tmp
) == INTEGER_CST
)
8567 return potential_constant_expression_1 (TREE_OPERAND (t
, 1),
8569 for (i
= 1; i
< 3; ++i
)
8570 if (potential_constant_expression_1 (TREE_OPERAND (t
, i
),
8571 want_rval
, tf_none
))
8573 if (flags
& tf_error
)
8574 error ("expression %qE is not a constant-expression", t
);
8578 if (VEC_INIT_EXPR_IS_CONSTEXPR (t
))
8580 if (flags
& tf_error
)
8582 error ("non-constant array initialization");
8583 diagnose_non_constexpr_vec_init (t
);
8588 sorry ("unexpected AST of kind %s", tree_code_name
[TREE_CODE (t
)]);
8594 /* The main entry point to the above. */
8597 potential_constant_expression (tree t
)
8599 return potential_constant_expression_1 (t
, false, tf_none
);
8602 /* As above, but require a constant rvalue. */
8605 potential_rvalue_constant_expression (tree t
)
8607 return potential_constant_expression_1 (t
, true, tf_none
);
8610 /* Like above, but complain about non-constant expressions. */
8613 require_potential_constant_expression (tree t
)
8615 return potential_constant_expression_1 (t
, false, tf_warning_or_error
);
8618 /* Cross product of the above. */
8621 require_potential_rvalue_constant_expression (tree t
)
8623 return potential_constant_expression_1 (t
, true, tf_warning_or_error
);
8626 /* Constructor for a lambda expression. */
8629 build_lambda_expr (void)
8631 tree lambda
= make_node (LAMBDA_EXPR
);
8632 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda
) = CPLD_NONE
;
8633 LAMBDA_EXPR_CAPTURE_LIST (lambda
) = NULL_TREE
;
8634 LAMBDA_EXPR_THIS_CAPTURE (lambda
) = NULL_TREE
;
8635 LAMBDA_EXPR_PENDING_PROXIES (lambda
) = NULL
;
8636 LAMBDA_EXPR_RETURN_TYPE (lambda
) = NULL_TREE
;
8637 LAMBDA_EXPR_MUTABLE_P (lambda
) = false;
8641 /* Create the closure object for a LAMBDA_EXPR. */
8644 build_lambda_object (tree lambda_expr
)
8646 /* Build aggregate constructor call.
8647 - cp_parser_braced_list
8648 - cp_parser_functional_cast */
8649 VEC(constructor_elt
,gc
) *elts
= NULL
;
8650 tree node
, expr
, type
;
8651 location_t saved_loc
;
8653 if (processing_template_decl
)
8656 /* Make sure any error messages refer to the lambda-introducer. */
8657 saved_loc
= input_location
;
8658 input_location
= LAMBDA_EXPR_LOCATION (lambda_expr
);
8660 for (node
= LAMBDA_EXPR_CAPTURE_LIST (lambda_expr
);
8662 node
= TREE_CHAIN (node
))
8664 tree field
= TREE_PURPOSE (node
);
8665 tree val
= TREE_VALUE (node
);
8667 if (field
== error_mark_node
)
8669 expr
= error_mark_node
;
8676 /* Mere mortals can't copy arrays with aggregate initialization, so
8677 do some magic to make it work here. */
8678 if (TREE_CODE (TREE_TYPE (field
)) == ARRAY_TYPE
)
8679 val
= build_array_copy (val
);
8680 else if (DECL_NORMAL_CAPTURE_P (field
)
8681 && TREE_CODE (TREE_TYPE (field
)) != REFERENCE_TYPE
)
8683 /* "the entities that are captured by copy are used to
8684 direct-initialize each corresponding non-static data
8685 member of the resulting closure object."
8687 There's normally no way to express direct-initialization
8688 from an element of a CONSTRUCTOR, so we build up a special
8689 TARGET_EXPR to bypass the usual copy-initialization. */
8690 val
= force_rvalue (val
, tf_warning_or_error
);
8691 if (TREE_CODE (val
) == TARGET_EXPR
)
8692 TARGET_EXPR_DIRECT_INIT_P (val
) = true;
8695 CONSTRUCTOR_APPEND_ELT (elts
, DECL_NAME (field
), val
);
8698 expr
= build_constructor (init_list_type_node
, elts
);
8699 CONSTRUCTOR_IS_DIRECT_INIT (expr
) = 1;
8701 /* N2927: "[The closure] class type is not an aggregate."
8702 But we briefly treat it as an aggregate to make this simpler. */
8703 type
= LAMBDA_EXPR_CLOSURE (lambda_expr
);
8704 CLASSTYPE_NON_AGGREGATE (type
) = 0;
8705 expr
= finish_compound_literal (type
, expr
, tf_warning_or_error
);
8706 CLASSTYPE_NON_AGGREGATE (type
) = 1;
8709 input_location
= saved_loc
;
8713 /* Return an initialized RECORD_TYPE for LAMBDA.
8714 LAMBDA must have its explicit captures already. */
8717 begin_lambda_type (tree lambda
)
8722 /* Unique name. This is just like an unnamed class, but we cannot use
8723 make_anon_name because of certain checks against TYPE_ANONYMOUS_P. */
8725 name
= make_lambda_name ();
8727 /* Create the new RECORD_TYPE for this lambda. */
8728 type
= xref_tag (/*tag_code=*/record_type
,
8730 /*scope=*/ts_within_enclosing_non_class
,
8731 /*template_header_p=*/false);
8734 /* Designate it as a struct so that we can use aggregate initialization. */
8735 CLASSTYPE_DECLARED_CLASS (type
) = false;
8737 /* Clear base types. */
8738 xref_basetypes (type
, /*bases=*/NULL_TREE
);
8740 /* Start the class. */
8741 type
= begin_class_definition (type
);
8742 if (type
== error_mark_node
)
8743 return error_mark_node
;
8745 /* Cross-reference the expression and the type. */
8746 LAMBDA_EXPR_CLOSURE (lambda
) = type
;
8747 CLASSTYPE_LAMBDA_EXPR (type
) = lambda
;
8752 /* Returns the type to use for the return type of the operator() of a
8756 lambda_return_type (tree expr
)
8758 if (expr
== NULL_TREE
)
8759 return void_type_node
;
8760 if (type_unknown_p (expr
)
8761 || BRACE_ENCLOSED_INITIALIZER_P (expr
))
8763 cxx_incomplete_type_error (expr
, TREE_TYPE (expr
));
8764 return void_type_node
;
8766 gcc_checking_assert (!type_dependent_expression_p (expr
));
8767 return cv_unqualified (type_decays_to (unlowered_expr_type (expr
)));
8770 /* Given a LAMBDA_EXPR or closure type LAMBDA, return the op() of the
8774 lambda_function (tree lambda
)
8777 if (TREE_CODE (lambda
) == LAMBDA_EXPR
)
8778 type
= LAMBDA_EXPR_CLOSURE (lambda
);
8781 gcc_assert (LAMBDA_TYPE_P (type
));
8782 /* Don't let debug_tree cause instantiation. */
8783 if (CLASSTYPE_TEMPLATE_INSTANTIATION (type
)
8784 && !COMPLETE_OR_OPEN_TYPE_P (type
))
8786 lambda
= lookup_member (type
, ansi_opname (CALL_EXPR
),
8787 /*protect=*/0, /*want_type=*/false,
8788 tf_warning_or_error
);
8790 lambda
= BASELINK_FUNCTIONS (lambda
);
8794 /* Returns the type to use for the FIELD_DECL corresponding to the
8796 The caller should add REFERENCE_TYPE for capture by reference. */
8799 lambda_capture_field_type (tree expr
)
8802 if (type_dependent_expression_p (expr
))
8804 type
= cxx_make_type (DECLTYPE_TYPE
);
8805 DECLTYPE_TYPE_EXPR (type
) = expr
;
8806 DECLTYPE_FOR_LAMBDA_CAPTURE (type
) = true;
8807 SET_TYPE_STRUCTURAL_EQUALITY (type
);
8810 type
= non_reference (unlowered_expr_type (expr
));
8814 /* Insert the deduced return type for an auto function. */
8817 apply_deduced_return_type (tree fco
, tree return_type
)
8821 if (return_type
== error_mark_node
)
8824 if (LAMBDA_FUNCTION_P (fco
))
8826 tree lambda
= CLASSTYPE_LAMBDA_EXPR (current_class_type
);
8827 LAMBDA_EXPR_RETURN_TYPE (lambda
) = return_type
;
8830 if (DECL_CONV_FN_P (fco
))
8831 DECL_NAME (fco
) = mangle_conv_op_name_for_type (return_type
);
8833 TREE_TYPE (fco
) = change_return_type (return_type
, TREE_TYPE (fco
));
8835 result
= DECL_RESULT (fco
);
8836 if (result
== NULL_TREE
)
8838 if (TREE_TYPE (result
) == return_type
)
8841 /* We already have a DECL_RESULT from start_preparsed_function.
8842 Now we need to redo the work it and allocate_struct_function
8843 did to reflect the new type. */
8844 gcc_assert (current_function_decl
== fco
);
8845 result
= build_decl (input_location
, RESULT_DECL
, NULL_TREE
,
8846 TYPE_MAIN_VARIANT (return_type
));
8847 DECL_ARTIFICIAL (result
) = 1;
8848 DECL_IGNORED_P (result
) = 1;
8849 cp_apply_type_quals_to_decl (cp_type_quals (return_type
),
8852 DECL_RESULT (fco
) = result
;
8854 if (!processing_template_decl
)
8856 bool aggr
= aggregate_value_p (result
, fco
);
8857 #ifdef PCC_STATIC_STRUCT_RETURN
8858 cfun
->returns_pcc_struct
= aggr
;
8860 cfun
->returns_struct
= aggr
;
8865 /* DECL is a local variable or parameter from the surrounding scope of a
8866 lambda-expression. Returns the decltype for a use of the capture field
8867 for DECL even if it hasn't been captured yet. */
8870 capture_decltype (tree decl
)
8872 tree lam
= CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (current_function_decl
));
8873 /* FIXME do lookup instead of list walk? */
8874 tree cap
= value_member (decl
, LAMBDA_EXPR_CAPTURE_LIST (lam
));
8878 type
= TREE_TYPE (TREE_PURPOSE (cap
));
8880 switch (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lam
))
8883 error ("%qD is not captured", decl
);
8884 return error_mark_node
;
8887 type
= TREE_TYPE (decl
);
8888 if (TREE_CODE (type
) == REFERENCE_TYPE
8889 && TREE_CODE (TREE_TYPE (type
)) != FUNCTION_TYPE
)
8890 type
= TREE_TYPE (type
);
8893 case CPLD_REFERENCE
:
8894 type
= TREE_TYPE (decl
);
8895 if (TREE_CODE (type
) != REFERENCE_TYPE
)
8896 type
= build_reference_type (TREE_TYPE (decl
));
8903 if (TREE_CODE (type
) != REFERENCE_TYPE
)
8905 if (!LAMBDA_EXPR_MUTABLE_P (lam
))
8906 type
= cp_build_qualified_type (type
, (cp_type_quals (type
)
8908 type
= build_reference_type (type
);
8913 /* Returns true iff DECL is a lambda capture proxy variable created by
8914 build_capture_proxy. */
8917 is_capture_proxy (tree decl
)
8919 return (TREE_CODE (decl
) == VAR_DECL
8920 && DECL_HAS_VALUE_EXPR_P (decl
)
8921 && !DECL_ANON_UNION_VAR_P (decl
)
8922 && LAMBDA_FUNCTION_P (DECL_CONTEXT (decl
)));
8925 /* Returns true iff DECL is a capture proxy for a normal capture
8926 (i.e. without explicit initializer). */
8929 is_normal_capture_proxy (tree decl
)
8933 if (!is_capture_proxy (decl
))
8934 /* It's not a capture proxy. */
8937 /* It is a capture proxy, is it a normal capture? */
8938 val
= DECL_VALUE_EXPR (decl
);
8939 gcc_assert (TREE_CODE (val
) == COMPONENT_REF
);
8940 val
= TREE_OPERAND (val
, 1);
8941 return DECL_NORMAL_CAPTURE_P (val
);
8944 /* VAR is a capture proxy created by build_capture_proxy; add it to the
8945 current function, which is the operator() for the appropriate lambda. */
8948 insert_capture_proxy (tree var
)
8950 cp_binding_level
*b
;
8954 /* Put the capture proxy in the extra body block so that it won't clash
8955 with a later local variable. */
8956 b
= current_binding_level
;
8957 for (skip
= 0; ; ++skip
)
8959 cp_binding_level
*n
= b
->level_chain
;
8960 if (n
->kind
== sk_function_parms
)
8964 pushdecl_with_scope (var
, b
, false);
8966 /* And put a DECL_EXPR in the STATEMENT_LIST for the same block. */
8967 var
= build_stmt (DECL_SOURCE_LOCATION (var
), DECL_EXPR
, var
);
8968 stmt_list
= VEC_index (tree
, stmt_list_stack
,
8969 VEC_length (tree
, stmt_list_stack
) - 1 - skip
);
8970 gcc_assert (stmt_list
);
8971 append_to_statement_list_force (var
, &stmt_list
);
8974 /* We've just finished processing a lambda; if the containing scope is also
8975 a lambda, insert any capture proxies that were created while processing
8976 the nested lambda. */
8979 insert_pending_capture_proxies (void)
8982 VEC(tree
,gc
) *proxies
;
8985 if (!current_function_decl
|| !LAMBDA_FUNCTION_P (current_function_decl
))
8988 lam
= CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (current_function_decl
));
8989 proxies
= LAMBDA_EXPR_PENDING_PROXIES (lam
);
8990 for (i
= 0; i
< VEC_length (tree
, proxies
); ++i
)
8992 tree var
= VEC_index (tree
, proxies
, i
);
8993 insert_capture_proxy (var
);
8995 release_tree_vector (LAMBDA_EXPR_PENDING_PROXIES (lam
));
8996 LAMBDA_EXPR_PENDING_PROXIES (lam
) = NULL
;
8999 /* Given REF, a COMPONENT_REF designating a field in the lambda closure,
9000 return the type we want the proxy to have: the type of the field itself,
9001 with added const-qualification if the lambda isn't mutable and the
9002 capture is by value. */
9005 lambda_proxy_type (tree ref
)
9008 if (REFERENCE_REF_P (ref
))
9009 ref
= TREE_OPERAND (ref
, 0);
9010 type
= TREE_TYPE (ref
);
9011 if (!dependent_type_p (type
))
9013 type
= cxx_make_type (DECLTYPE_TYPE
);
9014 DECLTYPE_TYPE_EXPR (type
) = ref
;
9015 DECLTYPE_FOR_LAMBDA_PROXY (type
) = true;
9016 SET_TYPE_STRUCTURAL_EQUALITY (type
);
9020 /* MEMBER is a capture field in a lambda closure class. Now that we're
9021 inside the operator(), build a placeholder var for future lookups and
9025 build_capture_proxy (tree member
)
9027 tree var
, object
, fn
, closure
, name
, lam
, type
;
9029 closure
= DECL_CONTEXT (member
);
9030 fn
= lambda_function (closure
);
9031 lam
= CLASSTYPE_LAMBDA_EXPR (closure
);
9033 /* The proxy variable forwards to the capture field. */
9034 object
= build_fold_indirect_ref (DECL_ARGUMENTS (fn
));
9035 object
= finish_non_static_data_member (member
, object
, NULL_TREE
);
9036 if (REFERENCE_REF_P (object
))
9037 object
= TREE_OPERAND (object
, 0);
9039 /* Remove the __ inserted by add_capture. */
9040 name
= get_identifier (IDENTIFIER_POINTER (DECL_NAME (member
)) + 2);
9042 type
= lambda_proxy_type (object
);
9043 var
= build_decl (input_location
, VAR_DECL
, name
, type
);
9044 SET_DECL_VALUE_EXPR (var
, object
);
9045 DECL_HAS_VALUE_EXPR_P (var
) = 1;
9046 DECL_ARTIFICIAL (var
) = 1;
9047 TREE_USED (var
) = 1;
9048 DECL_CONTEXT (var
) = fn
;
9050 if (name
== this_identifier
)
9052 gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (lam
) == member
);
9053 LAMBDA_EXPR_THIS_CAPTURE (lam
) = var
;
9056 if (fn
== current_function_decl
)
9057 insert_capture_proxy (var
);
9059 VEC_safe_push (tree
, gc
, LAMBDA_EXPR_PENDING_PROXIES (lam
), var
);
9064 /* From an ID and INITIALIZER, create a capture (by reference if
9065 BY_REFERENCE_P is true), add it to the capture-list for LAMBDA,
9069 add_capture (tree lambda
, tree id
, tree initializer
, bool by_reference_p
,
9070 bool explicit_init_p
)
9073 tree type
, member
, name
;
9075 type
= lambda_capture_field_type (initializer
);
9078 type
= build_reference_type (type
);
9079 if (!real_lvalue_p (initializer
))
9080 error ("cannot capture %qE by reference", initializer
);
9083 /* Capture by copy requires a complete type. */
9084 type
= complete_type (type
);
9086 /* Add __ to the beginning of the field name so that user code
9087 won't find the field with name lookup. We can't just leave the name
9088 unset because template instantiation uses the name to find
9089 instantiated fields. */
9090 buf
= (char *) alloca (IDENTIFIER_LENGTH (id
) + 3);
9091 buf
[1] = buf
[0] = '_';
9092 memcpy (buf
+ 2, IDENTIFIER_POINTER (id
),
9093 IDENTIFIER_LENGTH (id
) + 1);
9094 name
= get_identifier (buf
);
9096 /* If TREE_TYPE isn't set, we're still in the introducer, so check
9098 if (!LAMBDA_EXPR_CLOSURE (lambda
))
9100 if (IDENTIFIER_MARKED (name
))
9102 pedwarn (input_location
, 0,
9103 "already captured %qD in lambda expression", id
);
9106 IDENTIFIER_MARKED (name
) = true;
9109 /* Make member variable. */
9110 member
= build_lang_decl (FIELD_DECL
, name
, type
);
9112 if (!explicit_init_p
)
9113 /* Normal captures are invisible to name lookup but uses are replaced
9114 with references to the capture field; we implement this by only
9115 really making them invisible in unevaluated context; see
9116 qualify_lookup. For now, let's make explicitly initialized captures
9118 DECL_NORMAL_CAPTURE_P (member
) = true;
9120 if (id
== this_identifier
)
9121 LAMBDA_EXPR_THIS_CAPTURE (lambda
) = member
;
9123 /* Add it to the appropriate closure class if we've started it. */
9124 if (current_class_type
9125 && current_class_type
== LAMBDA_EXPR_CLOSURE (lambda
))
9126 finish_member_declaration (member
);
9128 LAMBDA_EXPR_CAPTURE_LIST (lambda
)
9129 = tree_cons (member
, initializer
, LAMBDA_EXPR_CAPTURE_LIST (lambda
));
9131 if (LAMBDA_EXPR_CLOSURE (lambda
))
9132 return build_capture_proxy (member
);
9133 /* For explicit captures we haven't started the function yet, so we wait
9134 and build the proxy from cp_parser_lambda_body. */
9138 /* Register all the capture members on the list CAPTURES, which is the
9139 LAMBDA_EXPR_CAPTURE_LIST for the lambda after the introducer. */
9142 register_capture_members (tree captures
)
9144 if (captures
== NULL_TREE
)
9147 register_capture_members (TREE_CHAIN (captures
));
9148 /* We set this in add_capture to avoid duplicates. */
9149 IDENTIFIER_MARKED (DECL_NAME (TREE_PURPOSE (captures
))) = false;
9150 finish_member_declaration (TREE_PURPOSE (captures
));
9153 /* Similar to add_capture, except this works on a stack of nested lambdas.
9154 BY_REFERENCE_P in this case is derived from the default capture mode.
9155 Returns the capture for the lambda at the bottom of the stack. */
9158 add_default_capture (tree lambda_stack
, tree id
, tree initializer
)
9160 bool this_capture_p
= (id
== this_identifier
);
9162 tree var
= NULL_TREE
;
9164 tree saved_class_type
= current_class_type
;
9168 for (node
= lambda_stack
;
9170 node
= TREE_CHAIN (node
))
9172 tree lambda
= TREE_VALUE (node
);
9174 current_class_type
= LAMBDA_EXPR_CLOSURE (lambda
);
9175 var
= add_capture (lambda
,
9180 && (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda
)
9181 == CPLD_REFERENCE
)),
9182 /*explicit_init_p=*/false);
9183 initializer
= convert_from_reference (var
);
9186 current_class_type
= saved_class_type
;
9191 /* Return the capture pertaining to a use of 'this' in LAMBDA, in the form of an
9192 INDIRECT_REF, possibly adding it through default capturing. */
9195 lambda_expr_this_capture (tree lambda
)
9199 tree this_capture
= LAMBDA_EXPR_THIS_CAPTURE (lambda
);
9201 /* Try to default capture 'this' if we can. */
9203 && LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda
) != CPLD_NONE
)
9205 tree containing_function
= TYPE_CONTEXT (LAMBDA_EXPR_CLOSURE (lambda
));
9206 tree lambda_stack
= tree_cons (NULL_TREE
, lambda
, NULL_TREE
);
9207 tree init
= NULL_TREE
;
9209 /* If we are in a lambda function, we can move out until we hit:
9210 1. a non-lambda function,
9211 2. a lambda function capturing 'this', or
9212 3. a non-default capturing lambda function. */
9213 while (LAMBDA_FUNCTION_P (containing_function
))
9216 = CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (containing_function
));
9218 if (LAMBDA_EXPR_THIS_CAPTURE (lambda
))
9220 /* An outer lambda has already captured 'this'. */
9221 init
= LAMBDA_EXPR_THIS_CAPTURE (lambda
);
9225 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda
) == CPLD_NONE
)
9226 /* An outer lambda won't let us capture 'this'. */
9229 lambda_stack
= tree_cons (NULL_TREE
,
9233 containing_function
= decl_function_context (containing_function
);
9236 if (!init
&& DECL_NONSTATIC_MEMBER_FUNCTION_P (containing_function
)
9237 && !LAMBDA_FUNCTION_P (containing_function
))
9238 /* First parameter is 'this'. */
9239 init
= DECL_ARGUMENTS (containing_function
);
9242 this_capture
= add_default_capture (lambda_stack
,
9243 /*id=*/this_identifier
,
9249 error ("%<this%> was not captured for this lambda function");
9250 result
= error_mark_node
;
9254 /* To make sure that current_class_ref is for the lambda. */
9255 gcc_assert (TYPE_MAIN_VARIANT (TREE_TYPE (current_class_ref
))
9256 == LAMBDA_EXPR_CLOSURE (lambda
));
9258 result
= this_capture
;
9260 /* If 'this' is captured, each use of 'this' is transformed into an
9261 access to the corresponding unnamed data member of the closure
9262 type cast (_expr.cast_ 5.4) to the type of 'this'. [ The cast
9263 ensures that the transformed expression is an rvalue. ] */
9264 result
= rvalue (result
);
9270 /* Returns the method basetype of the innermost non-lambda function, or
9271 NULL_TREE if none. */
9274 nonlambda_method_basetype (void)
9277 if (!current_class_ref
)
9280 type
= current_class_type
;
9281 if (!LAMBDA_TYPE_P (type
))
9284 /* Find the nearest enclosing non-lambda function. */
9285 fn
= TYPE_NAME (type
);
9287 fn
= decl_function_context (fn
);
9288 while (fn
&& LAMBDA_FUNCTION_P (fn
));
9290 if (!fn
|| !DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
9293 return TYPE_METHOD_BASETYPE (TREE_TYPE (fn
));
9296 /* If the closure TYPE has a static op(), also add a conversion to function
9300 maybe_add_lambda_conv_op (tree type
)
9302 bool nested
= (current_function_decl
!= NULL_TREE
);
9303 tree callop
= lambda_function (type
);
9304 tree rettype
, name
, fntype
, fn
, body
, compound_stmt
;
9305 tree thistype
, stattype
, statfn
, convfn
, call
, arg
;
9306 VEC (tree
, gc
) *argvec
;
9308 if (LAMBDA_EXPR_CAPTURE_LIST (CLASSTYPE_LAMBDA_EXPR (type
)) != NULL_TREE
)
9311 if (processing_template_decl
)
9314 stattype
= build_function_type (TREE_TYPE (TREE_TYPE (callop
)),
9315 FUNCTION_ARG_CHAIN (callop
));
9317 /* First build up the conversion op. */
9319 rettype
= build_pointer_type (stattype
);
9320 name
= mangle_conv_op_name_for_type (rettype
);
9321 thistype
= cp_build_qualified_type (type
, TYPE_QUAL_CONST
);
9322 fntype
= build_method_type_directly (thistype
, rettype
, void_list_node
);
9323 fn
= convfn
= build_lang_decl (FUNCTION_DECL
, name
, fntype
);
9324 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (callop
);
9326 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
9327 && DECL_ALIGN (fn
) < 2 * BITS_PER_UNIT
)
9328 DECL_ALIGN (fn
) = 2 * BITS_PER_UNIT
;
9330 SET_OVERLOADED_OPERATOR_CODE (fn
, TYPE_EXPR
);
9331 grokclassfn (type
, fn
, NO_SPECIAL
);
9332 set_linkage_according_to_type (type
, fn
);
9333 rest_of_decl_compilation (fn
, toplevel_bindings_p (), at_eof
);
9334 DECL_IN_AGGR_P (fn
) = 1;
9335 DECL_ARTIFICIAL (fn
) = 1;
9336 DECL_NOT_REALLY_EXTERN (fn
) = 1;
9337 DECL_DECLARED_INLINE_P (fn
) = 1;
9338 DECL_ARGUMENTS (fn
) = build_this_parm (fntype
, TYPE_QUAL_CONST
);
9340 add_method (type
, fn
, NULL_TREE
);
9342 /* Generic thunk code fails for varargs; we'll complain in mark_used if
9343 the conversion op is used. */
9344 if (varargs_function_p (callop
))
9346 DECL_DELETED_FN (fn
) = 1;
9350 /* Now build up the thunk to be returned. */
9352 name
= get_identifier ("_FUN");
9353 fn
= statfn
= build_lang_decl (FUNCTION_DECL
, name
, stattype
);
9354 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (callop
);
9355 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
9356 && DECL_ALIGN (fn
) < 2 * BITS_PER_UNIT
)
9357 DECL_ALIGN (fn
) = 2 * BITS_PER_UNIT
;
9358 grokclassfn (type
, fn
, NO_SPECIAL
);
9359 set_linkage_according_to_type (type
, fn
);
9360 rest_of_decl_compilation (fn
, toplevel_bindings_p (), at_eof
);
9361 DECL_IN_AGGR_P (fn
) = 1;
9362 DECL_ARTIFICIAL (fn
) = 1;
9363 DECL_NOT_REALLY_EXTERN (fn
) = 1;
9364 DECL_DECLARED_INLINE_P (fn
) = 1;
9365 DECL_STATIC_FUNCTION_P (fn
) = 1;
9366 DECL_ARGUMENTS (fn
) = copy_list (DECL_CHAIN (DECL_ARGUMENTS (callop
)));
9367 for (arg
= DECL_ARGUMENTS (fn
); arg
; arg
= DECL_CHAIN (arg
))
9368 DECL_CONTEXT (arg
) = fn
;
9370 add_method (type
, fn
, NULL_TREE
);
9373 push_function_context ();
9375 /* Still increment function_depth so that we don't GC in the
9376 middle of an expression. */
9379 /* Generate the body of the thunk. */
9381 start_preparsed_function (statfn
, NULL_TREE
,
9382 SF_PRE_PARSED
| SF_INCLASS_INLINE
);
9383 if (DECL_ONE_ONLY (statfn
))
9385 /* Put the thunk in the same comdat group as the call op. */
9386 symtab_add_to_same_comdat_group
9387 ((symtab_node
) cgraph_get_create_node (statfn
),
9388 (symtab_node
) cgraph_get_create_node (callop
));
9390 body
= begin_function_body ();
9391 compound_stmt
= begin_compound_stmt (0);
9393 arg
= build1 (NOP_EXPR
, TREE_TYPE (DECL_ARGUMENTS (callop
)),
9395 argvec
= make_tree_vector ();
9396 VEC_quick_push (tree
, argvec
, arg
);
9397 for (arg
= DECL_ARGUMENTS (statfn
); arg
; arg
= DECL_CHAIN (arg
))
9399 mark_exp_read (arg
);
9400 VEC_safe_push (tree
, gc
, argvec
, arg
);
9402 call
= build_call_a (callop
, VEC_length (tree
, argvec
),
9403 VEC_address (tree
, argvec
));
9404 CALL_FROM_THUNK_P (call
) = 1;
9405 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (call
)))
9406 call
= build_cplus_new (TREE_TYPE (call
), call
, tf_warning_or_error
);
9407 call
= convert_from_reference (call
);
9408 finish_return_stmt (call
);
9410 finish_compound_stmt (compound_stmt
);
9411 finish_function_body (body
);
9413 expand_or_defer_fn (finish_function (2));
9415 /* Generate the body of the conversion op. */
9417 start_preparsed_function (convfn
, NULL_TREE
,
9418 SF_PRE_PARSED
| SF_INCLASS_INLINE
);
9419 body
= begin_function_body ();
9420 compound_stmt
= begin_compound_stmt (0);
9422 finish_return_stmt (decay_conversion (statfn
, tf_warning_or_error
));
9424 finish_compound_stmt (compound_stmt
);
9425 finish_function_body (body
);
9427 expand_or_defer_fn (finish_function (2));
9430 pop_function_context ();
9435 /* Returns true iff VAL is a lambda-related declaration which should
9436 be ignored by unqualified lookup. */
9439 is_lambda_ignored_entity (tree val
)
9441 /* In unevaluated context, look past normal capture proxies. */
9442 if (cp_unevaluated_operand
&& is_normal_capture_proxy (val
))
9445 /* Always ignore lambda fields, their names are only for debugging. */
9446 if (TREE_CODE (val
) == FIELD_DECL
9447 && CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (val
)))
9450 /* None of the lookups that use qualify_lookup want the op() from the
9451 lambda; they want the one from the enclosing class. */
9452 if (TREE_CODE (val
) == FUNCTION_DECL
&& LAMBDA_FUNCTION_P (val
))
9458 #include "gt-cp-semantics.h"