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
))
575 = fold_build_cleanup_point_expr (TREE_TYPE (destination
),
580 check_goto (destination
);
582 return add_stmt (build_stmt (input_location
, GOTO_EXPR
, destination
));
585 /* COND is the condition-expression for an if, while, etc.,
586 statement. Convert it to a boolean value, if appropriate.
587 In addition, verify sequence points if -Wsequence-point is enabled. */
590 maybe_convert_cond (tree cond
)
592 /* Empty conditions remain empty. */
596 /* Wait until we instantiate templates before doing conversion. */
597 if (processing_template_decl
)
600 if (warn_sequence_point
)
601 verify_sequence_points (cond
);
603 /* Do the conversion. */
604 cond
= convert_from_reference (cond
);
606 if (TREE_CODE (cond
) == MODIFY_EXPR
607 && !TREE_NO_WARNING (cond
)
610 warning (OPT_Wparentheses
,
611 "suggest parentheses around assignment used as truth value");
612 TREE_NO_WARNING (cond
) = 1;
615 return condition_conversion (cond
);
618 /* Finish an expression-statement, whose EXPRESSION is as indicated. */
621 finish_expr_stmt (tree expr
)
625 if (expr
!= NULL_TREE
)
627 if (!processing_template_decl
)
629 if (warn_sequence_point
)
630 verify_sequence_points (expr
);
631 expr
= convert_to_void (expr
, ICV_STATEMENT
, tf_warning_or_error
);
633 else if (!type_dependent_expression_p (expr
))
634 convert_to_void (build_non_dependent_expr (expr
), ICV_STATEMENT
,
635 tf_warning_or_error
);
637 if (check_for_bare_parameter_packs (expr
))
638 expr
= error_mark_node
;
640 /* Simplification of inner statement expressions, compound exprs,
641 etc can result in us already having an EXPR_STMT. */
642 if (TREE_CODE (expr
) != CLEANUP_POINT_EXPR
)
644 if (TREE_CODE (expr
) != EXPR_STMT
)
645 expr
= build_stmt (input_location
, EXPR_STMT
, expr
);
646 expr
= maybe_cleanup_point_expr_void (expr
);
658 /* Begin an if-statement. Returns a newly created IF_STMT if
665 scope
= do_pushlevel (sk_cond
);
666 r
= build_stmt (input_location
, IF_STMT
, NULL_TREE
,
667 NULL_TREE
, NULL_TREE
, scope
);
668 begin_cond (&IF_COND (r
));
672 /* Process the COND of an if-statement, which may be given by
676 finish_if_stmt_cond (tree cond
, tree if_stmt
)
678 finish_cond (&IF_COND (if_stmt
), maybe_convert_cond (cond
));
680 THEN_CLAUSE (if_stmt
) = push_stmt_list ();
683 /* Finish the then-clause of an if-statement, which may be given by
687 finish_then_clause (tree if_stmt
)
689 THEN_CLAUSE (if_stmt
) = pop_stmt_list (THEN_CLAUSE (if_stmt
));
693 /* Begin the else-clause of an if-statement. */
696 begin_else_clause (tree if_stmt
)
698 ELSE_CLAUSE (if_stmt
) = push_stmt_list ();
701 /* Finish the else-clause of an if-statement, which may be given by
705 finish_else_clause (tree if_stmt
)
707 ELSE_CLAUSE (if_stmt
) = pop_stmt_list (ELSE_CLAUSE (if_stmt
));
710 /* Finish an if-statement. */
713 finish_if_stmt (tree if_stmt
)
715 tree scope
= IF_SCOPE (if_stmt
);
716 IF_SCOPE (if_stmt
) = NULL
;
717 add_stmt (do_poplevel (scope
));
721 /* Begin a while-statement. Returns a newly created WHILE_STMT if
725 begin_while_stmt (void)
728 r
= build_stmt (input_location
, WHILE_STMT
, NULL_TREE
, NULL_TREE
);
730 WHILE_BODY (r
) = do_pushlevel (sk_block
);
731 begin_cond (&WHILE_COND (r
));
735 /* Process the COND of a while-statement, which may be given by
739 finish_while_stmt_cond (tree cond
, tree while_stmt
)
741 finish_cond (&WHILE_COND (while_stmt
), maybe_convert_cond (cond
));
742 simplify_loop_decl_cond (&WHILE_COND (while_stmt
), WHILE_BODY (while_stmt
));
745 /* Finish a while-statement, which may be given by WHILE_STMT. */
748 finish_while_stmt (tree while_stmt
)
750 WHILE_BODY (while_stmt
) = do_poplevel (WHILE_BODY (while_stmt
));
754 /* Begin a do-statement. Returns a newly created DO_STMT if
760 tree r
= build_stmt (input_location
, DO_STMT
, NULL_TREE
, NULL_TREE
);
762 DO_BODY (r
) = push_stmt_list ();
766 /* Finish the body of a do-statement, which may be given by DO_STMT. */
769 finish_do_body (tree do_stmt
)
771 tree body
= DO_BODY (do_stmt
) = pop_stmt_list (DO_BODY (do_stmt
));
773 if (TREE_CODE (body
) == STATEMENT_LIST
&& STATEMENT_LIST_TAIL (body
))
774 body
= STATEMENT_LIST_TAIL (body
)->stmt
;
776 if (IS_EMPTY_STMT (body
))
777 warning (OPT_Wempty_body
,
778 "suggest explicit braces around empty body in %<do%> statement");
781 /* Finish a do-statement, which may be given by DO_STMT, and whose
782 COND is as indicated. */
785 finish_do_stmt (tree cond
, tree do_stmt
)
787 cond
= maybe_convert_cond (cond
);
788 DO_COND (do_stmt
) = cond
;
792 /* Finish a return-statement. The EXPRESSION returned, if any, is as
796 finish_return_stmt (tree expr
)
801 expr
= check_return_expr (expr
, &no_warning
);
803 if (flag_openmp
&& !check_omp_return ())
804 return error_mark_node
;
805 if (!processing_template_decl
)
807 if (warn_sequence_point
)
808 verify_sequence_points (expr
);
810 if (DECL_DESTRUCTOR_P (current_function_decl
)
811 || (DECL_CONSTRUCTOR_P (current_function_decl
)
812 && targetm
.cxx
.cdtor_returns_this ()))
814 /* Similarly, all destructors must run destructors for
815 base-classes before returning. So, all returns in a
816 destructor get sent to the DTOR_LABEL; finish_function emits
817 code to return a value there. */
818 return finish_goto_stmt (cdtor_label
);
822 r
= build_stmt (input_location
, RETURN_EXPR
, expr
);
823 TREE_NO_WARNING (r
) |= no_warning
;
824 r
= maybe_cleanup_point_expr_void (r
);
831 /* Begin the scope of a for-statement or a range-for-statement.
832 Both the returned trees are to be used in a call to
833 begin_for_stmt or begin_range_for_stmt. */
836 begin_for_scope (tree
*init
)
838 tree scope
= NULL_TREE
;
839 if (flag_new_for_scope
> 0)
840 scope
= do_pushlevel (sk_for
);
842 if (processing_template_decl
)
843 *init
= push_stmt_list ();
850 /* Begin a for-statement. Returns a new FOR_STMT.
851 SCOPE and INIT should be the return of begin_for_scope,
855 begin_for_stmt (tree scope
, tree init
)
859 r
= build_stmt (input_location
, FOR_STMT
, NULL_TREE
, NULL_TREE
,
860 NULL_TREE
, NULL_TREE
, NULL_TREE
);
862 if (scope
== NULL_TREE
)
864 gcc_assert (!init
|| !(flag_new_for_scope
> 0));
866 scope
= begin_for_scope (&init
);
868 FOR_INIT_STMT (r
) = init
;
869 FOR_SCOPE (r
) = scope
;
874 /* Finish the for-init-statement of a for-statement, which may be
875 given by FOR_STMT. */
878 finish_for_init_stmt (tree for_stmt
)
880 if (processing_template_decl
)
881 FOR_INIT_STMT (for_stmt
) = pop_stmt_list (FOR_INIT_STMT (for_stmt
));
883 FOR_BODY (for_stmt
) = do_pushlevel (sk_block
);
884 begin_cond (&FOR_COND (for_stmt
));
887 /* Finish the COND of a for-statement, which may be given by
891 finish_for_cond (tree cond
, tree for_stmt
)
893 finish_cond (&FOR_COND (for_stmt
), maybe_convert_cond (cond
));
894 simplify_loop_decl_cond (&FOR_COND (for_stmt
), FOR_BODY (for_stmt
));
897 /* Finish the increment-EXPRESSION in a for-statement, which may be
898 given by FOR_STMT. */
901 finish_for_expr (tree expr
, tree for_stmt
)
905 /* If EXPR is an overloaded function, issue an error; there is no
906 context available to use to perform overload resolution. */
907 if (type_unknown_p (expr
))
909 cxx_incomplete_type_error (expr
, TREE_TYPE (expr
));
910 expr
= error_mark_node
;
912 if (!processing_template_decl
)
914 if (warn_sequence_point
)
915 verify_sequence_points (expr
);
916 expr
= convert_to_void (expr
, ICV_THIRD_IN_FOR
,
917 tf_warning_or_error
);
919 else if (!type_dependent_expression_p (expr
))
920 convert_to_void (build_non_dependent_expr (expr
), ICV_THIRD_IN_FOR
,
921 tf_warning_or_error
);
922 expr
= maybe_cleanup_point_expr_void (expr
);
923 if (check_for_bare_parameter_packs (expr
))
924 expr
= error_mark_node
;
925 FOR_EXPR (for_stmt
) = expr
;
928 /* Finish the body of a for-statement, which may be given by
929 FOR_STMT. The increment-EXPR for the loop must be
931 It can also finish RANGE_FOR_STMT. */
934 finish_for_stmt (tree for_stmt
)
936 if (TREE_CODE (for_stmt
) == RANGE_FOR_STMT
)
937 RANGE_FOR_BODY (for_stmt
) = do_poplevel (RANGE_FOR_BODY (for_stmt
));
939 FOR_BODY (for_stmt
) = do_poplevel (FOR_BODY (for_stmt
));
941 /* Pop the scope for the body of the loop. */
942 if (flag_new_for_scope
> 0)
945 tree
*scope_ptr
= (TREE_CODE (for_stmt
) == RANGE_FOR_STMT
946 ? &RANGE_FOR_SCOPE (for_stmt
)
947 : &FOR_SCOPE (for_stmt
));
950 add_stmt (do_poplevel (scope
));
956 /* Begin a range-for-statement. Returns a new RANGE_FOR_STMT.
957 SCOPE and INIT should be the return of begin_for_scope,
959 To finish it call finish_for_stmt(). */
962 begin_range_for_stmt (tree scope
, tree init
)
966 r
= build_stmt (input_location
, RANGE_FOR_STMT
,
967 NULL_TREE
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
969 if (scope
== NULL_TREE
)
971 gcc_assert (!init
|| !(flag_new_for_scope
> 0));
973 scope
= begin_for_scope (&init
);
976 /* RANGE_FOR_STMTs do not use nor save the init tree, so we
979 pop_stmt_list (init
);
980 RANGE_FOR_SCOPE (r
) = scope
;
985 /* Finish the head of a range-based for statement, which may
986 be given by RANGE_FOR_STMT. DECL must be the declaration
987 and EXPR must be the loop expression. */
990 finish_range_for_decl (tree range_for_stmt
, tree decl
, tree expr
)
992 RANGE_FOR_DECL (range_for_stmt
) = decl
;
993 RANGE_FOR_EXPR (range_for_stmt
) = expr
;
994 add_stmt (range_for_stmt
);
995 RANGE_FOR_BODY (range_for_stmt
) = do_pushlevel (sk_block
);
998 /* Finish a break-statement. */
1001 finish_break_stmt (void)
1003 /* In switch statements break is sometimes stylistically used after
1004 a return statement. This can lead to spurious warnings about
1005 control reaching the end of a non-void function when it is
1006 inlined. Note that we are calling block_may_fallthru with
1007 language specific tree nodes; this works because
1008 block_may_fallthru returns true when given something it does not
1010 if (!block_may_fallthru (cur_stmt_list
))
1011 return void_zero_node
;
1012 return add_stmt (build_stmt (input_location
, BREAK_STMT
));
1015 /* Finish a continue-statement. */
1018 finish_continue_stmt (void)
1020 return add_stmt (build_stmt (input_location
, CONTINUE_STMT
));
1023 /* Begin a switch-statement. Returns a new SWITCH_STMT if
1027 begin_switch_stmt (void)
1031 scope
= do_pushlevel (sk_cond
);
1032 r
= build_stmt (input_location
, SWITCH_STMT
, NULL_TREE
, NULL_TREE
, NULL_TREE
, scope
);
1034 begin_cond (&SWITCH_STMT_COND (r
));
1039 /* Finish the cond of a switch-statement. */
1042 finish_switch_cond (tree cond
, tree switch_stmt
)
1044 tree orig_type
= NULL
;
1045 if (!processing_template_decl
)
1047 /* Convert the condition to an integer or enumeration type. */
1048 cond
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
, cond
, true);
1049 if (cond
== NULL_TREE
)
1051 error ("switch quantity not an integer");
1052 cond
= error_mark_node
;
1054 orig_type
= TREE_TYPE (cond
);
1055 if (cond
!= error_mark_node
)
1059 Integral promotions are performed. */
1060 cond
= perform_integral_promotions (cond
);
1061 cond
= maybe_cleanup_point_expr (cond
);
1064 if (check_for_bare_parameter_packs (cond
))
1065 cond
= error_mark_node
;
1066 else if (!processing_template_decl
&& warn_sequence_point
)
1067 verify_sequence_points (cond
);
1069 finish_cond (&SWITCH_STMT_COND (switch_stmt
), cond
);
1070 SWITCH_STMT_TYPE (switch_stmt
) = orig_type
;
1071 add_stmt (switch_stmt
);
1072 push_switch (switch_stmt
);
1073 SWITCH_STMT_BODY (switch_stmt
) = push_stmt_list ();
1076 /* Finish the body of a switch-statement, which may be given by
1077 SWITCH_STMT. The COND to switch on is indicated. */
1080 finish_switch_stmt (tree switch_stmt
)
1084 SWITCH_STMT_BODY (switch_stmt
) =
1085 pop_stmt_list (SWITCH_STMT_BODY (switch_stmt
));
1089 scope
= SWITCH_STMT_SCOPE (switch_stmt
);
1090 SWITCH_STMT_SCOPE (switch_stmt
) = NULL
;
1091 add_stmt (do_poplevel (scope
));
1094 /* Begin a try-block. Returns a newly-created TRY_BLOCK if
1098 begin_try_block (void)
1100 tree r
= build_stmt (input_location
, TRY_BLOCK
, NULL_TREE
, NULL_TREE
);
1102 TRY_STMTS (r
) = push_stmt_list ();
1106 /* Likewise, for a function-try-block. The block returned in
1107 *COMPOUND_STMT is an artificial outer scope, containing the
1108 function-try-block. */
1111 begin_function_try_block (tree
*compound_stmt
)
1114 /* This outer scope does not exist in the C++ standard, but we need
1115 a place to put __FUNCTION__ and similar variables. */
1116 *compound_stmt
= begin_compound_stmt (0);
1117 r
= begin_try_block ();
1118 FN_TRY_BLOCK_P (r
) = 1;
1122 /* Finish a try-block, which may be given by TRY_BLOCK. */
1125 finish_try_block (tree try_block
)
1127 TRY_STMTS (try_block
) = pop_stmt_list (TRY_STMTS (try_block
));
1128 TRY_HANDLERS (try_block
) = push_stmt_list ();
1131 /* Finish the body of a cleanup try-block, which may be given by
1135 finish_cleanup_try_block (tree try_block
)
1137 TRY_STMTS (try_block
) = pop_stmt_list (TRY_STMTS (try_block
));
1140 /* Finish an implicitly generated try-block, with a cleanup is given
1144 finish_cleanup (tree cleanup
, tree try_block
)
1146 TRY_HANDLERS (try_block
) = cleanup
;
1147 CLEANUP_P (try_block
) = 1;
1150 /* Likewise, for a function-try-block. */
1153 finish_function_try_block (tree try_block
)
1155 finish_try_block (try_block
);
1156 /* FIXME : something queer about CTOR_INITIALIZER somehow following
1157 the try block, but moving it inside. */
1158 in_function_try_handler
= 1;
1161 /* Finish a handler-sequence for a try-block, which may be given by
1165 finish_handler_sequence (tree try_block
)
1167 TRY_HANDLERS (try_block
) = pop_stmt_list (TRY_HANDLERS (try_block
));
1168 check_handlers (TRY_HANDLERS (try_block
));
1171 /* Finish the handler-seq for a function-try-block, given by
1172 TRY_BLOCK. COMPOUND_STMT is the outer block created by
1173 begin_function_try_block. */
1176 finish_function_handler_sequence (tree try_block
, tree compound_stmt
)
1178 in_function_try_handler
= 0;
1179 finish_handler_sequence (try_block
);
1180 finish_compound_stmt (compound_stmt
);
1183 /* Begin a handler. Returns a HANDLER if appropriate. */
1186 begin_handler (void)
1190 r
= build_stmt (input_location
, HANDLER
, NULL_TREE
, NULL_TREE
);
1193 /* Create a binding level for the eh_info and the exception object
1195 HANDLER_BODY (r
) = do_pushlevel (sk_catch
);
1200 /* Finish the handler-parameters for a handler, which may be given by
1201 HANDLER. DECL is the declaration for the catch parameter, or NULL
1202 if this is a `catch (...)' clause. */
1205 finish_handler_parms (tree decl
, tree handler
)
1207 tree type
= NULL_TREE
;
1208 if (processing_template_decl
)
1212 decl
= pushdecl (decl
);
1213 decl
= push_template_decl (decl
);
1214 HANDLER_PARMS (handler
) = decl
;
1215 type
= TREE_TYPE (decl
);
1219 type
= expand_start_catch_block (decl
);
1220 HANDLER_TYPE (handler
) = type
;
1221 if (!processing_template_decl
&& type
)
1222 mark_used (eh_type_info (type
));
1225 /* Finish a handler, which may be given by HANDLER. The BLOCKs are
1226 the return value from the matching call to finish_handler_parms. */
1229 finish_handler (tree handler
)
1231 if (!processing_template_decl
)
1232 expand_end_catch_block ();
1233 HANDLER_BODY (handler
) = do_poplevel (HANDLER_BODY (handler
));
1236 /* Begin a compound statement. FLAGS contains some bits that control the
1237 behavior and context. If BCS_NO_SCOPE is set, the compound statement
1238 does not define a scope. If BCS_FN_BODY is set, this is the outermost
1239 block of a function. If BCS_TRY_BLOCK is set, this is the block
1240 created on behalf of a TRY statement. Returns a token to be passed to
1241 finish_compound_stmt. */
1244 begin_compound_stmt (unsigned int flags
)
1248 if (flags
& BCS_NO_SCOPE
)
1250 r
= push_stmt_list ();
1251 STATEMENT_LIST_NO_SCOPE (r
) = 1;
1253 /* Normally, we try hard to keep the BLOCK for a statement-expression.
1254 But, if it's a statement-expression with a scopeless block, there's
1255 nothing to keep, and we don't want to accidentally keep a block
1256 *inside* the scopeless block. */
1257 keep_next_level (false);
1260 r
= do_pushlevel (flags
& BCS_TRY_BLOCK
? sk_try
: sk_block
);
1262 /* When processing a template, we need to remember where the braces were,
1263 so that we can set up identical scopes when instantiating the template
1264 later. BIND_EXPR is a handy candidate for this.
1265 Note that do_poplevel won't create a BIND_EXPR itself here (and thus
1266 result in nested BIND_EXPRs), since we don't build BLOCK nodes when
1267 processing templates. */
1268 if (processing_template_decl
)
1270 r
= build3 (BIND_EXPR
, NULL
, NULL
, r
, NULL
);
1271 BIND_EXPR_TRY_BLOCK (r
) = (flags
& BCS_TRY_BLOCK
) != 0;
1272 BIND_EXPR_BODY_BLOCK (r
) = (flags
& BCS_FN_BODY
) != 0;
1273 TREE_SIDE_EFFECTS (r
) = 1;
1279 /* Finish a compound-statement, which is given by STMT. */
1282 finish_compound_stmt (tree stmt
)
1284 if (TREE_CODE (stmt
) == BIND_EXPR
)
1286 tree body
= do_poplevel (BIND_EXPR_BODY (stmt
));
1287 /* If the STATEMENT_LIST is empty and this BIND_EXPR isn't special,
1288 discard the BIND_EXPR so it can be merged with the containing
1290 if (TREE_CODE (body
) == STATEMENT_LIST
1291 && STATEMENT_LIST_HEAD (body
) == NULL
1292 && !BIND_EXPR_BODY_BLOCK (stmt
)
1293 && !BIND_EXPR_TRY_BLOCK (stmt
))
1296 BIND_EXPR_BODY (stmt
) = body
;
1298 else if (STATEMENT_LIST_NO_SCOPE (stmt
))
1299 stmt
= pop_stmt_list (stmt
);
1302 /* Destroy any ObjC "super" receivers that may have been
1304 objc_clear_super_receiver ();
1306 stmt
= do_poplevel (stmt
);
1309 /* ??? See c_end_compound_stmt wrt statement expressions. */
1314 /* Finish an asm-statement, whose components are a STRING, some
1315 OUTPUT_OPERANDS, some INPUT_OPERANDS, some CLOBBERS and some
1316 LABELS. Also note whether the asm-statement should be
1317 considered volatile. */
1320 finish_asm_stmt (int volatile_p
, tree string
, tree output_operands
,
1321 tree input_operands
, tree clobbers
, tree labels
)
1325 int ninputs
= list_length (input_operands
);
1326 int noutputs
= list_length (output_operands
);
1328 if (!processing_template_decl
)
1330 const char *constraint
;
1331 const char **oconstraints
;
1332 bool allows_mem
, allows_reg
, is_inout
;
1336 oconstraints
= XALLOCAVEC (const char *, noutputs
);
1338 string
= resolve_asm_operand_names (string
, output_operands
,
1339 input_operands
, labels
);
1341 for (i
= 0, t
= output_operands
; t
; t
= TREE_CHAIN (t
), ++i
)
1343 operand
= TREE_VALUE (t
);
1345 /* ??? Really, this should not be here. Users should be using a
1346 proper lvalue, dammit. But there's a long history of using
1347 casts in the output operands. In cases like longlong.h, this
1348 becomes a primitive form of typechecking -- if the cast can be
1349 removed, then the output operand had a type of the proper width;
1350 otherwise we'll get an error. Gross, but ... */
1351 STRIP_NOPS (operand
);
1353 operand
= mark_lvalue_use (operand
);
1355 if (!lvalue_or_else (operand
, lv_asm
, tf_warning_or_error
))
1356 operand
= error_mark_node
;
1358 if (operand
!= error_mark_node
1359 && (TREE_READONLY (operand
)
1360 || CP_TYPE_CONST_P (TREE_TYPE (operand
))
1361 /* Functions are not modifiable, even though they are
1363 || TREE_CODE (TREE_TYPE (operand
)) == FUNCTION_TYPE
1364 || TREE_CODE (TREE_TYPE (operand
)) == METHOD_TYPE
1365 /* If it's an aggregate and any field is const, then it is
1366 effectively const. */
1367 || (CLASS_TYPE_P (TREE_TYPE (operand
))
1368 && C_TYPE_FIELDS_READONLY (TREE_TYPE (operand
)))))
1369 cxx_readonly_error (operand
, lv_asm
);
1371 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
1372 oconstraints
[i
] = constraint
;
1374 if (parse_output_constraint (&constraint
, i
, ninputs
, noutputs
,
1375 &allows_mem
, &allows_reg
, &is_inout
))
1377 /* If the operand is going to end up in memory,
1378 mark it addressable. */
1379 if (!allows_reg
&& !cxx_mark_addressable (operand
))
1380 operand
= error_mark_node
;
1383 operand
= error_mark_node
;
1385 TREE_VALUE (t
) = operand
;
1388 for (i
= 0, t
= input_operands
; t
; ++i
, t
= TREE_CHAIN (t
))
1390 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
1391 operand
= decay_conversion (TREE_VALUE (t
), tf_warning_or_error
);
1393 /* If the type of the operand hasn't been determined (e.g.,
1394 because it involves an overloaded function), then issue
1395 an error message. There's no context available to
1396 resolve the overloading. */
1397 if (TREE_TYPE (operand
) == unknown_type_node
)
1399 error ("type of asm operand %qE could not be determined",
1401 operand
= error_mark_node
;
1404 if (parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, 0,
1405 oconstraints
, &allows_mem
, &allows_reg
))
1407 /* If the operand is going to end up in memory,
1408 mark it addressable. */
1409 if (!allows_reg
&& allows_mem
)
1411 /* Strip the nops as we allow this case. FIXME, this really
1412 should be rejected or made deprecated. */
1413 STRIP_NOPS (operand
);
1414 if (!cxx_mark_addressable (operand
))
1415 operand
= error_mark_node
;
1419 operand
= error_mark_node
;
1421 TREE_VALUE (t
) = operand
;
1425 r
= build_stmt (input_location
, ASM_EXPR
, string
,
1426 output_operands
, input_operands
,
1428 ASM_VOLATILE_P (r
) = volatile_p
|| noutputs
== 0;
1429 r
= maybe_cleanup_point_expr_void (r
);
1430 return add_stmt (r
);
1433 /* Finish a label with the indicated NAME. Returns the new label. */
1436 finish_label_stmt (tree name
)
1438 tree decl
= define_label (input_location
, name
);
1440 if (decl
== error_mark_node
)
1441 return error_mark_node
;
1443 add_stmt (build_stmt (input_location
, LABEL_EXPR
, decl
));
1448 /* Finish a series of declarations for local labels. G++ allows users
1449 to declare "local" labels, i.e., labels with scope. This extension
1450 is useful when writing code involving statement-expressions. */
1453 finish_label_decl (tree name
)
1455 if (!at_function_scope_p ())
1457 error ("__label__ declarations are only allowed in function scopes");
1461 add_decl_expr (declare_local_label (name
));
1464 /* When DECL goes out of scope, make sure that CLEANUP is executed. */
1467 finish_decl_cleanup (tree decl
, tree cleanup
)
1469 push_cleanup (decl
, cleanup
, false);
1472 /* If the current scope exits with an exception, run CLEANUP. */
1475 finish_eh_cleanup (tree cleanup
)
1477 push_cleanup (NULL
, cleanup
, true);
1480 /* The MEM_INITS is a list of mem-initializers, in reverse of the
1481 order they were written by the user. Each node is as for
1482 emit_mem_initializers. */
1485 finish_mem_initializers (tree mem_inits
)
1487 /* Reorder the MEM_INITS so that they are in the order they appeared
1488 in the source program. */
1489 mem_inits
= nreverse (mem_inits
);
1491 if (processing_template_decl
)
1495 for (mem
= mem_inits
; mem
; mem
= TREE_CHAIN (mem
))
1497 /* If the TREE_PURPOSE is a TYPE_PACK_EXPANSION, skip the
1498 check for bare parameter packs in the TREE_VALUE, because
1499 any parameter packs in the TREE_VALUE have already been
1500 bound as part of the TREE_PURPOSE. See
1501 make_pack_expansion for more information. */
1502 if (TREE_CODE (TREE_PURPOSE (mem
)) != TYPE_PACK_EXPANSION
1503 && check_for_bare_parameter_packs (TREE_VALUE (mem
)))
1504 TREE_VALUE (mem
) = error_mark_node
;
1507 add_stmt (build_min_nt_loc (UNKNOWN_LOCATION
,
1508 CTOR_INITIALIZER
, mem_inits
));
1511 emit_mem_initializers (mem_inits
);
1514 /* Finish a parenthesized expression EXPR. */
1517 finish_parenthesized_expr (tree expr
)
1520 /* This inhibits warnings in c_common_truthvalue_conversion. */
1521 TREE_NO_WARNING (expr
) = 1;
1523 if (TREE_CODE (expr
) == OFFSET_REF
1524 || TREE_CODE (expr
) == SCOPE_REF
)
1525 /* [expr.unary.op]/3 The qualified id of a pointer-to-member must not be
1526 enclosed in parentheses. */
1527 PTRMEM_OK_P (expr
) = 0;
1529 if (TREE_CODE (expr
) == STRING_CST
)
1530 PAREN_STRING_LITERAL_P (expr
) = 1;
1535 /* Finish a reference to a non-static data member (DECL) that is not
1536 preceded by `.' or `->'. */
1539 finish_non_static_data_member (tree decl
, tree object
, tree qualifying_scope
)
1541 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
);
1545 tree scope
= qualifying_scope
;
1546 if (scope
== NULL_TREE
)
1547 scope
= context_for_name_lookup (decl
);
1548 object
= maybe_dummy_object (scope
, NULL
);
1551 if (object
== error_mark_node
)
1552 return error_mark_node
;
1554 /* DR 613: Can use non-static data members without an associated
1555 object in sizeof/decltype/alignof. */
1556 if (is_dummy_object (object
) && cp_unevaluated_operand
== 0
1557 && (!processing_template_decl
|| !current_class_ref
))
1559 if (current_function_decl
1560 && DECL_STATIC_FUNCTION_P (current_function_decl
))
1561 error ("invalid use of member %q+D in static member function", decl
);
1563 error ("invalid use of non-static data member %q+D", decl
);
1564 error ("from this location");
1566 return error_mark_node
;
1569 if (current_class_ptr
)
1570 TREE_USED (current_class_ptr
) = 1;
1571 if (processing_template_decl
&& !qualifying_scope
)
1573 tree type
= TREE_TYPE (decl
);
1575 if (TREE_CODE (type
) == REFERENCE_TYPE
)
1576 /* Quals on the object don't matter. */;
1579 /* Set the cv qualifiers. */
1580 int quals
= (current_class_ref
1581 ? cp_type_quals (TREE_TYPE (current_class_ref
))
1582 : TYPE_UNQUALIFIED
);
1584 if (DECL_MUTABLE_P (decl
))
1585 quals
&= ~TYPE_QUAL_CONST
;
1587 quals
|= cp_type_quals (TREE_TYPE (decl
));
1588 type
= cp_build_qualified_type (type
, quals
);
1591 return (convert_from_reference
1592 (build_min (COMPONENT_REF
, type
, object
, decl
, NULL_TREE
)));
1594 /* If PROCESSING_TEMPLATE_DECL is nonzero here, then
1595 QUALIFYING_SCOPE is also non-null. Wrap this in a SCOPE_REF
1597 else if (processing_template_decl
)
1598 return build_qualified_name (TREE_TYPE (decl
),
1601 /*template_p=*/false);
1604 tree access_type
= TREE_TYPE (object
);
1606 perform_or_defer_access_check (TYPE_BINFO (access_type
), decl
,
1609 /* If the data member was named `C::M', convert `*this' to `C'
1611 if (qualifying_scope
)
1613 tree binfo
= NULL_TREE
;
1614 object
= build_scoped_ref (object
, qualifying_scope
,
1618 return build_class_member_access_expr (object
, decl
,
1619 /*access_path=*/NULL_TREE
,
1620 /*preserve_reference=*/false,
1621 tf_warning_or_error
);
1625 /* If we are currently parsing a template and we encountered a typedef
1626 TYPEDEF_DECL that is being accessed though CONTEXT, this function
1627 adds the typedef to a list tied to the current template.
1628 At template instantiation time, that list is walked and access check
1629 performed for each typedef.
1630 LOCATION is the location of the usage point of TYPEDEF_DECL. */
1633 add_typedef_to_current_template_for_access_check (tree typedef_decl
,
1635 location_t location
)
1637 tree template_info
= NULL
;
1638 tree cs
= current_scope ();
1640 if (!is_typedef_decl (typedef_decl
)
1642 || !CLASS_TYPE_P (context
)
1646 if (CLASS_TYPE_P (cs
) || TREE_CODE (cs
) == FUNCTION_DECL
)
1647 template_info
= get_template_info (cs
);
1650 && TI_TEMPLATE (template_info
)
1651 && !currently_open_class (context
))
1652 append_type_to_template_for_access_check (cs
, typedef_decl
,
1656 /* DECL was the declaration to which a qualified-id resolved. Issue
1657 an error message if it is not accessible. If OBJECT_TYPE is
1658 non-NULL, we have just seen `x->' or `x.' and OBJECT_TYPE is the
1659 type of `*x', or `x', respectively. If the DECL was named as
1660 `A::B' then NESTED_NAME_SPECIFIER is `A'. */
1663 check_accessibility_of_qualified_id (tree decl
,
1665 tree nested_name_specifier
)
1668 tree qualifying_type
= NULL_TREE
;
1670 /* If we are parsing a template declaration and if decl is a typedef,
1671 add it to a list tied to the template.
1672 At template instantiation time, that list will be walked and
1673 access check performed. */
1674 add_typedef_to_current_template_for_access_check (decl
,
1675 nested_name_specifier
1676 ? nested_name_specifier
1677 : DECL_CONTEXT (decl
),
1680 /* If we're not checking, return immediately. */
1681 if (deferred_access_no_check
)
1684 /* Determine the SCOPE of DECL. */
1685 scope
= context_for_name_lookup (decl
);
1686 /* If the SCOPE is not a type, then DECL is not a member. */
1687 if (!TYPE_P (scope
))
1689 /* Compute the scope through which DECL is being accessed. */
1691 /* OBJECT_TYPE might not be a class type; consider:
1693 class A { typedef int I; };
1697 In this case, we will have "A::I" as the DECL, but "I" as the
1699 && CLASS_TYPE_P (object_type
)
1700 && DERIVED_FROM_P (scope
, object_type
))
1701 /* If we are processing a `->' or `.' expression, use the type of the
1703 qualifying_type
= object_type
;
1704 else if (nested_name_specifier
)
1706 /* If the reference is to a non-static member of the
1707 current class, treat it as if it were referenced through
1709 if (DECL_NONSTATIC_MEMBER_P (decl
)
1710 && current_class_ptr
1711 && DERIVED_FROM_P (scope
, current_class_type
))
1712 qualifying_type
= current_class_type
;
1713 /* Otherwise, use the type indicated by the
1714 nested-name-specifier. */
1716 qualifying_type
= nested_name_specifier
;
1719 /* Otherwise, the name must be from the current class or one of
1721 qualifying_type
= currently_open_derived_class (scope
);
1724 /* It is possible for qualifying type to be a TEMPLATE_TYPE_PARM
1725 or similar in a default argument value. */
1726 && CLASS_TYPE_P (qualifying_type
)
1727 && !dependent_type_p (qualifying_type
))
1728 perform_or_defer_access_check (TYPE_BINFO (qualifying_type
), decl
,
1732 /* EXPR is the result of a qualified-id. The QUALIFYING_CLASS was the
1733 class named to the left of the "::" operator. DONE is true if this
1734 expression is a complete postfix-expression; it is false if this
1735 expression is followed by '->', '[', '(', etc. ADDRESS_P is true
1736 iff this expression is the operand of '&'. TEMPLATE_P is true iff
1737 the qualified-id was of the form "A::template B". TEMPLATE_ARG_P
1738 is true iff this qualified name appears as a template argument. */
1741 finish_qualified_id_expr (tree qualifying_class
,
1746 bool template_arg_p
)
1748 gcc_assert (TYPE_P (qualifying_class
));
1750 if (error_operand_p (expr
))
1751 return error_mark_node
;
1753 if (DECL_P (expr
) || BASELINK_P (expr
))
1757 check_template_keyword (expr
);
1759 /* If EXPR occurs as the operand of '&', use special handling that
1760 permits a pointer-to-member. */
1761 if (address_p
&& done
)
1763 if (TREE_CODE (expr
) == SCOPE_REF
)
1764 expr
= TREE_OPERAND (expr
, 1);
1765 expr
= build_offset_ref (qualifying_class
, expr
,
1766 /*address_p=*/true);
1770 /* Within the scope of a class, turn references to non-static
1771 members into expression of the form "this->...". */
1773 /* But, within a template argument, we do not want make the
1774 transformation, as there is no "this" pointer. */
1776 else if (TREE_CODE (expr
) == FIELD_DECL
)
1778 push_deferring_access_checks (dk_no_check
);
1779 expr
= finish_non_static_data_member (expr
, NULL_TREE
,
1781 pop_deferring_access_checks ();
1783 else if (BASELINK_P (expr
) && !processing_template_decl
)
1787 /* See if any of the functions are non-static members. */
1788 /* If so, the expression may be relative to 'this'. */
1789 if (!shared_member_p (expr
)
1790 && (ob
= maybe_dummy_object (qualifying_class
, NULL
),
1791 !is_dummy_object (ob
)))
1792 expr
= (build_class_member_access_expr
1795 BASELINK_ACCESS_BINFO (expr
),
1796 /*preserve_reference=*/false,
1797 tf_warning_or_error
));
1799 /* The expression is a qualified name whose address is not
1801 expr
= build_offset_ref (qualifying_class
, expr
, /*address_p=*/false);
1807 /* Begin a statement-expression. The value returned must be passed to
1808 finish_stmt_expr. */
1811 begin_stmt_expr (void)
1813 return push_stmt_list ();
1816 /* Process the final expression of a statement expression. EXPR can be
1817 NULL, if the final expression is empty. Return a STATEMENT_LIST
1818 containing all the statements in the statement-expression, or
1819 ERROR_MARK_NODE if there was an error. */
1822 finish_stmt_expr_expr (tree expr
, tree stmt_expr
)
1824 if (error_operand_p (expr
))
1826 /* The type of the statement-expression is the type of the last
1828 TREE_TYPE (stmt_expr
) = error_mark_node
;
1829 return error_mark_node
;
1832 /* If the last statement does not have "void" type, then the value
1833 of the last statement is the value of the entire expression. */
1836 tree type
= TREE_TYPE (expr
);
1838 if (processing_template_decl
)
1840 expr
= build_stmt (input_location
, EXPR_STMT
, expr
);
1841 expr
= add_stmt (expr
);
1842 /* Mark the last statement so that we can recognize it as such at
1843 template-instantiation time. */
1844 EXPR_STMT_STMT_EXPR_RESULT (expr
) = 1;
1846 else if (VOID_TYPE_P (type
))
1848 /* Just treat this like an ordinary statement. */
1849 expr
= finish_expr_stmt (expr
);
1853 /* It actually has a value we need to deal with. First, force it
1854 to be an rvalue so that we won't need to build up a copy
1855 constructor call later when we try to assign it to something. */
1856 expr
= force_rvalue (expr
, tf_warning_or_error
);
1857 if (error_operand_p (expr
))
1858 return error_mark_node
;
1860 /* Update for array-to-pointer decay. */
1861 type
= TREE_TYPE (expr
);
1863 /* Wrap it in a CLEANUP_POINT_EXPR and add it to the list like a
1864 normal statement, but don't convert to void or actually add
1866 if (TREE_CODE (expr
) != CLEANUP_POINT_EXPR
)
1867 expr
= maybe_cleanup_point_expr (expr
);
1871 /* The type of the statement-expression is the type of the last
1873 TREE_TYPE (stmt_expr
) = type
;
1879 /* Finish a statement-expression. EXPR should be the value returned
1880 by the previous begin_stmt_expr. Returns an expression
1881 representing the statement-expression. */
1884 finish_stmt_expr (tree stmt_expr
, bool has_no_scope
)
1889 if (error_operand_p (stmt_expr
))
1891 pop_stmt_list (stmt_expr
);
1892 return error_mark_node
;
1895 gcc_assert (TREE_CODE (stmt_expr
) == STATEMENT_LIST
);
1897 type
= TREE_TYPE (stmt_expr
);
1898 result
= pop_stmt_list (stmt_expr
);
1899 TREE_TYPE (result
) = type
;
1901 if (processing_template_decl
)
1903 result
= build_min (STMT_EXPR
, type
, result
);
1904 TREE_SIDE_EFFECTS (result
) = 1;
1905 STMT_EXPR_NO_SCOPE (result
) = has_no_scope
;
1907 else if (CLASS_TYPE_P (type
))
1909 /* Wrap the statement-expression in a TARGET_EXPR so that the
1910 temporary object created by the final expression is destroyed at
1911 the end of the full-expression containing the
1912 statement-expression. */
1913 result
= force_target_expr (type
, result
, tf_warning_or_error
);
1919 /* Returns the expression which provides the value of STMT_EXPR. */
1922 stmt_expr_value_expr (tree stmt_expr
)
1924 tree t
= STMT_EXPR_STMT (stmt_expr
);
1926 if (TREE_CODE (t
) == BIND_EXPR
)
1927 t
= BIND_EXPR_BODY (t
);
1929 if (TREE_CODE (t
) == STATEMENT_LIST
&& STATEMENT_LIST_TAIL (t
))
1930 t
= STATEMENT_LIST_TAIL (t
)->stmt
;
1932 if (TREE_CODE (t
) == EXPR_STMT
)
1933 t
= EXPR_STMT_EXPR (t
);
1938 /* Return TRUE iff EXPR_STMT is an empty list of
1939 expression statements. */
1942 empty_expr_stmt_p (tree expr_stmt
)
1944 tree body
= NULL_TREE
;
1946 if (expr_stmt
== void_zero_node
)
1951 if (TREE_CODE (expr_stmt
) == EXPR_STMT
)
1952 body
= EXPR_STMT_EXPR (expr_stmt
);
1953 else if (TREE_CODE (expr_stmt
) == STATEMENT_LIST
)
1959 if (TREE_CODE (body
) == STATEMENT_LIST
)
1960 return tsi_end_p (tsi_start (body
));
1962 return empty_expr_stmt_p (body
);
1967 /* Perform Koenig lookup. FN is the postfix-expression representing
1968 the function (or functions) to call; ARGS are the arguments to the
1969 call; if INCLUDE_STD then the `std' namespace is automatically
1970 considered an associated namespace (used in range-based for loops).
1971 Returns the functions to be considered by overload resolution. */
1974 perform_koenig_lookup (tree fn
, VEC(tree
,gc
) *args
, bool include_std
,
1975 tsubst_flags_t complain
)
1977 tree identifier
= NULL_TREE
;
1978 tree functions
= NULL_TREE
;
1979 tree tmpl_args
= NULL_TREE
;
1980 bool template_id
= false;
1982 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
1984 /* Use a separate flag to handle null args. */
1986 tmpl_args
= TREE_OPERAND (fn
, 1);
1987 fn
= TREE_OPERAND (fn
, 0);
1990 /* Find the name of the overloaded function. */
1991 if (TREE_CODE (fn
) == IDENTIFIER_NODE
)
1993 else if (is_overloaded_fn (fn
))
1996 identifier
= DECL_NAME (get_first_fn (functions
));
1998 else if (DECL_P (fn
))
2001 identifier
= DECL_NAME (fn
);
2004 /* A call to a namespace-scope function using an unqualified name.
2006 Do Koenig lookup -- unless any of the arguments are
2008 if (!any_type_dependent_arguments_p (args
)
2009 && !any_dependent_template_arguments_p (tmpl_args
))
2011 fn
= lookup_arg_dependent (identifier
, functions
, args
, include_std
);
2014 /* The unqualified name could not be resolved. */
2016 fn
= unqualified_fn_lookup_error (identifier
);
2022 if (fn
&& template_id
)
2023 fn
= build2 (TEMPLATE_ID_EXPR
, unknown_type_node
, fn
, tmpl_args
);
2028 /* Generate an expression for `FN (ARGS)'. This may change the
2031 If DISALLOW_VIRTUAL is true, the call to FN will be not generated
2032 as a virtual call, even if FN is virtual. (This flag is set when
2033 encountering an expression where the function name is explicitly
2034 qualified. For example a call to `X::f' never generates a virtual
2037 Returns code for the call. */
2040 finish_call_expr (tree fn
, VEC(tree
,gc
) **args
, bool disallow_virtual
,
2041 bool koenig_p
, tsubst_flags_t complain
)
2045 VEC(tree
,gc
) *orig_args
= NULL
;
2047 if (fn
== error_mark_node
)
2048 return error_mark_node
;
2050 gcc_assert (!TYPE_P (fn
));
2054 if (processing_template_decl
)
2056 /* If the call expression is dependent, build a CALL_EXPR node
2057 with no type; type_dependent_expression_p recognizes
2058 expressions with no type as being dependent. */
2059 if (type_dependent_expression_p (fn
)
2060 || any_type_dependent_arguments_p (*args
)
2061 /* For a non-static member function that doesn't have an
2062 explicit object argument, we need to specifically
2063 test the type dependency of the "this" pointer because it
2064 is not included in *ARGS even though it is considered to
2065 be part of the list of arguments. Note that this is
2066 related to CWG issues 515 and 1005. */
2067 || (TREE_CODE (fn
) != COMPONENT_REF
2068 && non_static_member_function_p (fn
)
2069 && current_class_ref
2070 && type_dependent_expression_p (current_class_ref
)))
2072 result
= build_nt_call_vec (fn
, *args
);
2073 KOENIG_LOOKUP_P (result
) = koenig_p
;
2078 tree fndecl
= OVL_CURRENT (fn
);
2079 if (TREE_CODE (fndecl
) != FUNCTION_DECL
2080 || !TREE_THIS_VOLATILE (fndecl
))
2086 current_function_returns_abnormally
= 1;
2090 orig_args
= make_tree_vector_copy (*args
);
2091 if (!BASELINK_P (fn
)
2092 && TREE_CODE (fn
) != PSEUDO_DTOR_EXPR
2093 && TREE_TYPE (fn
) != unknown_type_node
)
2094 fn
= build_non_dependent_expr (fn
);
2095 make_args_non_dependent (*args
);
2098 if (TREE_CODE (fn
) == COMPONENT_REF
)
2100 tree member
= TREE_OPERAND (fn
, 1);
2101 if (BASELINK_P (member
))
2103 tree object
= TREE_OPERAND (fn
, 0);
2104 return build_new_method_call (object
, member
,
2107 ? LOOKUP_NORMAL
| LOOKUP_NONVIRTUAL
2114 if (is_overloaded_fn (fn
))
2115 fn
= baselink_for_fns (fn
);
2118 if (BASELINK_P (fn
))
2122 /* A call to a member function. From [over.call.func]:
2124 If the keyword this is in scope and refers to the class of
2125 that member function, or a derived class thereof, then the
2126 function call is transformed into a qualified function call
2127 using (*this) as the postfix-expression to the left of the
2128 . operator.... [Otherwise] a contrived object of type T
2129 becomes the implied object argument.
2133 struct A { void f(); };
2134 struct B : public A {};
2135 struct C : public A { void g() { B::f(); }};
2137 "the class of that member function" refers to `A'. But 11.2
2138 [class.access.base] says that we need to convert 'this' to B* as
2139 part of the access, so we pass 'B' to maybe_dummy_object. */
2141 object
= maybe_dummy_object (BINFO_TYPE (BASELINK_ACCESS_BINFO (fn
)),
2144 if (processing_template_decl
)
2146 if (type_dependent_expression_p (object
))
2148 tree ret
= build_nt_call_vec (orig_fn
, orig_args
);
2149 release_tree_vector (orig_args
);
2152 object
= build_non_dependent_expr (object
);
2155 result
= build_new_method_call (object
, fn
, args
, NULL_TREE
,
2157 ? LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
2162 else if (is_overloaded_fn (fn
))
2164 /* If the function is an overloaded builtin, resolve it. */
2165 if (TREE_CODE (fn
) == FUNCTION_DECL
2166 && (DECL_BUILT_IN_CLASS (fn
) == BUILT_IN_NORMAL
2167 || DECL_BUILT_IN_CLASS (fn
) == BUILT_IN_MD
))
2168 result
= resolve_overloaded_builtin (input_location
, fn
, *args
);
2171 /* A call to a namespace-scope function. */
2172 result
= build_new_function_call (fn
, args
, koenig_p
, complain
);
2174 else if (TREE_CODE (fn
) == PSEUDO_DTOR_EXPR
)
2176 if (!VEC_empty (tree
, *args
))
2177 error ("arguments to destructor are not allowed");
2178 /* Mark the pseudo-destructor call as having side-effects so
2179 that we do not issue warnings about its use. */
2180 result
= build1 (NOP_EXPR
,
2182 TREE_OPERAND (fn
, 0));
2183 TREE_SIDE_EFFECTS (result
) = 1;
2185 else if (CLASS_TYPE_P (TREE_TYPE (fn
)))
2186 /* If the "function" is really an object of class type, it might
2187 have an overloaded `operator ()'. */
2188 result
= build_op_call (fn
, args
, complain
);
2191 /* A call where the function is unknown. */
2192 result
= cp_build_function_call_vec (fn
, args
, complain
);
2194 if (processing_template_decl
&& result
!= error_mark_node
)
2196 if (TREE_CODE (result
) == INDIRECT_REF
)
2197 result
= TREE_OPERAND (result
, 0);
2198 result
= build_call_vec (TREE_TYPE (result
), orig_fn
, orig_args
);
2199 SET_EXPR_LOCATION (result
, input_location
);
2200 KOENIG_LOOKUP_P (result
) = koenig_p
;
2201 release_tree_vector (orig_args
);
2202 result
= convert_from_reference (result
);
2207 /* Free garbage OVERLOADs from arg-dependent lookup. */
2208 tree next
= NULL_TREE
;
2210 fn
&& TREE_CODE (fn
) == OVERLOAD
&& OVL_ARG_DEPENDENT (fn
);
2213 if (processing_template_decl
)
2214 /* In a template, we'll re-use them at instantiation time. */
2215 OVL_ARG_DEPENDENT (fn
) = false;
2218 next
= OVL_CHAIN (fn
);
2227 /* Finish a call to a postfix increment or decrement or EXPR. (Which
2228 is indicated by CODE, which should be POSTINCREMENT_EXPR or
2229 POSTDECREMENT_EXPR.) */
2232 finish_increment_expr (tree expr
, enum tree_code code
)
2234 return build_x_unary_op (input_location
, code
, expr
, tf_warning_or_error
);
2237 /* Finish a use of `this'. Returns an expression for `this'. */
2240 finish_this_expr (void)
2244 if (current_class_ptr
)
2246 tree type
= TREE_TYPE (current_class_ref
);
2248 /* In a lambda expression, 'this' refers to the captured 'this'. */
2249 if (LAMBDA_TYPE_P (type
))
2250 result
= lambda_expr_this_capture (CLASSTYPE_LAMBDA_EXPR (type
));
2252 result
= current_class_ptr
;
2255 else if (current_function_decl
2256 && DECL_STATIC_FUNCTION_P (current_function_decl
))
2258 error ("%<this%> is unavailable for static member functions");
2259 result
= error_mark_node
;
2263 if (current_function_decl
)
2264 error ("invalid use of %<this%> in non-member function");
2266 error ("invalid use of %<this%> at top level");
2267 result
= error_mark_node
;
2273 /* Finish a pseudo-destructor expression. If SCOPE is NULL, the
2274 expression was of the form `OBJECT.~DESTRUCTOR' where DESTRUCTOR is
2275 the TYPE for the type given. If SCOPE is non-NULL, the expression
2276 was of the form `OBJECT.SCOPE::~DESTRUCTOR'. */
2279 finish_pseudo_destructor_expr (tree object
, tree scope
, tree destructor
)
2281 if (object
== error_mark_node
|| destructor
== error_mark_node
)
2282 return error_mark_node
;
2284 gcc_assert (TYPE_P (destructor
));
2286 if (!processing_template_decl
)
2288 if (scope
== error_mark_node
)
2290 error ("invalid qualifying scope in pseudo-destructor name");
2291 return error_mark_node
;
2293 if (scope
&& TYPE_P (scope
) && !check_dtor_name (scope
, destructor
))
2295 error ("qualified type %qT does not match destructor name ~%qT",
2297 return error_mark_node
;
2301 /* [expr.pseudo] says both:
2303 The type designated by the pseudo-destructor-name shall be
2304 the same as the object type.
2308 The cv-unqualified versions of the object type and of the
2309 type designated by the pseudo-destructor-name shall be the
2312 We implement the more generous second sentence, since that is
2313 what most other compilers do. */
2314 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (object
),
2317 error ("%qE is not of type %qT", object
, destructor
);
2318 return error_mark_node
;
2322 return build3 (PSEUDO_DTOR_EXPR
, void_type_node
, object
, scope
, destructor
);
2325 /* Finish an expression of the form CODE EXPR. */
2328 finish_unary_op_expr (location_t loc
, enum tree_code code
, tree expr
)
2330 tree result
= build_x_unary_op (loc
, code
, expr
, tf_warning_or_error
);
2331 if (TREE_OVERFLOW_P (result
) && !TREE_OVERFLOW_P (expr
))
2332 overflow_warning (input_location
, result
);
2337 /* Finish a compound-literal expression. TYPE is the type to which
2338 the CONSTRUCTOR in COMPOUND_LITERAL is being cast. */
2341 finish_compound_literal (tree type
, tree compound_literal
,
2342 tsubst_flags_t complain
)
2344 if (type
== error_mark_node
)
2345 return error_mark_node
;
2347 if (TREE_CODE (type
) == REFERENCE_TYPE
)
2350 = finish_compound_literal (TREE_TYPE (type
), compound_literal
,
2352 return cp_build_c_cast (type
, compound_literal
, complain
);
2355 if (!TYPE_OBJ_P (type
))
2357 if (complain
& tf_error
)
2358 error ("compound literal of non-object type %qT", type
);
2359 return error_mark_node
;
2362 if (processing_template_decl
)
2364 TREE_TYPE (compound_literal
) = type
;
2365 /* Mark the expression as a compound literal. */
2366 TREE_HAS_CONSTRUCTOR (compound_literal
) = 1;
2367 return compound_literal
;
2370 type
= complete_type (type
);
2372 if (TYPE_NON_AGGREGATE_CLASS (type
))
2374 /* Trying to deal with a CONSTRUCTOR instead of a TREE_LIST
2375 everywhere that deals with function arguments would be a pain, so
2376 just wrap it in a TREE_LIST. The parser set a flag so we know
2377 that it came from T{} rather than T({}). */
2378 CONSTRUCTOR_IS_DIRECT_INIT (compound_literal
) = 1;
2379 compound_literal
= build_tree_list (NULL_TREE
, compound_literal
);
2380 return build_functional_cast (type
, compound_literal
, complain
);
2383 if (TREE_CODE (type
) == ARRAY_TYPE
2384 && check_array_initializer (NULL_TREE
, type
, compound_literal
))
2385 return error_mark_node
;
2386 compound_literal
= reshape_init (type
, compound_literal
, complain
);
2387 if (SCALAR_TYPE_P (type
)
2388 && !BRACE_ENCLOSED_INITIALIZER_P (compound_literal
)
2389 && (complain
& tf_warning_or_error
))
2390 check_narrowing (type
, compound_literal
);
2391 if (TREE_CODE (type
) == ARRAY_TYPE
2392 && TYPE_DOMAIN (type
) == NULL_TREE
)
2394 cp_complete_array_type_or_error (&type
, compound_literal
,
2396 if (type
== error_mark_node
)
2397 return error_mark_node
;
2399 compound_literal
= digest_init (type
, compound_literal
, complain
);
2400 if (TREE_CODE (compound_literal
) == CONSTRUCTOR
)
2401 TREE_HAS_CONSTRUCTOR (compound_literal
) = true;
2402 /* Put static/constant array temporaries in static variables, but always
2403 represent class temporaries with TARGET_EXPR so we elide copies. */
2404 if ((!at_function_scope_p () || CP_TYPE_CONST_P (type
))
2405 && TREE_CODE (type
) == ARRAY_TYPE
2406 && !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
2407 && initializer_constant_valid_p (compound_literal
, type
))
2409 tree decl
= create_temporary_var (type
);
2410 DECL_INITIAL (decl
) = compound_literal
;
2411 TREE_STATIC (decl
) = 1;
2412 if (literal_type_p (type
) && CP_TYPE_CONST_NON_VOLATILE_P (type
))
2414 /* 5.19 says that a constant expression can include an
2415 lvalue-rvalue conversion applied to "a glvalue of literal type
2416 that refers to a non-volatile temporary object initialized
2417 with a constant expression". Rather than try to communicate
2418 that this VAR_DECL is a temporary, just mark it constexpr. */
2419 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
2420 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = true;
2421 TREE_CONSTANT (decl
) = true;
2423 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
2424 decl
= pushdecl_top_level (decl
);
2425 DECL_NAME (decl
) = make_anon_name ();
2426 SET_DECL_ASSEMBLER_NAME (decl
, DECL_NAME (decl
));
2430 return get_target_expr_sfinae (compound_literal
, complain
);
2433 /* Return the declaration for the function-name variable indicated by
2437 finish_fname (tree id
)
2441 decl
= fname_decl (input_location
, C_RID_CODE (id
), id
);
2442 if (processing_template_decl
&& current_function_decl
)
2443 decl
= DECL_NAME (decl
);
2447 /* Finish a translation unit. */
2450 finish_translation_unit (void)
2452 /* In case there were missing closebraces,
2453 get us back to the global binding level. */
2455 while (current_namespace
!= global_namespace
)
2458 /* Do file scope __FUNCTION__ et al. */
2459 finish_fname_decls ();
2462 /* Finish a template type parameter, specified as AGGR IDENTIFIER.
2463 Returns the parameter. */
2466 finish_template_type_parm (tree aggr
, tree identifier
)
2468 if (aggr
!= class_type_node
)
2470 permerror (input_location
, "template type parameters must use the keyword %<class%> or %<typename%>");
2471 aggr
= class_type_node
;
2474 return build_tree_list (aggr
, identifier
);
2477 /* Finish a template template parameter, specified as AGGR IDENTIFIER.
2478 Returns the parameter. */
2481 finish_template_template_parm (tree aggr
, tree identifier
)
2483 tree decl
= build_decl (input_location
,
2484 TYPE_DECL
, identifier
, NULL_TREE
);
2485 tree tmpl
= build_lang_decl (TEMPLATE_DECL
, identifier
, NULL_TREE
);
2486 DECL_TEMPLATE_PARMS (tmpl
) = current_template_parms
;
2487 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
2488 DECL_ARTIFICIAL (decl
) = 1;
2489 end_template_decl ();
2491 gcc_assert (DECL_TEMPLATE_PARMS (tmpl
));
2493 check_default_tmpl_args (decl
, DECL_TEMPLATE_PARMS (tmpl
),
2494 /*is_primary=*/true, /*is_partial=*/false,
2497 return finish_template_type_parm (aggr
, tmpl
);
2500 /* ARGUMENT is the default-argument value for a template template
2501 parameter. If ARGUMENT is invalid, issue error messages and return
2502 the ERROR_MARK_NODE. Otherwise, ARGUMENT itself is returned. */
2505 check_template_template_default_arg (tree argument
)
2507 if (TREE_CODE (argument
) != TEMPLATE_DECL
2508 && TREE_CODE (argument
) != TEMPLATE_TEMPLATE_PARM
2509 && TREE_CODE (argument
) != UNBOUND_CLASS_TEMPLATE
)
2511 if (TREE_CODE (argument
) == TYPE_DECL
)
2512 error ("invalid use of type %qT as a default value for a template "
2513 "template-parameter", TREE_TYPE (argument
));
2515 error ("invalid default argument for a template template parameter");
2516 return error_mark_node
;
2522 /* Begin a class definition, as indicated by T. */
2525 begin_class_definition (tree t
)
2527 if (error_operand_p (t
) || error_operand_p (TYPE_MAIN_DECL (t
)))
2528 return error_mark_node
;
2530 if (processing_template_parmlist
)
2532 error ("definition of %q#T inside template parameter list", t
);
2533 return error_mark_node
;
2536 /* According to the C++ ABI, decimal classes defined in ISO/IEC TR 24733
2537 are passed the same as decimal scalar types. */
2538 if (TREE_CODE (t
) == RECORD_TYPE
2539 && !processing_template_decl
)
2541 tree ns
= TYPE_CONTEXT (t
);
2542 if (ns
&& TREE_CODE (ns
) == NAMESPACE_DECL
2543 && DECL_CONTEXT (ns
) == std_node
2545 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (ns
)), "decimal"))
2547 const char *n
= TYPE_NAME_STRING (t
);
2548 if ((strcmp (n
, "decimal32") == 0)
2549 || (strcmp (n
, "decimal64") == 0)
2550 || (strcmp (n
, "decimal128") == 0))
2551 TYPE_TRANSPARENT_AGGR (t
) = 1;
2555 /* A non-implicit typename comes from code like:
2557 template <typename T> struct A {
2558 template <typename U> struct A<T>::B ...
2560 This is erroneous. */
2561 else if (TREE_CODE (t
) == TYPENAME_TYPE
)
2563 error ("invalid definition of qualified type %qT", t
);
2564 t
= error_mark_node
;
2567 if (t
== error_mark_node
|| ! MAYBE_CLASS_TYPE_P (t
))
2569 t
= make_class_type (RECORD_TYPE
);
2570 pushtag (make_anon_name (), t
, /*tag_scope=*/ts_current
);
2573 if (TYPE_BEING_DEFINED (t
))
2575 t
= make_class_type (TREE_CODE (t
));
2576 pushtag (TYPE_IDENTIFIER (t
), t
, /*tag_scope=*/ts_current
);
2578 maybe_process_partial_specialization (t
);
2580 TYPE_BEING_DEFINED (t
) = 1;
2582 if (flag_pack_struct
)
2585 TYPE_PACKED (t
) = 1;
2586 /* Even though the type is being defined for the first time
2587 here, there might have been a forward declaration, so there
2588 might be cv-qualified variants of T. */
2589 for (v
= TYPE_NEXT_VARIANT (t
); v
; v
= TYPE_NEXT_VARIANT (v
))
2590 TYPE_PACKED (v
) = 1;
2592 /* Reset the interface data, at the earliest possible
2593 moment, as it might have been set via a class foo;
2595 if (! TYPE_ANONYMOUS_P (t
))
2597 struct c_fileinfo
*finfo
= get_fileinfo (input_filename
);
2598 CLASSTYPE_INTERFACE_ONLY (t
) = finfo
->interface_only
;
2599 SET_CLASSTYPE_INTERFACE_UNKNOWN_X
2600 (t
, finfo
->interface_unknown
);
2602 reset_specialization();
2604 /* Make a declaration for this class in its own scope. */
2605 build_self_reference ();
2610 /* Finish the member declaration given by DECL. */
2613 finish_member_declaration (tree decl
)
2615 if (decl
== error_mark_node
|| decl
== NULL_TREE
)
2618 if (decl
== void_type_node
)
2619 /* The COMPONENT was a friend, not a member, and so there's
2620 nothing for us to do. */
2623 /* We should see only one DECL at a time. */
2624 gcc_assert (DECL_CHAIN (decl
) == NULL_TREE
);
2626 /* Set up access control for DECL. */
2628 = (current_access_specifier
== access_private_node
);
2629 TREE_PROTECTED (decl
)
2630 = (current_access_specifier
== access_protected_node
);
2631 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
2633 TREE_PRIVATE (DECL_TEMPLATE_RESULT (decl
)) = TREE_PRIVATE (decl
);
2634 TREE_PROTECTED (DECL_TEMPLATE_RESULT (decl
)) = TREE_PROTECTED (decl
);
2637 /* Mark the DECL as a member of the current class, unless it's
2638 a member of an enumeration. */
2639 if (TREE_CODE (decl
) != CONST_DECL
)
2640 DECL_CONTEXT (decl
) = current_class_type
;
2642 /* Check for bare parameter packs in the member variable declaration. */
2643 if (TREE_CODE (decl
) == FIELD_DECL
)
2645 if (check_for_bare_parameter_packs (TREE_TYPE (decl
)))
2646 TREE_TYPE (decl
) = error_mark_node
;
2647 if (check_for_bare_parameter_packs (DECL_ATTRIBUTES (decl
)))
2648 DECL_ATTRIBUTES (decl
) = NULL_TREE
;
2653 A C language linkage is ignored for the names of class members
2654 and the member function type of class member functions. */
2655 if (DECL_LANG_SPECIFIC (decl
) && DECL_LANGUAGE (decl
) == lang_c
)
2656 SET_DECL_LANGUAGE (decl
, lang_cplusplus
);
2658 /* Put functions on the TYPE_METHODS list and everything else on the
2659 TYPE_FIELDS list. Note that these are built up in reverse order.
2660 We reverse them (to obtain declaration order) in finish_struct. */
2661 if (TREE_CODE (decl
) == FUNCTION_DECL
2662 || DECL_FUNCTION_TEMPLATE_P (decl
))
2664 /* We also need to add this function to the
2665 CLASSTYPE_METHOD_VEC. */
2666 if (add_method (current_class_type
, decl
, NULL_TREE
))
2668 DECL_CHAIN (decl
) = TYPE_METHODS (current_class_type
);
2669 TYPE_METHODS (current_class_type
) = decl
;
2671 maybe_add_class_template_decl_list (current_class_type
, decl
,
2675 /* Enter the DECL into the scope of the class. */
2676 else if (pushdecl_class_level (decl
))
2678 if (TREE_CODE (decl
) == USING_DECL
)
2680 /* For now, ignore class-scope USING_DECLS, so that
2681 debugging backends do not see them. */
2682 DECL_IGNORED_P (decl
) = 1;
2685 /* All TYPE_DECLs go at the end of TYPE_FIELDS. Ordinary fields
2686 go at the beginning. The reason is that lookup_field_1
2687 searches the list in order, and we want a field name to
2688 override a type name so that the "struct stat hack" will
2689 work. In particular:
2691 struct S { enum E { }; int E } s;
2694 is valid. In addition, the FIELD_DECLs must be maintained in
2695 declaration order so that class layout works as expected.
2696 However, we don't need that order until class layout, so we
2697 save a little time by putting FIELD_DECLs on in reverse order
2698 here, and then reversing them in finish_struct_1. (We could
2699 also keep a pointer to the correct insertion points in the
2702 if (TREE_CODE (decl
) == TYPE_DECL
)
2703 TYPE_FIELDS (current_class_type
)
2704 = chainon (TYPE_FIELDS (current_class_type
), decl
);
2707 DECL_CHAIN (decl
) = TYPE_FIELDS (current_class_type
);
2708 TYPE_FIELDS (current_class_type
) = decl
;
2711 maybe_add_class_template_decl_list (current_class_type
, decl
,
2716 note_decl_for_pch (decl
);
2719 /* DECL has been declared while we are building a PCH file. Perform
2720 actions that we might normally undertake lazily, but which can be
2721 performed now so that they do not have to be performed in
2722 translation units which include the PCH file. */
2725 note_decl_for_pch (tree decl
)
2727 gcc_assert (pch_file
);
2729 /* There's a good chance that we'll have to mangle names at some
2730 point, even if only for emission in debugging information. */
2731 if ((TREE_CODE (decl
) == VAR_DECL
2732 || TREE_CODE (decl
) == FUNCTION_DECL
)
2733 && !processing_template_decl
)
2737 /* Finish processing a complete template declaration. The PARMS are
2738 the template parameters. */
2741 finish_template_decl (tree parms
)
2744 end_template_decl ();
2746 end_specialization ();
2749 /* Finish processing a template-id (which names a type) of the form
2750 NAME < ARGS >. Return the TYPE_DECL for the type named by the
2751 template-id. If ENTERING_SCOPE is nonzero we are about to enter
2752 the scope of template-id indicated. */
2755 finish_template_type (tree name
, tree args
, int entering_scope
)
2759 type
= lookup_template_class (name
, args
,
2760 NULL_TREE
, NULL_TREE
, entering_scope
,
2761 tf_warning_or_error
| tf_user
);
2762 if (type
== error_mark_node
)
2764 else if (CLASS_TYPE_P (type
) && !alias_type_or_template_p (type
))
2765 return TYPE_STUB_DECL (type
);
2767 return TYPE_NAME (type
);
2770 /* Finish processing a BASE_CLASS with the indicated ACCESS_SPECIFIER.
2771 Return a TREE_LIST containing the ACCESS_SPECIFIER and the
2772 BASE_CLASS, or NULL_TREE if an error occurred. The
2773 ACCESS_SPECIFIER is one of
2774 access_{default,public,protected_private}_node. For a virtual base
2775 we set TREE_TYPE. */
2778 finish_base_specifier (tree base
, tree access
, bool virtual_p
)
2782 if (base
== error_mark_node
)
2784 error ("invalid base-class specification");
2787 else if (! MAYBE_CLASS_TYPE_P (base
))
2789 error ("%qT is not a class type", base
);
2794 if (cp_type_quals (base
) != 0)
2796 /* DR 484: Can a base-specifier name a cv-qualified
2798 base
= TYPE_MAIN_VARIANT (base
);
2800 result
= build_tree_list (access
, base
);
2802 TREE_TYPE (result
) = integer_type_node
;
2808 /* If FNS is a member function, a set of member functions, or a
2809 template-id referring to one or more member functions, return a
2810 BASELINK for FNS, incorporating the current access context.
2811 Otherwise, return FNS unchanged. */
2814 baselink_for_fns (tree fns
)
2819 if (BASELINK_P (fns
)
2820 || error_operand_p (fns
))
2823 scope
= ovl_scope (fns
);
2824 if (!CLASS_TYPE_P (scope
))
2827 cl
= currently_open_derived_class (scope
);
2830 cl
= TYPE_BINFO (cl
);
2831 return build_baselink (cl
, cl
, fns
, /*optype=*/NULL_TREE
);
2834 /* Returns true iff DECL is an automatic variable from a function outside
2838 outer_automatic_var_p (tree decl
)
2840 return ((TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == PARM_DECL
)
2841 && DECL_FUNCTION_SCOPE_P (decl
)
2842 && !TREE_STATIC (decl
)
2843 && DECL_CONTEXT (decl
) != current_function_decl
);
2846 /* ID_EXPRESSION is a representation of parsed, but unprocessed,
2847 id-expression. (See cp_parser_id_expression for details.) SCOPE,
2848 if non-NULL, is the type or namespace used to explicitly qualify
2849 ID_EXPRESSION. DECL is the entity to which that name has been
2852 *CONSTANT_EXPRESSION_P is true if we are presently parsing a
2853 constant-expression. In that case, *NON_CONSTANT_EXPRESSION_P will
2854 be set to true if this expression isn't permitted in a
2855 constant-expression, but it is otherwise not set by this function.
2856 *ALLOW_NON_CONSTANT_EXPRESSION_P is true if we are parsing a
2857 constant-expression, but a non-constant expression is also
2860 DONE is true if this expression is a complete postfix-expression;
2861 it is false if this expression is followed by '->', '[', '(', etc.
2862 ADDRESS_P is true iff this expression is the operand of '&'.
2863 TEMPLATE_P is true iff the qualified-id was of the form
2864 "A::template B". TEMPLATE_ARG_P is true iff this qualified name
2865 appears as a template argument.
2867 If an error occurs, and it is the kind of error that might cause
2868 the parser to abort a tentative parse, *ERROR_MSG is filled in. It
2869 is the caller's responsibility to issue the message. *ERROR_MSG
2870 will be a string with static storage duration, so the caller need
2873 Return an expression for the entity, after issuing appropriate
2874 diagnostics. This function is also responsible for transforming a
2875 reference to a non-static member into a COMPONENT_REF that makes
2876 the use of "this" explicit.
2878 Upon return, *IDK will be filled in appropriately. */
2880 finish_id_expression (tree id_expression
,
2884 bool integral_constant_expression_p
,
2885 bool allow_non_integral_constant_expression_p
,
2886 bool *non_integral_constant_expression_p
,
2890 bool template_arg_p
,
2891 const char **error_msg
,
2892 location_t location
)
2894 decl
= strip_using_decl (decl
);
2896 /* Initialize the output parameters. */
2897 *idk
= CP_ID_KIND_NONE
;
2900 if (id_expression
== error_mark_node
)
2901 return error_mark_node
;
2902 /* If we have a template-id, then no further lookup is
2903 required. If the template-id was for a template-class, we
2904 will sometimes have a TYPE_DECL at this point. */
2905 else if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
2906 || TREE_CODE (decl
) == TYPE_DECL
)
2908 /* Look up the name. */
2911 if (decl
== error_mark_node
)
2913 /* Name lookup failed. */
2916 || (!dependent_type_p (scope
)
2917 && !(TREE_CODE (id_expression
) == IDENTIFIER_NODE
2918 && IDENTIFIER_TYPENAME_P (id_expression
)
2919 && dependent_type_p (TREE_TYPE (id_expression
))))))
2921 /* If the qualifying type is non-dependent (and the name
2922 does not name a conversion operator to a dependent
2923 type), issue an error. */
2924 qualified_name_lookup_error (scope
, id_expression
, decl
, location
);
2925 return error_mark_node
;
2929 /* It may be resolved via Koenig lookup. */
2930 *idk
= CP_ID_KIND_UNQUALIFIED
;
2931 return id_expression
;
2934 decl
= id_expression
;
2936 /* If DECL is a variable that would be out of scope under
2937 ANSI/ISO rules, but in scope in the ARM, name lookup
2938 will succeed. Issue a diagnostic here. */
2940 decl
= check_for_out_of_scope_variable (decl
);
2942 /* Remember that the name was used in the definition of
2943 the current class so that we can check later to see if
2944 the meaning would have been different after the class
2945 was entirely defined. */
2946 if (!scope
&& decl
!= error_mark_node
2947 && TREE_CODE (id_expression
) == IDENTIFIER_NODE
)
2948 maybe_note_name_used_in_class (id_expression
, decl
);
2950 /* Disallow uses of local variables from containing functions, except
2951 within lambda-expressions. */
2952 if (outer_automatic_var_p (decl
)
2953 /* It's not a use (3.2) if we're in an unevaluated context. */
2954 && !cp_unevaluated_operand
)
2956 tree context
= DECL_CONTEXT (decl
);
2957 tree containing_function
= current_function_decl
;
2958 tree lambda_stack
= NULL_TREE
;
2959 tree lambda_expr
= NULL_TREE
;
2960 tree initializer
= convert_from_reference (decl
);
2962 /* Mark it as used now even if the use is ill-formed. */
2965 /* Core issue 696: "[At the July 2009 meeting] the CWG expressed
2966 support for an approach in which a reference to a local
2967 [constant] automatic variable in a nested class or lambda body
2968 would enter the expression as an rvalue, which would reduce
2969 the complexity of the problem"
2971 FIXME update for final resolution of core issue 696. */
2972 if (decl_constant_var_p (decl
))
2973 return integral_constant_value (decl
);
2975 /* If we are in a lambda function, we can move out until we hit
2977 2. a non-lambda function, or
2978 3. a non-default capturing lambda function. */
2979 while (context
!= containing_function
2980 && LAMBDA_FUNCTION_P (containing_function
))
2982 lambda_expr
= CLASSTYPE_LAMBDA_EXPR
2983 (DECL_CONTEXT (containing_function
));
2985 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr
)
2989 lambda_stack
= tree_cons (NULL_TREE
,
2994 = decl_function_context (containing_function
);
2997 if (context
== containing_function
)
2999 decl
= add_default_capture (lambda_stack
,
3000 /*id=*/DECL_NAME (decl
),
3003 else if (lambda_expr
)
3005 error ("%qD is not captured", decl
);
3006 return error_mark_node
;
3010 error (TREE_CODE (decl
) == VAR_DECL
3011 ? G_("use of %<auto%> variable from containing function")
3012 : G_("use of parameter from containing function"));
3013 error (" %q+#D declared here", decl
);
3014 return error_mark_node
;
3018 /* Also disallow uses of function parameters outside the function
3019 body, except inside an unevaluated context (i.e. decltype). */
3020 if (TREE_CODE (decl
) == PARM_DECL
3021 && DECL_CONTEXT (decl
) == NULL_TREE
3022 && !cp_unevaluated_operand
)
3024 error ("use of parameter %qD outside function body", decl
);
3025 return error_mark_node
;
3029 /* If we didn't find anything, or what we found was a type,
3030 then this wasn't really an id-expression. */
3031 if (TREE_CODE (decl
) == TEMPLATE_DECL
3032 && !DECL_FUNCTION_TEMPLATE_P (decl
))
3034 *error_msg
= "missing template arguments";
3035 return error_mark_node
;
3037 else if (TREE_CODE (decl
) == TYPE_DECL
3038 || TREE_CODE (decl
) == NAMESPACE_DECL
)
3040 *error_msg
= "expected primary-expression";
3041 return error_mark_node
;
3044 /* If the name resolved to a template parameter, there is no
3045 need to look it up again later. */
3046 if ((TREE_CODE (decl
) == CONST_DECL
&& DECL_TEMPLATE_PARM_P (decl
))
3047 || TREE_CODE (decl
) == TEMPLATE_PARM_INDEX
)
3051 *idk
= CP_ID_KIND_NONE
;
3052 if (TREE_CODE (decl
) == TEMPLATE_PARM_INDEX
)
3053 decl
= TEMPLATE_PARM_DECL (decl
);
3054 r
= convert_from_reference (DECL_INITIAL (decl
));
3056 if (integral_constant_expression_p
3057 && !dependent_type_p (TREE_TYPE (decl
))
3058 && !(INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (r
))))
3060 if (!allow_non_integral_constant_expression_p
)
3061 error ("template parameter %qD of type %qT is not allowed in "
3062 "an integral constant expression because it is not of "
3063 "integral or enumeration type", decl
, TREE_TYPE (decl
));
3064 *non_integral_constant_expression_p
= true;
3072 /* If the declaration was explicitly qualified indicate
3073 that. The semantics of `A::f(3)' are different than
3074 `f(3)' if `f' is virtual. */
3076 ? CP_ID_KIND_QUALIFIED
3077 : (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
3078 ? CP_ID_KIND_TEMPLATE_ID
3079 : CP_ID_KIND_UNQUALIFIED
));
3084 An id-expression is type-dependent if it contains an
3085 identifier that was declared with a dependent type.
3087 The standard is not very specific about an id-expression that
3088 names a set of overloaded functions. What if some of them
3089 have dependent types and some of them do not? Presumably,
3090 such a name should be treated as a dependent name. */
3091 /* Assume the name is not dependent. */
3092 dependent_p
= false;
3093 if (!processing_template_decl
)
3094 /* No names are dependent outside a template. */
3096 else if (TREE_CODE (decl
) == CONST_DECL
)
3097 /* We don't want to treat enumerators as dependent. */
3099 /* A template-id where the name of the template was not resolved
3100 is definitely dependent. */
3101 else if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
3102 && (TREE_CODE (TREE_OPERAND (decl
, 0))
3103 == IDENTIFIER_NODE
))
3105 /* For anything except an overloaded function, just check its
3107 else if (!is_overloaded_fn (decl
))
3109 = dependent_type_p (TREE_TYPE (decl
));
3110 /* For a set of overloaded functions, check each of the
3116 if (BASELINK_P (fns
))
3117 fns
= BASELINK_FUNCTIONS (fns
);
3119 /* For a template-id, check to see if the template
3120 arguments are dependent. */
3121 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
3123 tree args
= TREE_OPERAND (fns
, 1);
3124 dependent_p
= any_dependent_template_arguments_p (args
);
3125 /* The functions are those referred to by the
3127 fns
= TREE_OPERAND (fns
, 0);
3130 /* If there are no dependent template arguments, go through
3131 the overloaded functions. */
3132 while (fns
&& !dependent_p
)
3134 tree fn
= OVL_CURRENT (fns
);
3136 /* Member functions of dependent classes are
3138 if (TREE_CODE (fn
) == FUNCTION_DECL
3139 && type_dependent_expression_p (fn
))
3141 else if (TREE_CODE (fn
) == TEMPLATE_DECL
3142 && dependent_template_p (fn
))
3145 fns
= OVL_NEXT (fns
);
3149 /* If the name was dependent on a template parameter, we will
3150 resolve the name at instantiation time. */
3153 /* Create a SCOPE_REF for qualified names, if the scope is
3159 if (address_p
&& done
)
3160 decl
= finish_qualified_id_expr (scope
, decl
,
3166 tree type
= NULL_TREE
;
3167 if (DECL_P (decl
) && !dependent_scope_p (scope
))
3168 type
= TREE_TYPE (decl
);
3169 decl
= build_qualified_name (type
,
3175 if (TREE_TYPE (decl
))
3176 decl
= convert_from_reference (decl
);
3179 /* A TEMPLATE_ID already contains all the information we
3181 if (TREE_CODE (id_expression
) == TEMPLATE_ID_EXPR
)
3182 return id_expression
;
3183 *idk
= CP_ID_KIND_UNQUALIFIED_DEPENDENT
;
3184 /* If we found a variable, then name lookup during the
3185 instantiation will always resolve to the same VAR_DECL
3186 (or an instantiation thereof). */
3187 if (TREE_CODE (decl
) == VAR_DECL
3188 || TREE_CODE (decl
) == PARM_DECL
)
3191 return convert_from_reference (decl
);
3193 /* The same is true for FIELD_DECL, but we also need to
3194 make sure that the syntax is correct. */
3195 else if (TREE_CODE (decl
) == FIELD_DECL
)
3197 /* Since SCOPE is NULL here, this is an unqualified name.
3198 Access checking has been performed during name lookup
3199 already. Turn off checking to avoid duplicate errors. */
3200 push_deferring_access_checks (dk_no_check
);
3201 decl
= finish_non_static_data_member
3203 /*qualifying_scope=*/NULL_TREE
);
3204 pop_deferring_access_checks ();
3207 return id_expression
;
3210 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
3212 error ("use of namespace %qD as expression", decl
);
3213 return error_mark_node
;
3215 else if (DECL_CLASS_TEMPLATE_P (decl
))
3217 error ("use of class template %qT as expression", decl
);
3218 return error_mark_node
;
3220 else if (TREE_CODE (decl
) == TREE_LIST
)
3222 /* Ambiguous reference to base members. */
3223 error ("request for member %qD is ambiguous in "
3224 "multiple inheritance lattice", id_expression
);
3225 print_candidates (decl
);
3226 return error_mark_node
;
3229 /* Mark variable-like entities as used. Functions are similarly
3230 marked either below or after overload resolution. */
3231 if (TREE_CODE (decl
) == VAR_DECL
3232 || TREE_CODE (decl
) == PARM_DECL
3233 || TREE_CODE (decl
) == CONST_DECL
3234 || TREE_CODE (decl
) == RESULT_DECL
)
3237 /* Only certain kinds of names are allowed in constant
3238 expression. Template parameters have already
3239 been handled above. */
3240 if (! error_operand_p (decl
)
3241 && integral_constant_expression_p
3242 && ! decl_constant_var_p (decl
)
3243 && TREE_CODE (decl
) != CONST_DECL
3244 && ! builtin_valid_in_constant_expr_p (decl
))
3246 if (!allow_non_integral_constant_expression_p
)
3248 error ("%qD cannot appear in a constant-expression", decl
);
3249 return error_mark_node
;
3251 *non_integral_constant_expression_p
= true;
3256 decl
= (adjust_result_of_qualified_name_lookup
3257 (decl
, scope
, current_nonlambda_class_type()));
3259 if (TREE_CODE (decl
) == FUNCTION_DECL
)
3262 if (TREE_CODE (decl
) == FIELD_DECL
|| BASELINK_P (decl
))
3263 decl
= finish_qualified_id_expr (scope
,
3271 tree r
= convert_from_reference (decl
);
3273 /* In a template, return a SCOPE_REF for most qualified-ids
3274 so that we can check access at instantiation time. But if
3275 we're looking at a member of the current instantiation, we
3276 know we have access and building up the SCOPE_REF confuses
3277 non-type template argument handling. */
3278 if (processing_template_decl
&& TYPE_P (scope
)
3279 && !currently_open_class (scope
))
3280 r
= build_qualified_name (TREE_TYPE (r
),
3286 else if (TREE_CODE (decl
) == FIELD_DECL
)
3288 /* Since SCOPE is NULL here, this is an unqualified name.
3289 Access checking has been performed during name lookup
3290 already. Turn off checking to avoid duplicate errors. */
3291 push_deferring_access_checks (dk_no_check
);
3292 decl
= finish_non_static_data_member (decl
, NULL_TREE
,
3293 /*qualifying_scope=*/NULL_TREE
);
3294 pop_deferring_access_checks ();
3296 else if (is_overloaded_fn (decl
))
3300 first_fn
= get_first_fn (decl
);
3301 if (TREE_CODE (first_fn
) == TEMPLATE_DECL
)
3302 first_fn
= DECL_TEMPLATE_RESULT (first_fn
);
3304 if (!really_overloaded_fn (decl
)
3305 && !mark_used (first_fn
))
3306 return error_mark_node
;
3309 && TREE_CODE (first_fn
) == FUNCTION_DECL
3310 && DECL_FUNCTION_MEMBER_P (first_fn
)
3311 && !shared_member_p (decl
))
3313 /* A set of member functions. */
3314 decl
= maybe_dummy_object (DECL_CONTEXT (first_fn
), 0);
3315 return finish_class_member_access_expr (decl
, id_expression
,
3316 /*template_p=*/false,
3317 tf_warning_or_error
);
3320 decl
= baselink_for_fns (decl
);
3324 if (DECL_P (decl
) && DECL_NONLOCAL (decl
)
3325 && DECL_CLASS_SCOPE_P (decl
))
3327 tree context
= context_for_name_lookup (decl
);
3328 if (context
!= current_class_type
)
3330 tree path
= currently_open_derived_class (context
);
3331 perform_or_defer_access_check (TYPE_BINFO (path
),
3336 decl
= convert_from_reference (decl
);
3340 if (TREE_DEPRECATED (decl
))
3341 warn_deprecated_use (decl
, NULL_TREE
);
3346 /* Implement the __typeof keyword: Return the type of EXPR, suitable for
3347 use as a type-specifier. */
3350 finish_typeof (tree expr
)
3354 if (type_dependent_expression_p (expr
))
3356 type
= cxx_make_type (TYPEOF_TYPE
);
3357 TYPEOF_TYPE_EXPR (type
) = expr
;
3358 SET_TYPE_STRUCTURAL_EQUALITY (type
);
3363 expr
= mark_type_use (expr
);
3365 type
= unlowered_expr_type (expr
);
3367 if (!type
|| type
== unknown_type_node
)
3369 error ("type of %qE is unknown", expr
);
3370 return error_mark_node
;
3376 /* Implement the __underlying_type keyword: Return the underlying
3377 type of TYPE, suitable for use as a type-specifier. */
3380 finish_underlying_type (tree type
)
3382 tree underlying_type
;
3384 if (processing_template_decl
)
3386 underlying_type
= cxx_make_type (UNDERLYING_TYPE
);
3387 UNDERLYING_TYPE_TYPE (underlying_type
) = type
;
3388 SET_TYPE_STRUCTURAL_EQUALITY (underlying_type
);
3390 return underlying_type
;
3393 complete_type (type
);
3395 if (TREE_CODE (type
) != ENUMERAL_TYPE
)
3397 error ("%qT is not an enumeration type", type
);
3398 return error_mark_node
;
3401 underlying_type
= ENUM_UNDERLYING_TYPE (type
);
3403 /* Fixup necessary in this case because ENUM_UNDERLYING_TYPE
3404 includes TYPE_MIN_VALUE and TYPE_MAX_VALUE information.
3405 See finish_enum_value_list for details. */
3406 if (!ENUM_FIXED_UNDERLYING_TYPE_P (type
))
3408 = c_common_type_for_mode (TYPE_MODE (underlying_type
),
3409 TYPE_UNSIGNED (underlying_type
));
3411 return underlying_type
;
3414 /* Implement the __direct_bases keyword: Return the direct base classes
3418 calculate_direct_bases (tree type
)
3420 VEC(tree
, gc
) *vector
= make_tree_vector();
3421 tree bases_vec
= NULL_TREE
;
3422 VEC(tree
, none
) *base_binfos
;
3426 complete_type (type
);
3428 if (!NON_UNION_CLASS_TYPE_P (type
))
3429 return make_tree_vec (0);
3431 base_binfos
= BINFO_BASE_BINFOS (TYPE_BINFO (type
));
3433 /* Virtual bases are initialized first */
3434 for (i
= 0; VEC_iterate (tree
, base_binfos
, i
, binfo
); i
++)
3436 if (BINFO_VIRTUAL_P (binfo
))
3438 VEC_safe_push (tree
, gc
, vector
, binfo
);
3442 /* Now non-virtuals */
3443 for (i
= 0; VEC_iterate (tree
, base_binfos
, i
, binfo
); i
++)
3445 if (!BINFO_VIRTUAL_P (binfo
))
3447 VEC_safe_push (tree
, gc
, vector
, binfo
);
3452 bases_vec
= make_tree_vec (VEC_length (tree
, vector
));
3454 for (i
= 0; i
< VEC_length (tree
, vector
); ++i
)
3456 TREE_VEC_ELT (bases_vec
, i
) = BINFO_TYPE (VEC_index (tree
, vector
, i
));
3461 /* Implement the __bases keyword: Return the base classes
3464 /* Find morally non-virtual base classes by walking binfo hierarchy */
3465 /* Virtual base classes are handled separately in finish_bases */
3468 dfs_calculate_bases_pre (tree binfo
, ATTRIBUTE_UNUSED
void *data_
)
3470 /* Don't walk bases of virtual bases */
3471 return BINFO_VIRTUAL_P (binfo
) ? dfs_skip_bases
: NULL_TREE
;
3475 dfs_calculate_bases_post (tree binfo
, void *data_
)
3477 VEC(tree
, gc
) **data
= (VEC(tree
, gc
) **) data_
;
3478 if (!BINFO_VIRTUAL_P (binfo
))
3480 VEC_safe_push (tree
, gc
, *data
, BINFO_TYPE (binfo
));
3485 /* Calculates the morally non-virtual base classes of a class */
3486 static VEC(tree
, gc
) *
3487 calculate_bases_helper (tree type
)
3489 VEC(tree
, gc
) *vector
= make_tree_vector();
3491 /* Now add non-virtual base classes in order of construction */
3492 dfs_walk_all (TYPE_BINFO (type
),
3493 dfs_calculate_bases_pre
, dfs_calculate_bases_post
, &vector
);
3498 calculate_bases (tree type
)
3500 VEC(tree
, gc
) *vector
= make_tree_vector();
3501 tree bases_vec
= NULL_TREE
;
3503 VEC(tree
, gc
) *vbases
;
3504 VEC(tree
, gc
) *nonvbases
;
3507 complete_type (type
);
3509 if (!NON_UNION_CLASS_TYPE_P (type
))
3510 return make_tree_vec (0);
3512 /* First go through virtual base classes */
3513 for (vbases
= CLASSTYPE_VBASECLASSES (type
), i
= 0;
3514 VEC_iterate (tree
, vbases
, i
, binfo
); i
++)
3516 VEC(tree
, gc
) *vbase_bases
= calculate_bases_helper (BINFO_TYPE (binfo
));
3517 VEC_safe_splice (tree
, gc
, vector
, vbase_bases
);
3518 release_tree_vector (vbase_bases
);
3521 /* Now for the non-virtual bases */
3522 nonvbases
= calculate_bases_helper (type
);
3523 VEC_safe_splice (tree
, gc
, vector
, nonvbases
);
3524 release_tree_vector (nonvbases
);
3526 /* Last element is entire class, so don't copy */
3527 bases_vec
= make_tree_vec (VEC_length (tree
, vector
) - 1);
3529 for (i
= 0; i
< VEC_length (tree
, vector
) - 1; ++i
)
3531 TREE_VEC_ELT (bases_vec
, i
) = VEC_index (tree
, vector
, i
);
3533 release_tree_vector (vector
);
3538 finish_bases (tree type
, bool direct
)
3540 tree bases
= NULL_TREE
;
3542 if (!processing_template_decl
)
3544 /* Parameter packs can only be used in templates */
3545 error ("Parameter pack __bases only valid in template declaration");
3546 return error_mark_node
;
3549 bases
= cxx_make_type (BASES
);
3550 BASES_TYPE (bases
) = type
;
3551 BASES_DIRECT (bases
) = direct
;
3552 SET_TYPE_STRUCTURAL_EQUALITY (bases
);
3557 /* Perform C++-specific checks for __builtin_offsetof before calling
3561 finish_offsetof (tree expr
)
3563 if (TREE_CODE (expr
) == PSEUDO_DTOR_EXPR
)
3565 error ("cannot apply %<offsetof%> to destructor %<~%T%>",
3566 TREE_OPERAND (expr
, 2));
3567 return error_mark_node
;
3569 if (TREE_CODE (TREE_TYPE (expr
)) == FUNCTION_TYPE
3570 || TREE_CODE (TREE_TYPE (expr
)) == METHOD_TYPE
3571 || TREE_TYPE (expr
) == unknown_type_node
)
3573 if (TREE_CODE (expr
) == COMPONENT_REF
3574 || TREE_CODE (expr
) == COMPOUND_EXPR
)
3575 expr
= TREE_OPERAND (expr
, 1);
3576 error ("cannot apply %<offsetof%> to member function %qD", expr
);
3577 return error_mark_node
;
3579 if (REFERENCE_REF_P (expr
))
3580 expr
= TREE_OPERAND (expr
, 0);
3581 if (TREE_CODE (expr
) == COMPONENT_REF
)
3583 tree object
= TREE_OPERAND (expr
, 0);
3584 if (!complete_type_or_else (TREE_TYPE (object
), object
))
3585 return error_mark_node
;
3587 return fold_offsetof (expr
);
3590 /* Replace the AGGR_INIT_EXPR at *TP with an equivalent CALL_EXPR. This
3591 function is broken out from the above for the benefit of the tree-ssa
3595 simplify_aggr_init_expr (tree
*tp
)
3597 tree aggr_init_expr
= *tp
;
3599 /* Form an appropriate CALL_EXPR. */
3600 tree fn
= AGGR_INIT_EXPR_FN (aggr_init_expr
);
3601 tree slot
= AGGR_INIT_EXPR_SLOT (aggr_init_expr
);
3602 tree type
= TREE_TYPE (slot
);
3605 enum style_t
{ ctor
, arg
, pcc
} style
;
3607 if (AGGR_INIT_VIA_CTOR_P (aggr_init_expr
))
3609 #ifdef PCC_STATIC_STRUCT_RETURN
3615 gcc_assert (TREE_ADDRESSABLE (type
));
3619 call_expr
= build_call_array_loc (input_location
,
3620 TREE_TYPE (TREE_TYPE (TREE_TYPE (fn
))),
3622 aggr_init_expr_nargs (aggr_init_expr
),
3623 AGGR_INIT_EXPR_ARGP (aggr_init_expr
));
3624 TREE_NOTHROW (call_expr
) = TREE_NOTHROW (aggr_init_expr
);
3628 /* Replace the first argument to the ctor with the address of the
3630 cxx_mark_addressable (slot
);
3631 CALL_EXPR_ARG (call_expr
, 0) =
3632 build1 (ADDR_EXPR
, build_pointer_type (type
), slot
);
3634 else if (style
== arg
)
3636 /* Just mark it addressable here, and leave the rest to
3637 expand_call{,_inline}. */
3638 cxx_mark_addressable (slot
);
3639 CALL_EXPR_RETURN_SLOT_OPT (call_expr
) = true;
3640 call_expr
= build2 (INIT_EXPR
, TREE_TYPE (call_expr
), slot
, call_expr
);
3642 else if (style
== pcc
)
3644 /* If we're using the non-reentrant PCC calling convention, then we
3645 need to copy the returned value out of the static buffer into the
3647 push_deferring_access_checks (dk_no_check
);
3648 call_expr
= build_aggr_init (slot
, call_expr
,
3649 DIRECT_BIND
| LOOKUP_ONLYCONVERTING
,
3650 tf_warning_or_error
);
3651 pop_deferring_access_checks ();
3652 call_expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (slot
), call_expr
, slot
);
3655 if (AGGR_INIT_ZERO_FIRST (aggr_init_expr
))
3657 tree init
= build_zero_init (type
, NULL_TREE
,
3658 /*static_storage_p=*/false);
3659 init
= build2 (INIT_EXPR
, void_type_node
, slot
, init
);
3660 call_expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (call_expr
),
3667 /* Emit all thunks to FN that should be emitted when FN is emitted. */
3670 emit_associated_thunks (tree fn
)
3672 /* When we use vcall offsets, we emit thunks with the virtual
3673 functions to which they thunk. The whole point of vcall offsets
3674 is so that you can know statically the entire set of thunks that
3675 will ever be needed for a given virtual function, thereby
3676 enabling you to output all the thunks with the function itself. */
3677 if (DECL_VIRTUAL_P (fn
)
3678 /* Do not emit thunks for extern template instantiations. */
3679 && ! DECL_REALLY_EXTERN (fn
))
3683 for (thunk
= DECL_THUNKS (fn
); thunk
; thunk
= DECL_CHAIN (thunk
))
3685 if (!THUNK_ALIAS (thunk
))
3687 use_thunk (thunk
, /*emit_p=*/1);
3688 if (DECL_RESULT_THUNK_P (thunk
))
3692 for (probe
= DECL_THUNKS (thunk
);
3693 probe
; probe
= DECL_CHAIN (probe
))
3694 use_thunk (probe
, /*emit_p=*/1);
3698 gcc_assert (!DECL_THUNKS (thunk
));
3703 /* Returns true iff FUN is an instantiation of a constexpr function
3707 is_instantiation_of_constexpr (tree fun
)
3709 return (DECL_TEMPLOID_INSTANTIATION (fun
)
3710 && DECL_DECLARED_CONSTEXPR_P (DECL_TEMPLATE_RESULT
3711 (DECL_TI_TEMPLATE (fun
))));
3714 /* Generate RTL for FN. */
3717 expand_or_defer_fn_1 (tree fn
)
3719 /* When the parser calls us after finishing the body of a template
3720 function, we don't really want to expand the body. */
3721 if (processing_template_decl
)
3723 /* Normally, collection only occurs in rest_of_compilation. So,
3724 if we don't collect here, we never collect junk generated
3725 during the processing of templates until we hit a
3726 non-template function. It's not safe to do this inside a
3727 nested class, though, as the parser may have local state that
3728 is not a GC root. */
3729 if (!function_depth
)
3734 gcc_assert (DECL_SAVED_TREE (fn
));
3736 /* If this is a constructor or destructor body, we have to clone
3738 if (maybe_clone_body (fn
))
3740 /* We don't want to process FN again, so pretend we've written
3741 it out, even though we haven't. */
3742 TREE_ASM_WRITTEN (fn
) = 1;
3743 /* If this is an instantiation of a constexpr function, keep
3744 DECL_SAVED_TREE for explain_invalid_constexpr_fn. */
3745 if (!is_instantiation_of_constexpr (fn
))
3746 DECL_SAVED_TREE (fn
) = NULL_TREE
;
3750 /* We make a decision about linkage for these functions at the end
3751 of the compilation. Until that point, we do not want the back
3752 end to output them -- but we do want it to see the bodies of
3753 these functions so that it can inline them as appropriate. */
3754 if (DECL_DECLARED_INLINE_P (fn
) || DECL_IMPLICIT_INSTANTIATION (fn
))
3756 if (DECL_INTERFACE_KNOWN (fn
))
3757 /* We've already made a decision as to how this function will
3761 DECL_EXTERNAL (fn
) = 1;
3762 DECL_NOT_REALLY_EXTERN (fn
) = 1;
3763 note_vague_linkage_fn (fn
);
3764 /* A non-template inline function with external linkage will
3765 always be COMDAT. As we must eventually determine the
3766 linkage of all functions, and as that causes writes to
3767 the data mapped in from the PCH file, it's advantageous
3768 to mark the functions at this point. */
3769 if (!DECL_IMPLICIT_INSTANTIATION (fn
))
3771 /* This function must have external linkage, as
3772 otherwise DECL_INTERFACE_KNOWN would have been
3774 gcc_assert (TREE_PUBLIC (fn
));
3775 comdat_linkage (fn
);
3776 DECL_INTERFACE_KNOWN (fn
) = 1;
3780 import_export_decl (fn
);
3782 /* If the user wants us to keep all inline functions, then mark
3783 this function as needed so that finish_file will make sure to
3784 output it later. Similarly, all dllexport'd functions must
3785 be emitted; there may be callers in other DLLs. */
3786 if ((flag_keep_inline_functions
3787 && DECL_DECLARED_INLINE_P (fn
)
3788 && !DECL_REALLY_EXTERN (fn
))
3789 || (flag_keep_inline_dllexport
3790 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (fn
))))
3793 DECL_EXTERNAL (fn
) = 0;
3797 /* There's no reason to do any of the work here if we're only doing
3798 semantic analysis; this code just generates RTL. */
3799 if (flag_syntax_only
)
3806 expand_or_defer_fn (tree fn
)
3808 if (expand_or_defer_fn_1 (fn
))
3812 /* Expand or defer, at the whim of the compilation unit manager. */
3813 cgraph_finalize_function (fn
, function_depth
> 1);
3814 emit_associated_thunks (fn
);
3827 /* Helper function for walk_tree, used by finalize_nrv below. */
3830 finalize_nrv_r (tree
* tp
, int* walk_subtrees
, void* data
)
3832 struct nrv_data
*dp
= (struct nrv_data
*)data
;
3835 /* No need to walk into types. There wouldn't be any need to walk into
3836 non-statements, except that we have to consider STMT_EXPRs. */
3839 /* Change all returns to just refer to the RESULT_DECL; this is a nop,
3840 but differs from using NULL_TREE in that it indicates that we care
3841 about the value of the RESULT_DECL. */
3842 else if (TREE_CODE (*tp
) == RETURN_EXPR
)
3843 TREE_OPERAND (*tp
, 0) = dp
->result
;
3844 /* Change all cleanups for the NRV to only run when an exception is
3846 else if (TREE_CODE (*tp
) == CLEANUP_STMT
3847 && CLEANUP_DECL (*tp
) == dp
->var
)
3848 CLEANUP_EH_ONLY (*tp
) = 1;
3849 /* Replace the DECL_EXPR for the NRV with an initialization of the
3850 RESULT_DECL, if needed. */
3851 else if (TREE_CODE (*tp
) == DECL_EXPR
3852 && DECL_EXPR_DECL (*tp
) == dp
->var
)
3855 if (DECL_INITIAL (dp
->var
)
3856 && DECL_INITIAL (dp
->var
) != error_mark_node
)
3857 init
= build2 (INIT_EXPR
, void_type_node
, dp
->result
,
3858 DECL_INITIAL (dp
->var
));
3860 init
= build_empty_stmt (EXPR_LOCATION (*tp
));
3861 DECL_INITIAL (dp
->var
) = NULL_TREE
;
3862 SET_EXPR_LOCATION (init
, EXPR_LOCATION (*tp
));
3865 /* And replace all uses of the NRV with the RESULT_DECL. */
3866 else if (*tp
== dp
->var
)
3869 /* Avoid walking into the same tree more than once. Unfortunately, we
3870 can't just use walk_tree_without duplicates because it would only call
3871 us for the first occurrence of dp->var in the function body. */
3872 slot
= htab_find_slot (dp
->visited
, *tp
, INSERT
);
3878 /* Keep iterating. */
3882 /* Called from finish_function to implement the named return value
3883 optimization by overriding all the RETURN_EXPRs and pertinent
3884 CLEANUP_STMTs and replacing all occurrences of VAR with RESULT, the
3885 RESULT_DECL for the function. */
3888 finalize_nrv (tree
*tp
, tree var
, tree result
)
3890 struct nrv_data data
;
3892 /* Copy name from VAR to RESULT. */
3893 DECL_NAME (result
) = DECL_NAME (var
);
3894 /* Don't forget that we take its address. */
3895 TREE_ADDRESSABLE (result
) = TREE_ADDRESSABLE (var
);
3896 /* Finally set DECL_VALUE_EXPR to avoid assigning
3897 a stack slot at -O0 for the original var and debug info
3898 uses RESULT location for VAR. */
3899 SET_DECL_VALUE_EXPR (var
, result
);
3900 DECL_HAS_VALUE_EXPR_P (var
) = 1;
3903 data
.result
= result
;
3904 data
.visited
= htab_create (37, htab_hash_pointer
, htab_eq_pointer
, NULL
);
3905 cp_walk_tree (tp
, finalize_nrv_r
, &data
, 0);
3906 htab_delete (data
.visited
);
3909 /* Create CP_OMP_CLAUSE_INFO for clause C. Returns true if it is invalid. */
3912 cxx_omp_create_clause_info (tree c
, tree type
, bool need_default_ctor
,
3913 bool need_copy_ctor
, bool need_copy_assignment
)
3915 int save_errorcount
= errorcount
;
3918 /* Always allocate 3 elements for simplicity. These are the
3919 function decls for the ctor, dtor, and assignment op.
3920 This layout is known to the three lang hooks,
3921 cxx_omp_clause_default_init, cxx_omp_clause_copy_init,
3922 and cxx_omp_clause_assign_op. */
3923 info
= make_tree_vec (3);
3924 CP_OMP_CLAUSE_INFO (c
) = info
;
3926 if (need_default_ctor
|| need_copy_ctor
)
3928 if (need_default_ctor
)
3929 t
= get_default_ctor (type
);
3931 t
= get_copy_ctor (type
, tf_warning_or_error
);
3933 if (t
&& !trivial_fn_p (t
))
3934 TREE_VEC_ELT (info
, 0) = t
;
3937 if ((need_default_ctor
|| need_copy_ctor
)
3938 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
3939 TREE_VEC_ELT (info
, 1) = get_dtor (type
, tf_warning_or_error
);
3941 if (need_copy_assignment
)
3943 t
= get_copy_assign (type
);
3945 if (t
&& !trivial_fn_p (t
))
3946 TREE_VEC_ELT (info
, 2) = t
;
3949 return errorcount
!= save_errorcount
;
3952 /* For all elements of CLAUSES, validate them vs OpenMP constraints.
3953 Remove any elements from the list that are invalid. */
3956 finish_omp_clauses (tree clauses
)
3958 bitmap_head generic_head
, firstprivate_head
, lastprivate_head
;
3959 tree c
, t
, *pc
= &clauses
;
3962 bitmap_obstack_initialize (NULL
);
3963 bitmap_initialize (&generic_head
, &bitmap_default_obstack
);
3964 bitmap_initialize (&firstprivate_head
, &bitmap_default_obstack
);
3965 bitmap_initialize (&lastprivate_head
, &bitmap_default_obstack
);
3967 for (pc
= &clauses
, c
= clauses
; c
; c
= *pc
)
3969 bool remove
= false;
3971 switch (OMP_CLAUSE_CODE (c
))
3973 case OMP_CLAUSE_SHARED
:
3975 goto check_dup_generic
;
3976 case OMP_CLAUSE_PRIVATE
:
3978 goto check_dup_generic
;
3979 case OMP_CLAUSE_REDUCTION
:
3981 goto check_dup_generic
;
3982 case OMP_CLAUSE_COPYPRIVATE
:
3983 name
= "copyprivate";
3984 goto check_dup_generic
;
3985 case OMP_CLAUSE_COPYIN
:
3987 goto check_dup_generic
;
3989 t
= OMP_CLAUSE_DECL (c
);
3990 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
3992 if (processing_template_decl
)
3995 error ("%qD is not a variable in clause %qs", t
, name
);
3997 error ("%qE is not a variable in clause %qs", t
, name
);
4000 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
4001 || bitmap_bit_p (&firstprivate_head
, DECL_UID (t
))
4002 || bitmap_bit_p (&lastprivate_head
, DECL_UID (t
)))
4004 error ("%qD appears more than once in data clauses", t
);
4008 bitmap_set_bit (&generic_head
, DECL_UID (t
));
4011 case OMP_CLAUSE_FIRSTPRIVATE
:
4012 t
= OMP_CLAUSE_DECL (c
);
4013 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
4015 if (processing_template_decl
)
4018 error ("%qD is not a variable in clause %<firstprivate%>", t
);
4020 error ("%qE is not a variable in clause %<firstprivate%>", t
);
4023 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
4024 || bitmap_bit_p (&firstprivate_head
, DECL_UID (t
)))
4026 error ("%qD appears more than once in data clauses", t
);
4030 bitmap_set_bit (&firstprivate_head
, DECL_UID (t
));
4033 case OMP_CLAUSE_LASTPRIVATE
:
4034 t
= OMP_CLAUSE_DECL (c
);
4035 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
4037 if (processing_template_decl
)
4040 error ("%qD is not a variable in clause %<lastprivate%>", t
);
4042 error ("%qE is not a variable in clause %<lastprivate%>", t
);
4045 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
4046 || bitmap_bit_p (&lastprivate_head
, DECL_UID (t
)))
4048 error ("%qD appears more than once in data clauses", t
);
4052 bitmap_set_bit (&lastprivate_head
, DECL_UID (t
));
4056 t
= OMP_CLAUSE_IF_EXPR (c
);
4057 t
= maybe_convert_cond (t
);
4058 if (t
== error_mark_node
)
4060 else if (!processing_template_decl
)
4061 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4062 OMP_CLAUSE_IF_EXPR (c
) = t
;
4065 case OMP_CLAUSE_FINAL
:
4066 t
= OMP_CLAUSE_FINAL_EXPR (c
);
4067 t
= maybe_convert_cond (t
);
4068 if (t
== error_mark_node
)
4070 else if (!processing_template_decl
)
4071 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4072 OMP_CLAUSE_FINAL_EXPR (c
) = t
;
4075 case OMP_CLAUSE_NUM_THREADS
:
4076 t
= OMP_CLAUSE_NUM_THREADS_EXPR (c
);
4077 if (t
== error_mark_node
)
4079 else if (!type_dependent_expression_p (t
)
4080 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
4082 error ("num_threads expression must be integral");
4087 t
= mark_rvalue_use (t
);
4088 if (!processing_template_decl
)
4089 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4090 OMP_CLAUSE_NUM_THREADS_EXPR (c
) = t
;
4094 case OMP_CLAUSE_SCHEDULE
:
4095 t
= OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c
);
4098 else if (t
== error_mark_node
)
4100 else if (!type_dependent_expression_p (t
)
4101 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
4103 error ("schedule chunk size expression must be integral");
4108 t
= mark_rvalue_use (t
);
4109 if (!processing_template_decl
)
4110 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4111 OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c
) = t
;
4115 case OMP_CLAUSE_NOWAIT
:
4116 case OMP_CLAUSE_ORDERED
:
4117 case OMP_CLAUSE_DEFAULT
:
4118 case OMP_CLAUSE_UNTIED
:
4119 case OMP_CLAUSE_COLLAPSE
:
4120 case OMP_CLAUSE_MERGEABLE
:
4128 *pc
= OMP_CLAUSE_CHAIN (c
);
4130 pc
= &OMP_CLAUSE_CHAIN (c
);
4133 for (pc
= &clauses
, c
= clauses
; c
; c
= *pc
)
4135 enum omp_clause_code c_kind
= OMP_CLAUSE_CODE (c
);
4136 bool remove
= false;
4137 bool need_complete_non_reference
= false;
4138 bool need_default_ctor
= false;
4139 bool need_copy_ctor
= false;
4140 bool need_copy_assignment
= false;
4141 bool need_implicitly_determined
= false;
4142 tree type
, inner_type
;
4146 case OMP_CLAUSE_SHARED
:
4148 need_implicitly_determined
= true;
4150 case OMP_CLAUSE_PRIVATE
:
4152 need_complete_non_reference
= true;
4153 need_default_ctor
= true;
4154 need_implicitly_determined
= true;
4156 case OMP_CLAUSE_FIRSTPRIVATE
:
4157 name
= "firstprivate";
4158 need_complete_non_reference
= true;
4159 need_copy_ctor
= true;
4160 need_implicitly_determined
= true;
4162 case OMP_CLAUSE_LASTPRIVATE
:
4163 name
= "lastprivate";
4164 need_complete_non_reference
= true;
4165 need_copy_assignment
= true;
4166 need_implicitly_determined
= true;
4168 case OMP_CLAUSE_REDUCTION
:
4170 need_implicitly_determined
= true;
4172 case OMP_CLAUSE_COPYPRIVATE
:
4173 name
= "copyprivate";
4174 need_copy_assignment
= true;
4176 case OMP_CLAUSE_COPYIN
:
4178 need_copy_assignment
= true;
4181 pc
= &OMP_CLAUSE_CHAIN (c
);
4185 t
= OMP_CLAUSE_DECL (c
);
4186 if (processing_template_decl
4187 && TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
4189 pc
= &OMP_CLAUSE_CHAIN (c
);
4195 case OMP_CLAUSE_LASTPRIVATE
:
4196 if (!bitmap_bit_p (&firstprivate_head
, DECL_UID (t
)))
4197 need_default_ctor
= true;
4200 case OMP_CLAUSE_REDUCTION
:
4201 if (AGGREGATE_TYPE_P (TREE_TYPE (t
))
4202 || POINTER_TYPE_P (TREE_TYPE (t
)))
4204 error ("%qE has invalid type for %<reduction%>", t
);
4207 else if (FLOAT_TYPE_P (TREE_TYPE (t
)))
4209 enum tree_code r_code
= OMP_CLAUSE_REDUCTION_CODE (c
);
4219 error ("%qE has invalid type for %<reduction(%s)%>",
4220 t
, operator_name_info
[r_code
].name
);
4226 case OMP_CLAUSE_COPYIN
:
4227 if (TREE_CODE (t
) != VAR_DECL
|| !DECL_THREAD_LOCAL_P (t
))
4229 error ("%qE must be %<threadprivate%> for %<copyin%>", t
);
4238 if (need_complete_non_reference
|| need_copy_assignment
)
4240 t
= require_complete_type (t
);
4241 if (t
== error_mark_node
)
4243 else if (TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
4244 && need_complete_non_reference
)
4246 error ("%qE has reference type for %qs", t
, name
);
4250 if (need_implicitly_determined
)
4252 const char *share_name
= NULL
;
4254 if (TREE_CODE (t
) == VAR_DECL
&& DECL_THREAD_LOCAL_P (t
))
4255 share_name
= "threadprivate";
4256 else switch (cxx_omp_predetermined_sharing (t
))
4258 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
4260 case OMP_CLAUSE_DEFAULT_SHARED
:
4261 /* const vars may be specified in firstprivate clause. */
4262 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
4263 && cxx_omp_const_qual_no_mutable (t
))
4265 share_name
= "shared";
4267 case OMP_CLAUSE_DEFAULT_PRIVATE
:
4268 share_name
= "private";
4275 error ("%qE is predetermined %qs for %qs",
4276 t
, share_name
, name
);
4281 /* We're interested in the base element, not arrays. */
4282 inner_type
= type
= TREE_TYPE (t
);
4283 while (TREE_CODE (inner_type
) == ARRAY_TYPE
)
4284 inner_type
= TREE_TYPE (inner_type
);
4286 /* Check for special function availability by building a call to one.
4287 Save the results, because later we won't be in the right context
4288 for making these queries. */
4289 if (CLASS_TYPE_P (inner_type
)
4290 && COMPLETE_TYPE_P (inner_type
)
4291 && (need_default_ctor
|| need_copy_ctor
|| need_copy_assignment
)
4292 && !type_dependent_expression_p (t
)
4293 && cxx_omp_create_clause_info (c
, inner_type
, need_default_ctor
,
4294 need_copy_ctor
, need_copy_assignment
))
4298 *pc
= OMP_CLAUSE_CHAIN (c
);
4300 pc
= &OMP_CLAUSE_CHAIN (c
);
4303 bitmap_obstack_release (NULL
);
4307 /* For all variables in the tree_list VARS, mark them as thread local. */
4310 finish_omp_threadprivate (tree vars
)
4314 /* Mark every variable in VARS to be assigned thread local storage. */
4315 for (t
= vars
; t
; t
= TREE_CHAIN (t
))
4317 tree v
= TREE_PURPOSE (t
);
4319 if (error_operand_p (v
))
4321 else if (TREE_CODE (v
) != VAR_DECL
)
4322 error ("%<threadprivate%> %qD is not file, namespace "
4323 "or block scope variable", v
);
4324 /* If V had already been marked threadprivate, it doesn't matter
4325 whether it had been used prior to this point. */
4326 else if (TREE_USED (v
)
4327 && (DECL_LANG_SPECIFIC (v
) == NULL
4328 || !CP_DECL_THREADPRIVATE_P (v
)))
4329 error ("%qE declared %<threadprivate%> after first use", v
);
4330 else if (! TREE_STATIC (v
) && ! DECL_EXTERNAL (v
))
4331 error ("automatic variable %qE cannot be %<threadprivate%>", v
);
4332 else if (! COMPLETE_TYPE_P (TREE_TYPE (v
)))
4333 error ("%<threadprivate%> %qE has incomplete type", v
);
4334 else if (TREE_STATIC (v
) && TYPE_P (CP_DECL_CONTEXT (v
))
4335 && CP_DECL_CONTEXT (v
) != current_class_type
)
4336 error ("%<threadprivate%> %qE directive not "
4337 "in %qT definition", v
, CP_DECL_CONTEXT (v
));
4340 /* Allocate a LANG_SPECIFIC structure for V, if needed. */
4341 if (DECL_LANG_SPECIFIC (v
) == NULL
)
4343 retrofit_lang_decl (v
);
4345 /* Make sure that DECL_DISCRIMINATOR_P continues to be true
4346 after the allocation of the lang_decl structure. */
4347 if (DECL_DISCRIMINATOR_P (v
))
4348 DECL_LANG_SPECIFIC (v
)->u
.base
.u2sel
= 1;
4351 if (! DECL_THREAD_LOCAL_P (v
))
4353 DECL_TLS_MODEL (v
) = decl_default_tls_model (v
);
4354 /* If rtl has been already set for this var, call
4355 make_decl_rtl once again, so that encode_section_info
4356 has a chance to look at the new decl flags. */
4357 if (DECL_RTL_SET_P (v
))
4360 CP_DECL_THREADPRIVATE_P (v
) = 1;
4365 /* Build an OpenMP structured block. */
4368 begin_omp_structured_block (void)
4370 return do_pushlevel (sk_omp
);
4374 finish_omp_structured_block (tree block
)
4376 return do_poplevel (block
);
4379 /* Similarly, except force the retention of the BLOCK. */
4382 begin_omp_parallel (void)
4384 keep_next_level (true);
4385 return begin_omp_structured_block ();
4389 finish_omp_parallel (tree clauses
, tree body
)
4393 body
= finish_omp_structured_block (body
);
4395 stmt
= make_node (OMP_PARALLEL
);
4396 TREE_TYPE (stmt
) = void_type_node
;
4397 OMP_PARALLEL_CLAUSES (stmt
) = clauses
;
4398 OMP_PARALLEL_BODY (stmt
) = body
;
4400 return add_stmt (stmt
);
4404 begin_omp_task (void)
4406 keep_next_level (true);
4407 return begin_omp_structured_block ();
4411 finish_omp_task (tree clauses
, tree body
)
4415 body
= finish_omp_structured_block (body
);
4417 stmt
= make_node (OMP_TASK
);
4418 TREE_TYPE (stmt
) = void_type_node
;
4419 OMP_TASK_CLAUSES (stmt
) = clauses
;
4420 OMP_TASK_BODY (stmt
) = body
;
4422 return add_stmt (stmt
);
4425 /* Helper function for finish_omp_for. Convert Ith random access iterator
4426 into integral iterator. Return FALSE if successful. */
4429 handle_omp_for_class_iterator (int i
, location_t locus
, tree declv
, tree initv
,
4430 tree condv
, tree incrv
, tree
*body
,
4431 tree
*pre_body
, tree clauses
)
4433 tree diff
, iter_init
, iter_incr
= NULL
, last
;
4434 tree incr_var
= NULL
, orig_pre_body
, orig_body
, c
;
4435 tree decl
= TREE_VEC_ELT (declv
, i
);
4436 tree init
= TREE_VEC_ELT (initv
, i
);
4437 tree cond
= TREE_VEC_ELT (condv
, i
);
4438 tree incr
= TREE_VEC_ELT (incrv
, i
);
4440 location_t elocus
= locus
;
4442 if (init
&& EXPR_HAS_LOCATION (init
))
4443 elocus
= EXPR_LOCATION (init
);
4445 switch (TREE_CODE (cond
))
4451 if (TREE_OPERAND (cond
, 1) == iter
)
4452 cond
= build2 (swap_tree_comparison (TREE_CODE (cond
)),
4453 TREE_TYPE (cond
), iter
, TREE_OPERAND (cond
, 0));
4454 if (TREE_OPERAND (cond
, 0) != iter
)
4455 cond
= error_mark_node
;
4458 tree tem
= build_x_binary_op (EXPR_LOCATION (cond
),
4461 TREE_OPERAND (cond
, 1), ERROR_MARK
,
4462 NULL
, tf_warning_or_error
);
4463 if (error_operand_p (tem
))
4468 cond
= error_mark_node
;
4471 if (cond
== error_mark_node
)
4473 error_at (elocus
, "invalid controlling predicate");
4476 diff
= build_x_binary_op (elocus
, MINUS_EXPR
, TREE_OPERAND (cond
, 1),
4477 ERROR_MARK
, iter
, ERROR_MARK
, NULL
,
4478 tf_warning_or_error
);
4479 if (error_operand_p (diff
))
4481 if (TREE_CODE (TREE_TYPE (diff
)) != INTEGER_TYPE
)
4483 error_at (elocus
, "difference between %qE and %qD does not have integer type",
4484 TREE_OPERAND (cond
, 1), iter
);
4488 switch (TREE_CODE (incr
))
4490 case PREINCREMENT_EXPR
:
4491 case PREDECREMENT_EXPR
:
4492 case POSTINCREMENT_EXPR
:
4493 case POSTDECREMENT_EXPR
:
4494 if (TREE_OPERAND (incr
, 0) != iter
)
4496 incr
= error_mark_node
;
4499 iter_incr
= build_x_unary_op (EXPR_LOCATION (incr
),
4500 TREE_CODE (incr
), iter
,
4501 tf_warning_or_error
);
4502 if (error_operand_p (iter_incr
))
4504 else if (TREE_CODE (incr
) == PREINCREMENT_EXPR
4505 || TREE_CODE (incr
) == POSTINCREMENT_EXPR
)
4506 incr
= integer_one_node
;
4508 incr
= integer_minus_one_node
;
4511 if (TREE_OPERAND (incr
, 0) != iter
)
4512 incr
= error_mark_node
;
4513 else if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
4514 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
4516 tree rhs
= TREE_OPERAND (incr
, 1);
4517 if (TREE_OPERAND (rhs
, 0) == iter
)
4519 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs
, 1)))
4521 incr
= error_mark_node
;
4524 iter_incr
= build_x_modify_expr (EXPR_LOCATION (rhs
),
4525 iter
, TREE_CODE (rhs
),
4526 TREE_OPERAND (rhs
, 1),
4527 tf_warning_or_error
);
4528 if (error_operand_p (iter_incr
))
4530 incr
= TREE_OPERAND (rhs
, 1);
4531 incr
= cp_convert (TREE_TYPE (diff
), incr
,
4532 tf_warning_or_error
);
4533 if (TREE_CODE (rhs
) == MINUS_EXPR
)
4535 incr
= build1 (NEGATE_EXPR
, TREE_TYPE (diff
), incr
);
4536 incr
= fold_if_not_in_template (incr
);
4538 if (TREE_CODE (incr
) != INTEGER_CST
4539 && (TREE_CODE (incr
) != NOP_EXPR
4540 || (TREE_CODE (TREE_OPERAND (incr
, 0))
4545 else if (TREE_OPERAND (rhs
, 1) == iter
)
4547 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs
, 0))) != INTEGER_TYPE
4548 || TREE_CODE (rhs
) != PLUS_EXPR
)
4549 incr
= error_mark_node
;
4552 iter_incr
= build_x_binary_op (EXPR_LOCATION (rhs
),
4554 TREE_OPERAND (rhs
, 0),
4557 tf_warning_or_error
);
4558 if (error_operand_p (iter_incr
))
4560 iter_incr
= build_x_modify_expr (EXPR_LOCATION (rhs
),
4563 tf_warning_or_error
);
4564 if (error_operand_p (iter_incr
))
4566 incr
= TREE_OPERAND (rhs
, 0);
4571 incr
= error_mark_node
;
4574 incr
= error_mark_node
;
4577 incr
= error_mark_node
;
4581 if (incr
== error_mark_node
)
4583 error_at (elocus
, "invalid increment expression");
4587 incr
= cp_convert (TREE_TYPE (diff
), incr
, tf_warning_or_error
);
4588 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
4589 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
4590 && OMP_CLAUSE_DECL (c
) == iter
)
4593 decl
= create_temporary_var (TREE_TYPE (diff
));
4595 add_decl_expr (decl
);
4596 last
= create_temporary_var (TREE_TYPE (diff
));
4598 add_decl_expr (last
);
4599 if (c
&& iter_incr
== NULL
)
4601 incr_var
= create_temporary_var (TREE_TYPE (diff
));
4602 pushdecl (incr_var
);
4603 add_decl_expr (incr_var
);
4605 gcc_assert (stmts_are_full_exprs_p ());
4607 orig_pre_body
= *pre_body
;
4608 *pre_body
= push_stmt_list ();
4610 add_stmt (orig_pre_body
);
4612 finish_expr_stmt (build_x_modify_expr (elocus
,
4613 iter
, NOP_EXPR
, init
,
4614 tf_warning_or_error
));
4615 init
= build_int_cst (TREE_TYPE (diff
), 0);
4616 if (c
&& iter_incr
== NULL
)
4618 finish_expr_stmt (build_x_modify_expr (elocus
,
4620 incr
, tf_warning_or_error
));
4622 iter_incr
= build_x_modify_expr (elocus
,
4623 iter
, PLUS_EXPR
, incr
,
4624 tf_warning_or_error
);
4626 finish_expr_stmt (build_x_modify_expr (elocus
,
4627 last
, NOP_EXPR
, init
,
4628 tf_warning_or_error
));
4629 *pre_body
= pop_stmt_list (*pre_body
);
4631 cond
= cp_build_binary_op (elocus
,
4632 TREE_CODE (cond
), decl
, diff
,
4633 tf_warning_or_error
);
4634 incr
= build_modify_expr (elocus
, decl
, NULL_TREE
, PLUS_EXPR
,
4635 elocus
, incr
, NULL_TREE
);
4638 *body
= push_stmt_list ();
4639 iter_init
= build2 (MINUS_EXPR
, TREE_TYPE (diff
), decl
, last
);
4640 iter_init
= build_x_modify_expr (elocus
,
4641 iter
, PLUS_EXPR
, iter_init
,
4642 tf_warning_or_error
);
4643 iter_init
= build1 (NOP_EXPR
, void_type_node
, iter_init
);
4644 finish_expr_stmt (iter_init
);
4645 finish_expr_stmt (build_x_modify_expr (elocus
,
4646 last
, NOP_EXPR
, decl
,
4647 tf_warning_or_error
));
4648 add_stmt (orig_body
);
4649 *body
= pop_stmt_list (*body
);
4653 OMP_CLAUSE_LASTPRIVATE_STMT (c
) = push_stmt_list ();
4654 finish_expr_stmt (iter_incr
);
4655 OMP_CLAUSE_LASTPRIVATE_STMT (c
)
4656 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (c
));
4659 TREE_VEC_ELT (declv
, i
) = decl
;
4660 TREE_VEC_ELT (initv
, i
) = init
;
4661 TREE_VEC_ELT (condv
, i
) = cond
;
4662 TREE_VEC_ELT (incrv
, i
) = incr
;
4667 /* Build and validate an OMP_FOR statement. CLAUSES, BODY, COND, INCR
4668 are directly for their associated operands in the statement. DECL
4669 and INIT are a combo; if DECL is NULL then INIT ought to be a
4670 MODIFY_EXPR, and the DECL should be extracted. PRE_BODY are
4671 optional statements that need to go before the loop into its
4675 finish_omp_for (location_t locus
, tree declv
, tree initv
, tree condv
,
4676 tree incrv
, tree body
, tree pre_body
, tree clauses
)
4678 tree omp_for
= NULL
, orig_incr
= NULL
;
4679 tree decl
, init
, cond
, incr
;
4683 gcc_assert (TREE_VEC_LENGTH (declv
) == TREE_VEC_LENGTH (initv
));
4684 gcc_assert (TREE_VEC_LENGTH (declv
) == TREE_VEC_LENGTH (condv
));
4685 gcc_assert (TREE_VEC_LENGTH (declv
) == TREE_VEC_LENGTH (incrv
));
4686 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
4688 decl
= TREE_VEC_ELT (declv
, i
);
4689 init
= TREE_VEC_ELT (initv
, i
);
4690 cond
= TREE_VEC_ELT (condv
, i
);
4691 incr
= TREE_VEC_ELT (incrv
, i
);
4697 switch (TREE_CODE (init
))
4700 decl
= TREE_OPERAND (init
, 0);
4701 init
= TREE_OPERAND (init
, 1);
4704 if (TREE_CODE (TREE_OPERAND (init
, 1)) == NOP_EXPR
)
4706 decl
= TREE_OPERAND (init
, 0);
4707 init
= TREE_OPERAND (init
, 2);
4717 "expected iteration declaration or initialization");
4722 if (init
&& EXPR_HAS_LOCATION (init
))
4723 elocus
= EXPR_LOCATION (init
);
4727 error_at (elocus
, "missing controlling predicate");
4733 error_at (elocus
, "missing increment expression");
4737 TREE_VEC_ELT (declv
, i
) = decl
;
4738 TREE_VEC_ELT (initv
, i
) = init
;
4741 if (dependent_omp_for_p (declv
, initv
, condv
, incrv
))
4745 stmt
= make_node (OMP_FOR
);
4747 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
4749 /* This is really just a place-holder. We'll be decomposing this
4750 again and going through the cp_build_modify_expr path below when
4751 we instantiate the thing. */
4752 TREE_VEC_ELT (initv
, i
)
4753 = build2 (MODIFY_EXPR
, void_type_node
, TREE_VEC_ELT (declv
, i
),
4754 TREE_VEC_ELT (initv
, i
));
4757 TREE_TYPE (stmt
) = void_type_node
;
4758 OMP_FOR_INIT (stmt
) = initv
;
4759 OMP_FOR_COND (stmt
) = condv
;
4760 OMP_FOR_INCR (stmt
) = incrv
;
4761 OMP_FOR_BODY (stmt
) = body
;
4762 OMP_FOR_PRE_BODY (stmt
) = pre_body
;
4763 OMP_FOR_CLAUSES (stmt
) = clauses
;
4765 SET_EXPR_LOCATION (stmt
, locus
);
4766 return add_stmt (stmt
);
4769 if (processing_template_decl
)
4770 orig_incr
= make_tree_vec (TREE_VEC_LENGTH (incrv
));
4772 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); )
4774 decl
= TREE_VEC_ELT (declv
, i
);
4775 init
= TREE_VEC_ELT (initv
, i
);
4776 cond
= TREE_VEC_ELT (condv
, i
);
4777 incr
= TREE_VEC_ELT (incrv
, i
);
4779 TREE_VEC_ELT (orig_incr
, i
) = incr
;
4782 if (init
&& EXPR_HAS_LOCATION (init
))
4783 elocus
= EXPR_LOCATION (init
);
4787 error_at (elocus
, "expected iteration declaration or initialization");
4791 if (incr
&& TREE_CODE (incr
) == MODOP_EXPR
)
4794 TREE_VEC_ELT (orig_incr
, i
) = incr
;
4795 incr
= cp_build_modify_expr (TREE_OPERAND (incr
, 0),
4796 TREE_CODE (TREE_OPERAND (incr
, 1)),
4797 TREE_OPERAND (incr
, 2),
4798 tf_warning_or_error
);
4801 if (CLASS_TYPE_P (TREE_TYPE (decl
)))
4803 if (handle_omp_for_class_iterator (i
, locus
, declv
, initv
, condv
,
4804 incrv
, &body
, &pre_body
, clauses
))
4809 if (!INTEGRAL_TYPE_P (TREE_TYPE (decl
))
4810 && TREE_CODE (TREE_TYPE (decl
)) != POINTER_TYPE
)
4812 error_at (elocus
, "invalid type for iteration variable %qE", decl
);
4816 if (!processing_template_decl
)
4818 init
= fold_build_cleanup_point_expr (TREE_TYPE (init
), init
);
4819 init
= cp_build_modify_expr (decl
, NOP_EXPR
, init
, tf_warning_or_error
);
4822 init
= build2 (MODIFY_EXPR
, void_type_node
, decl
, init
);
4824 && TREE_SIDE_EFFECTS (cond
)
4825 && COMPARISON_CLASS_P (cond
)
4826 && !processing_template_decl
)
4828 tree t
= TREE_OPERAND (cond
, 0);
4829 if (TREE_SIDE_EFFECTS (t
)
4831 && (TREE_CODE (t
) != NOP_EXPR
4832 || TREE_OPERAND (t
, 0) != decl
))
4833 TREE_OPERAND (cond
, 0)
4834 = fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4836 t
= TREE_OPERAND (cond
, 1);
4837 if (TREE_SIDE_EFFECTS (t
)
4839 && (TREE_CODE (t
) != NOP_EXPR
4840 || TREE_OPERAND (t
, 0) != decl
))
4841 TREE_OPERAND (cond
, 1)
4842 = fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4844 if (decl
== error_mark_node
|| init
== error_mark_node
)
4847 TREE_VEC_ELT (declv
, i
) = decl
;
4848 TREE_VEC_ELT (initv
, i
) = init
;
4849 TREE_VEC_ELT (condv
, i
) = cond
;
4850 TREE_VEC_ELT (incrv
, i
) = incr
;
4854 if (IS_EMPTY_STMT (pre_body
))
4857 omp_for
= c_finish_omp_for (locus
, declv
, initv
, condv
, incrv
,
4860 if (omp_for
== NULL
)
4863 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INCR (omp_for
)); i
++)
4865 decl
= TREE_OPERAND (TREE_VEC_ELT (OMP_FOR_INIT (omp_for
), i
), 0);
4866 incr
= TREE_VEC_ELT (OMP_FOR_INCR (omp_for
), i
);
4868 if (TREE_CODE (incr
) != MODIFY_EXPR
)
4871 if (TREE_SIDE_EFFECTS (TREE_OPERAND (incr
, 1))
4872 && BINARY_CLASS_P (TREE_OPERAND (incr
, 1))
4873 && !processing_template_decl
)
4875 tree t
= TREE_OPERAND (TREE_OPERAND (incr
, 1), 0);
4876 if (TREE_SIDE_EFFECTS (t
)
4878 && (TREE_CODE (t
) != NOP_EXPR
4879 || TREE_OPERAND (t
, 0) != decl
))
4880 TREE_OPERAND (TREE_OPERAND (incr
, 1), 0)
4881 = fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4883 t
= TREE_OPERAND (TREE_OPERAND (incr
, 1), 1);
4884 if (TREE_SIDE_EFFECTS (t
)
4886 && (TREE_CODE (t
) != NOP_EXPR
4887 || TREE_OPERAND (t
, 0) != decl
))
4888 TREE_OPERAND (TREE_OPERAND (incr
, 1), 1)
4889 = fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4893 TREE_VEC_ELT (OMP_FOR_INCR (omp_for
), i
) = TREE_VEC_ELT (orig_incr
, i
);
4895 if (omp_for
!= NULL
)
4896 OMP_FOR_CLAUSES (omp_for
) = clauses
;
4901 finish_omp_atomic (enum tree_code code
, enum tree_code opcode
, tree lhs
,
4902 tree rhs
, tree v
, tree lhs1
, tree rhs1
)
4917 dependent_p
= false;
4920 /* Even in a template, we can detect invalid uses of the atomic
4921 pragma if neither LHS nor RHS is type-dependent. */
4922 if (processing_template_decl
)
4924 dependent_p
= (type_dependent_expression_p (lhs
)
4925 || (rhs
&& type_dependent_expression_p (rhs
))
4926 || (v
&& type_dependent_expression_p (v
))
4927 || (lhs1
&& type_dependent_expression_p (lhs1
))
4928 || (rhs1
&& type_dependent_expression_p (rhs1
)));
4931 lhs
= build_non_dependent_expr (lhs
);
4933 rhs
= build_non_dependent_expr (rhs
);
4935 v
= build_non_dependent_expr (v
);
4937 lhs1
= build_non_dependent_expr (lhs1
);
4939 rhs1
= build_non_dependent_expr (rhs1
);
4944 stmt
= c_finish_omp_atomic (input_location
, code
, opcode
, lhs
, rhs
,
4946 if (stmt
== error_mark_node
)
4949 if (processing_template_decl
)
4951 if (code
== OMP_ATOMIC_READ
)
4953 stmt
= build_min_nt_loc (EXPR_LOCATION (orig_lhs
),
4954 OMP_ATOMIC_READ
, orig_lhs
);
4955 stmt
= build2 (MODIFY_EXPR
, void_type_node
, orig_v
, stmt
);
4959 if (opcode
== NOP_EXPR
)
4960 stmt
= build2 (MODIFY_EXPR
, void_type_node
, orig_lhs
, orig_rhs
);
4962 stmt
= build2 (opcode
, void_type_node
, orig_lhs
, orig_rhs
);
4964 stmt
= build_min_nt_loc (EXPR_LOCATION (orig_rhs1
),
4965 COMPOUND_EXPR
, orig_rhs1
, stmt
);
4966 if (code
!= OMP_ATOMIC
)
4968 stmt
= build_min_nt_loc (EXPR_LOCATION (orig_lhs1
),
4969 code
, orig_lhs1
, stmt
);
4970 stmt
= build2 (MODIFY_EXPR
, void_type_node
, orig_v
, stmt
);
4973 stmt
= build2 (OMP_ATOMIC
, void_type_node
, integer_zero_node
, stmt
);
4979 finish_omp_barrier (void)
4981 tree fn
= builtin_decl_explicit (BUILT_IN_GOMP_BARRIER
);
4982 VEC(tree
,gc
) *vec
= make_tree_vector ();
4983 tree stmt
= finish_call_expr (fn
, &vec
, false, false, tf_warning_or_error
);
4984 release_tree_vector (vec
);
4985 finish_expr_stmt (stmt
);
4989 finish_omp_flush (void)
4991 tree fn
= builtin_decl_explicit (BUILT_IN_SYNC_SYNCHRONIZE
);
4992 VEC(tree
,gc
) *vec
= make_tree_vector ();
4993 tree stmt
= finish_call_expr (fn
, &vec
, false, false, tf_warning_or_error
);
4994 release_tree_vector (vec
);
4995 finish_expr_stmt (stmt
);
4999 finish_omp_taskwait (void)
5001 tree fn
= builtin_decl_explicit (BUILT_IN_GOMP_TASKWAIT
);
5002 VEC(tree
,gc
) *vec
= make_tree_vector ();
5003 tree stmt
= finish_call_expr (fn
, &vec
, false, false, tf_warning_or_error
);
5004 release_tree_vector (vec
);
5005 finish_expr_stmt (stmt
);
5009 finish_omp_taskyield (void)
5011 tree fn
= builtin_decl_explicit (BUILT_IN_GOMP_TASKYIELD
);
5012 VEC(tree
,gc
) *vec
= make_tree_vector ();
5013 tree stmt
= finish_call_expr (fn
, &vec
, false, false, tf_warning_or_error
);
5014 release_tree_vector (vec
);
5015 finish_expr_stmt (stmt
);
5018 /* Begin a __transaction_atomic or __transaction_relaxed statement.
5019 If PCOMPOUND is non-null, this is for a function-transaction-block, and we
5020 should create an extra compound stmt. */
5023 begin_transaction_stmt (location_t loc
, tree
*pcompound
, int flags
)
5028 *pcompound
= begin_compound_stmt (0);
5030 r
= build_stmt (loc
, TRANSACTION_EXPR
, NULL_TREE
);
5032 /* Only add the statement to the function if support enabled. */
5036 error_at (loc
, ((flags
& TM_STMT_ATTR_RELAXED
) != 0
5037 ? G_("%<__transaction_relaxed%> without "
5038 "transactional memory support enabled")
5039 : G_("%<__transaction_atomic%> without "
5040 "transactional memory support enabled")));
5042 TRANSACTION_EXPR_BODY (r
) = push_stmt_list ();
5046 /* End a __transaction_atomic or __transaction_relaxed statement.
5047 If COMPOUND_STMT is non-null, this is for a function-transaction-block,
5048 and we should end the compound. If NOEX is non-NULL, we wrap the body in
5049 a MUST_NOT_THROW_EXPR with NOEX as condition. */
5052 finish_transaction_stmt (tree stmt
, tree compound_stmt
, int flags
, tree noex
)
5054 TRANSACTION_EXPR_BODY (stmt
) = pop_stmt_list (TRANSACTION_EXPR_BODY (stmt
));
5055 TRANSACTION_EXPR_OUTER (stmt
) = (flags
& TM_STMT_ATTR_OUTER
) != 0;
5056 TRANSACTION_EXPR_RELAXED (stmt
) = (flags
& TM_STMT_ATTR_RELAXED
) != 0;
5057 TRANSACTION_EXPR_IS_STMT (stmt
) = 1;
5059 /* noexcept specifications are not allowed for function transactions. */
5060 gcc_assert (!(noex
&& compound_stmt
));
5063 tree body
= build_must_not_throw_expr (TRANSACTION_EXPR_BODY (stmt
),
5065 SET_EXPR_LOCATION (body
, EXPR_LOCATION (TRANSACTION_EXPR_BODY (stmt
)));
5066 TREE_SIDE_EFFECTS (body
) = 1;
5067 TRANSACTION_EXPR_BODY (stmt
) = body
;
5071 finish_compound_stmt (compound_stmt
);
5075 /* Build a __transaction_atomic or __transaction_relaxed expression. If
5076 NOEX is non-NULL, we wrap the body in a MUST_NOT_THROW_EXPR with NOEX as
5080 build_transaction_expr (location_t loc
, tree expr
, int flags
, tree noex
)
5085 expr
= build_must_not_throw_expr (expr
, noex
);
5086 SET_EXPR_LOCATION (expr
, loc
);
5087 TREE_SIDE_EFFECTS (expr
) = 1;
5089 ret
= build1 (TRANSACTION_EXPR
, TREE_TYPE (expr
), expr
);
5090 if (flags
& TM_STMT_ATTR_RELAXED
)
5091 TRANSACTION_EXPR_RELAXED (ret
) = 1;
5092 SET_EXPR_LOCATION (ret
, loc
);
5097 init_cp_semantics (void)
5101 /* Build a STATIC_ASSERT for a static assertion with the condition
5102 CONDITION and the message text MESSAGE. LOCATION is the location
5103 of the static assertion in the source code. When MEMBER_P, this
5104 static assertion is a member of a class. */
5106 finish_static_assert (tree condition
, tree message
, location_t location
,
5109 if (check_for_bare_parameter_packs (condition
))
5110 condition
= error_mark_node
;
5112 if (type_dependent_expression_p (condition
)
5113 || value_dependent_expression_p (condition
))
5115 /* We're in a template; build a STATIC_ASSERT and put it in
5119 assertion
= make_node (STATIC_ASSERT
);
5120 STATIC_ASSERT_CONDITION (assertion
) = condition
;
5121 STATIC_ASSERT_MESSAGE (assertion
) = message
;
5122 STATIC_ASSERT_SOURCE_LOCATION (assertion
) = location
;
5125 maybe_add_class_template_decl_list (current_class_type
,
5129 add_stmt (assertion
);
5134 /* Fold the expression and convert it to a boolean value. */
5135 condition
= fold_non_dependent_expr (condition
);
5136 condition
= cp_convert (boolean_type_node
, condition
, tf_warning_or_error
);
5137 condition
= maybe_constant_value (condition
);
5139 if (TREE_CODE (condition
) == INTEGER_CST
&& !integer_zerop (condition
))
5140 /* Do nothing; the condition is satisfied. */
5144 location_t saved_loc
= input_location
;
5146 input_location
= location
;
5147 if (TREE_CODE (condition
) == INTEGER_CST
5148 && integer_zerop (condition
))
5149 /* Report the error. */
5150 error ("static assertion failed: %s", TREE_STRING_POINTER (message
));
5151 else if (condition
&& condition
!= error_mark_node
)
5153 error ("non-constant condition for static assertion");
5154 cxx_constant_value (condition
);
5156 input_location
= saved_loc
;
5160 /* Implements the C++0x decltype keyword. Returns the type of EXPR,
5161 suitable for use as a type-specifier.
5163 ID_EXPRESSION_OR_MEMBER_ACCESS_P is true when EXPR was parsed as an
5164 id-expression or a class member access, FALSE when it was parsed as
5165 a full expression. */
5168 finish_decltype_type (tree expr
, bool id_expression_or_member_access_p
,
5169 tsubst_flags_t complain
)
5171 tree type
= NULL_TREE
;
5173 if (!expr
|| error_operand_p (expr
))
5174 return error_mark_node
;
5177 || TREE_CODE (expr
) == TYPE_DECL
5178 || (TREE_CODE (expr
) == BIT_NOT_EXPR
5179 && TYPE_P (TREE_OPERAND (expr
, 0))))
5181 if (complain
& tf_error
)
5182 error ("argument to decltype must be an expression");
5183 return error_mark_node
;
5186 /* FIXME instantiation-dependent */
5187 if (type_dependent_expression_p (expr
)
5188 /* In a template, a COMPONENT_REF has an IDENTIFIER_NODE for op1 even
5189 if it isn't dependent, so that we can check access control at
5190 instantiation time, so defer the decltype as well (PR 42277). */
5191 || (id_expression_or_member_access_p
5192 && processing_template_decl
5193 && TREE_CODE (expr
) == COMPONENT_REF
))
5195 type
= cxx_make_type (DECLTYPE_TYPE
);
5196 DECLTYPE_TYPE_EXPR (type
) = expr
;
5197 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type
)
5198 = id_expression_or_member_access_p
;
5199 SET_TYPE_STRUCTURAL_EQUALITY (type
);
5204 /* The type denoted by decltype(e) is defined as follows: */
5206 expr
= resolve_nondeduced_context (expr
);
5208 if (type_unknown_p (expr
))
5210 if (complain
& tf_error
)
5211 error ("decltype cannot resolve address of overloaded function");
5212 return error_mark_node
;
5215 if (invalid_nonstatic_memfn_p (expr
, complain
))
5216 return error_mark_node
;
5218 /* To get the size of a static data member declared as an array of
5219 unknown bound, we need to instantiate it. */
5220 if (TREE_CODE (expr
) == VAR_DECL
5221 && VAR_HAD_UNKNOWN_BOUND (expr
)
5222 && DECL_TEMPLATE_INSTANTIATION (expr
))
5223 instantiate_decl (expr
, /*defer_ok*/true, /*expl_inst_mem*/false);
5225 if (id_expression_or_member_access_p
)
5227 /* If e is an id-expression or a class member access (5.2.5
5228 [expr.ref]), decltype(e) is defined as the type of the entity
5229 named by e. If there is no such entity, or e names a set of
5230 overloaded functions, the program is ill-formed. */
5231 if (TREE_CODE (expr
) == IDENTIFIER_NODE
)
5232 expr
= lookup_name (expr
);
5234 if (TREE_CODE (expr
) == INDIRECT_REF
)
5235 /* This can happen when the expression is, e.g., "a.b". Just
5236 look at the underlying operand. */
5237 expr
= TREE_OPERAND (expr
, 0);
5239 if (TREE_CODE (expr
) == OFFSET_REF
5240 || TREE_CODE (expr
) == MEMBER_REF
)
5241 /* We're only interested in the field itself. If it is a
5242 BASELINK, we will need to see through it in the next
5244 expr
= TREE_OPERAND (expr
, 1);
5246 if (BASELINK_P (expr
))
5247 /* See through BASELINK nodes to the underlying function. */
5248 expr
= BASELINK_FUNCTIONS (expr
);
5250 switch (TREE_CODE (expr
))
5253 if (DECL_BIT_FIELD_TYPE (expr
))
5255 type
= DECL_BIT_FIELD_TYPE (expr
);
5258 /* Fall through for fields that aren't bitfields. */
5265 case TEMPLATE_PARM_INDEX
:
5266 expr
= mark_type_use (expr
);
5267 type
= TREE_TYPE (expr
);
5271 type
= error_mark_node
;
5275 mark_type_use (expr
);
5276 type
= is_bitfield_expr_with_lowered_type (expr
);
5278 type
= TREE_TYPE (TREE_OPERAND (expr
, 1));
5286 /* We can get here when the id-expression refers to an
5287 enumerator or non-type template parameter. */
5288 type
= TREE_TYPE (expr
);
5293 return error_mark_node
;
5298 /* Within a lambda-expression:
5300 Every occurrence of decltype((x)) where x is a possibly
5301 parenthesized id-expression that names an entity of
5302 automatic storage duration is treated as if x were
5303 transformed into an access to a corresponding data member
5304 of the closure type that would have been declared if x
5305 were a use of the denoted entity. */
5306 if (outer_automatic_var_p (expr
)
5307 && current_function_decl
5308 && LAMBDA_FUNCTION_P (current_function_decl
))
5309 type
= capture_decltype (expr
);
5310 else if (error_operand_p (expr
))
5311 type
= error_mark_node
;
5312 else if (expr
== current_class_ptr
)
5313 /* If the expression is just "this", we want the
5314 cv-unqualified pointer for the "this" type. */
5315 type
= TYPE_MAIN_VARIANT (TREE_TYPE (expr
));
5318 /* Otherwise, where T is the type of e, if e is an lvalue,
5319 decltype(e) is defined as T&; if an xvalue, T&&; otherwise, T. */
5320 cp_lvalue_kind clk
= lvalue_kind (expr
);
5321 type
= unlowered_expr_type (expr
);
5322 gcc_assert (TREE_CODE (type
) != REFERENCE_TYPE
);
5323 if (clk
!= clk_none
&& !(clk
& clk_class
))
5324 type
= cp_build_reference_type (type
, (clk
& clk_rvalueref
));
5331 /* Called from trait_expr_value to evaluate either __has_nothrow_assign or
5332 __has_nothrow_copy, depending on assign_p. */
5335 classtype_has_nothrow_assign_or_copy_p (tree type
, bool assign_p
)
5342 ix
= lookup_fnfields_1 (type
, ansi_assopname (NOP_EXPR
));
5345 fns
= VEC_index (tree
, CLASSTYPE_METHOD_VEC (type
), ix
);
5347 else if (TYPE_HAS_COPY_CTOR (type
))
5349 /* If construction of the copy constructor was postponed, create
5351 if (CLASSTYPE_LAZY_COPY_CTOR (type
))
5352 lazily_declare_fn (sfk_copy_constructor
, type
);
5353 if (CLASSTYPE_LAZY_MOVE_CTOR (type
))
5354 lazily_declare_fn (sfk_move_constructor
, type
);
5355 fns
= CLASSTYPE_CONSTRUCTORS (type
);
5360 for (; fns
; fns
= OVL_NEXT (fns
))
5362 tree fn
= OVL_CURRENT (fns
);
5366 if (copy_fn_p (fn
) == 0)
5369 else if (copy_fn_p (fn
) <= 0)
5372 if (!TYPE_NOTHROW_P (TREE_TYPE (fn
)))
5379 /* Actually evaluates the trait. */
5382 trait_expr_value (cp_trait_kind kind
, tree type1
, tree type2
)
5384 enum tree_code type_code1
;
5387 type_code1
= TREE_CODE (type1
);
5391 case CPTK_HAS_NOTHROW_ASSIGN
:
5392 type1
= strip_array_types (type1
);
5393 return (!CP_TYPE_CONST_P (type1
) && type_code1
!= REFERENCE_TYPE
5394 && (trait_expr_value (CPTK_HAS_TRIVIAL_ASSIGN
, type1
, type2
)
5395 || (CLASS_TYPE_P (type1
)
5396 && classtype_has_nothrow_assign_or_copy_p (type1
,
5399 case CPTK_HAS_TRIVIAL_ASSIGN
:
5400 /* ??? The standard seems to be missing the "or array of such a class
5401 type" wording for this trait. */
5402 type1
= strip_array_types (type1
);
5403 return (!CP_TYPE_CONST_P (type1
) && type_code1
!= REFERENCE_TYPE
5404 && (trivial_type_p (type1
)
5405 || (CLASS_TYPE_P (type1
)
5406 && TYPE_HAS_TRIVIAL_COPY_ASSIGN (type1
))));
5408 case CPTK_HAS_NOTHROW_CONSTRUCTOR
:
5409 type1
= strip_array_types (type1
);
5410 return (trait_expr_value (CPTK_HAS_TRIVIAL_CONSTRUCTOR
, type1
, type2
)
5411 || (CLASS_TYPE_P (type1
)
5412 && (t
= locate_ctor (type1
))
5413 && TYPE_NOTHROW_P (TREE_TYPE (t
))));
5415 case CPTK_HAS_TRIVIAL_CONSTRUCTOR
:
5416 type1
= strip_array_types (type1
);
5417 return (trivial_type_p (type1
)
5418 || (CLASS_TYPE_P (type1
) && TYPE_HAS_TRIVIAL_DFLT (type1
)));
5420 case CPTK_HAS_NOTHROW_COPY
:
5421 type1
= strip_array_types (type1
);
5422 return (trait_expr_value (CPTK_HAS_TRIVIAL_COPY
, type1
, type2
)
5423 || (CLASS_TYPE_P (type1
)
5424 && classtype_has_nothrow_assign_or_copy_p (type1
, false)));
5426 case CPTK_HAS_TRIVIAL_COPY
:
5427 /* ??? The standard seems to be missing the "or array of such a class
5428 type" wording for this trait. */
5429 type1
= strip_array_types (type1
);
5430 return (trivial_type_p (type1
) || type_code1
== REFERENCE_TYPE
5431 || (CLASS_TYPE_P (type1
) && TYPE_HAS_TRIVIAL_COPY_CTOR (type1
)));
5433 case CPTK_HAS_TRIVIAL_DESTRUCTOR
:
5434 type1
= strip_array_types (type1
);
5435 return (trivial_type_p (type1
) || type_code1
== REFERENCE_TYPE
5436 || (CLASS_TYPE_P (type1
)
5437 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type1
)));
5439 case CPTK_HAS_VIRTUAL_DESTRUCTOR
:
5440 return type_has_virtual_destructor (type1
);
5442 case CPTK_IS_ABSTRACT
:
5443 return (ABSTRACT_CLASS_TYPE_P (type1
));
5445 case CPTK_IS_BASE_OF
:
5446 return (NON_UNION_CLASS_TYPE_P (type1
) && NON_UNION_CLASS_TYPE_P (type2
)
5447 && DERIVED_FROM_P (type1
, type2
));
5450 return (NON_UNION_CLASS_TYPE_P (type1
));
5452 case CPTK_IS_CONVERTIBLE_TO
:
5457 return (NON_UNION_CLASS_TYPE_P (type1
) && CLASSTYPE_EMPTY_P (type1
));
5460 return (type_code1
== ENUMERAL_TYPE
);
5463 return (CLASS_TYPE_P (type1
) && CLASSTYPE_FINAL (type1
));
5465 case CPTK_IS_LITERAL_TYPE
:
5466 return (literal_type_p (type1
));
5469 return (pod_type_p (type1
));
5471 case CPTK_IS_POLYMORPHIC
:
5472 return (CLASS_TYPE_P (type1
) && TYPE_POLYMORPHIC_P (type1
));
5474 case CPTK_IS_STD_LAYOUT
:
5475 return (std_layout_type_p (type1
));
5477 case CPTK_IS_TRIVIAL
:
5478 return (trivial_type_p (type1
));
5481 return (type_code1
== UNION_TYPE
);
5489 /* If TYPE is an array of unknown bound, or (possibly cv-qualified)
5490 void, or a complete type, returns it, otherwise NULL_TREE. */
5493 check_trait_type (tree type
)
5495 if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
)
5496 && COMPLETE_TYPE_P (TREE_TYPE (type
)))
5499 if (VOID_TYPE_P (type
))
5502 return complete_type_or_else (strip_array_types (type
), NULL_TREE
);
5505 /* Process a trait expression. */
5508 finish_trait_expr (cp_trait_kind kind
, tree type1
, tree type2
)
5510 gcc_assert (kind
== CPTK_HAS_NOTHROW_ASSIGN
5511 || kind
== CPTK_HAS_NOTHROW_CONSTRUCTOR
5512 || kind
== CPTK_HAS_NOTHROW_COPY
5513 || kind
== CPTK_HAS_TRIVIAL_ASSIGN
5514 || kind
== CPTK_HAS_TRIVIAL_CONSTRUCTOR
5515 || kind
== CPTK_HAS_TRIVIAL_COPY
5516 || kind
== CPTK_HAS_TRIVIAL_DESTRUCTOR
5517 || kind
== CPTK_HAS_VIRTUAL_DESTRUCTOR
5518 || kind
== CPTK_IS_ABSTRACT
5519 || kind
== CPTK_IS_BASE_OF
5520 || kind
== CPTK_IS_CLASS
5521 || kind
== CPTK_IS_CONVERTIBLE_TO
5522 || kind
== CPTK_IS_EMPTY
5523 || kind
== CPTK_IS_ENUM
5524 || kind
== CPTK_IS_FINAL
5525 || kind
== CPTK_IS_LITERAL_TYPE
5526 || kind
== CPTK_IS_POD
5527 || kind
== CPTK_IS_POLYMORPHIC
5528 || kind
== CPTK_IS_STD_LAYOUT
5529 || kind
== CPTK_IS_TRIVIAL
5530 || kind
== CPTK_IS_UNION
);
5532 if (kind
== CPTK_IS_CONVERTIBLE_TO
)
5534 sorry ("__is_convertible_to");
5535 return error_mark_node
;
5538 if (type1
== error_mark_node
5539 || ((kind
== CPTK_IS_BASE_OF
|| kind
== CPTK_IS_CONVERTIBLE_TO
)
5540 && type2
== error_mark_node
))
5541 return error_mark_node
;
5543 if (processing_template_decl
)
5545 tree trait_expr
= make_node (TRAIT_EXPR
);
5546 TREE_TYPE (trait_expr
) = boolean_type_node
;
5547 TRAIT_EXPR_TYPE1 (trait_expr
) = type1
;
5548 TRAIT_EXPR_TYPE2 (trait_expr
) = type2
;
5549 TRAIT_EXPR_KIND (trait_expr
) = kind
;
5555 case CPTK_HAS_NOTHROW_ASSIGN
:
5556 case CPTK_HAS_TRIVIAL_ASSIGN
:
5557 case CPTK_HAS_NOTHROW_CONSTRUCTOR
:
5558 case CPTK_HAS_TRIVIAL_CONSTRUCTOR
:
5559 case CPTK_HAS_NOTHROW_COPY
:
5560 case CPTK_HAS_TRIVIAL_COPY
:
5561 case CPTK_HAS_TRIVIAL_DESTRUCTOR
:
5562 case CPTK_HAS_VIRTUAL_DESTRUCTOR
:
5563 case CPTK_IS_ABSTRACT
:
5566 case CPTK_IS_LITERAL_TYPE
:
5568 case CPTK_IS_POLYMORPHIC
:
5569 case CPTK_IS_STD_LAYOUT
:
5570 case CPTK_IS_TRIVIAL
:
5571 if (!check_trait_type (type1
))
5572 return error_mark_node
;
5575 case CPTK_IS_BASE_OF
:
5576 if (NON_UNION_CLASS_TYPE_P (type1
) && NON_UNION_CLASS_TYPE_P (type2
)
5577 && !same_type_ignoring_top_level_qualifiers_p (type1
, type2
)
5578 && !complete_type_or_else (type2
, NULL_TREE
))
5579 /* We already issued an error. */
5580 return error_mark_node
;
5588 case CPTK_IS_CONVERTIBLE_TO
:
5593 return (trait_expr_value (kind
, type1
, type2
)
5594 ? boolean_true_node
: boolean_false_node
);
5597 /* Do-nothing variants of functions to handle pragma FLOAT_CONST_DECIMAL64,
5598 which is ignored for C++. */
5601 set_float_const_decimal64 (void)
5606 clear_float_const_decimal64 (void)
5611 float_const_decimal64_p (void)
5617 /* Return true if T is a literal type. */
5620 literal_type_p (tree t
)
5622 if (SCALAR_TYPE_P (t
)
5623 || TREE_CODE (t
) == VECTOR_TYPE
5624 || TREE_CODE (t
) == REFERENCE_TYPE
)
5626 if (CLASS_TYPE_P (t
))
5628 t
= complete_type (t
);
5629 gcc_assert (COMPLETE_TYPE_P (t
) || errorcount
);
5630 return CLASSTYPE_LITERAL_P (t
);
5632 if (TREE_CODE (t
) == ARRAY_TYPE
)
5633 return literal_type_p (strip_array_types (t
));
5637 /* If DECL is a variable declared `constexpr', require its type
5638 be literal. Return the DECL if OK, otherwise NULL. */
5641 ensure_literal_type_for_constexpr_object (tree decl
)
5643 tree type
= TREE_TYPE (decl
);
5644 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_DECLARED_CONSTEXPR_P (decl
)
5645 && !processing_template_decl
)
5647 if (CLASS_TYPE_P (type
) && !COMPLETE_TYPE_P (complete_type (type
)))
5648 /* Don't complain here, we'll complain about incompleteness
5649 when we try to initialize the variable. */;
5650 else if (!literal_type_p (type
))
5652 error ("the type %qT of constexpr variable %qD is not literal",
5654 explain_non_literal_class (type
);
5661 /* Representation of entries in the constexpr function definition table. */
5663 typedef struct GTY(()) constexpr_fundef
{
5668 /* This table holds all constexpr function definitions seen in
5669 the current translation unit. */
5671 static GTY ((param_is (constexpr_fundef
))) htab_t constexpr_fundef_table
;
5673 /* Utility function used for managing the constexpr function table.
5674 Return true if the entries pointed to by P and Q are for the
5675 same constexpr function. */
5678 constexpr_fundef_equal (const void *p
, const void *q
)
5680 const constexpr_fundef
*lhs
= (const constexpr_fundef
*) p
;
5681 const constexpr_fundef
*rhs
= (const constexpr_fundef
*) q
;
5682 return lhs
->decl
== rhs
->decl
;
5685 /* Utility function used for managing the constexpr function table.
5686 Return a hash value for the entry pointed to by Q. */
5688 static inline hashval_t
5689 constexpr_fundef_hash (const void *p
)
5691 const constexpr_fundef
*fundef
= (const constexpr_fundef
*) p
;
5692 return DECL_UID (fundef
->decl
);
5695 /* Return a previously saved definition of function FUN. */
5697 static constexpr_fundef
*
5698 retrieve_constexpr_fundef (tree fun
)
5700 constexpr_fundef fundef
= { NULL
, NULL
};
5701 if (constexpr_fundef_table
== NULL
)
5705 return (constexpr_fundef
*) htab_find (constexpr_fundef_table
, &fundef
);
5708 /* Check whether the parameter and return types of FUN are valid for a
5709 constexpr function, and complain if COMPLAIN. */
5712 is_valid_constexpr_fn (tree fun
, bool complain
)
5714 tree parm
= FUNCTION_FIRST_USER_PARM (fun
);
5716 for (; parm
!= NULL
; parm
= TREE_CHAIN (parm
))
5717 if (!literal_type_p (TREE_TYPE (parm
)))
5722 error ("invalid type for parameter %d of constexpr "
5723 "function %q+#D", DECL_PARM_INDEX (parm
), fun
);
5724 explain_non_literal_class (TREE_TYPE (parm
));
5728 if (!DECL_CONSTRUCTOR_P (fun
))
5730 tree rettype
= TREE_TYPE (TREE_TYPE (fun
));
5731 if (!literal_type_p (rettype
))
5736 error ("invalid return type %qT of constexpr function %q+D",
5738 explain_non_literal_class (rettype
);
5742 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
5743 && !CLASSTYPE_LITERAL_P (DECL_CONTEXT (fun
)))
5748 error ("enclosing class of constexpr non-static member "
5749 "function %q+#D is not a literal type", fun
);
5750 explain_non_literal_class (DECL_CONTEXT (fun
));
5754 else if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fun
)))
5758 error ("%q#T has virtual base classes", DECL_CONTEXT (fun
));
5764 /* Subroutine of build_constexpr_constructor_member_initializers.
5765 The expression tree T represents a data member initialization
5766 in a (constexpr) constructor definition. Build a pairing of
5767 the data member with its initializer, and prepend that pair
5768 to the existing initialization pair INITS. */
5771 build_data_member_initialization (tree t
, VEC(constructor_elt
,gc
) **vec
)
5774 if (TREE_CODE (t
) == CLEANUP_POINT_EXPR
)
5775 t
= TREE_OPERAND (t
, 0);
5776 if (TREE_CODE (t
) == EXPR_STMT
)
5777 t
= TREE_OPERAND (t
, 0);
5778 if (t
== error_mark_node
)
5780 if (TREE_CODE (t
) == STATEMENT_LIST
)
5782 tree_stmt_iterator i
;
5783 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
5785 if (! build_data_member_initialization (tsi_stmt (i
), vec
))
5790 if (TREE_CODE (t
) == CLEANUP_STMT
)
5792 /* We can't see a CLEANUP_STMT in a constructor for a literal class,
5793 but we can in a constexpr constructor for a non-literal class. Just
5794 ignore it; either all the initialization will be constant, in which
5795 case the cleanup can't run, or it can't be constexpr.
5796 Still recurse into CLEANUP_BODY. */
5797 return build_data_member_initialization (CLEANUP_BODY (t
), vec
);
5799 if (TREE_CODE (t
) == CONVERT_EXPR
)
5800 t
= TREE_OPERAND (t
, 0);
5801 if (TREE_CODE (t
) == INIT_EXPR
5802 || TREE_CODE (t
) == MODIFY_EXPR
)
5804 member
= TREE_OPERAND (t
, 0);
5805 init
= unshare_expr (TREE_OPERAND (t
, 1));
5809 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
5810 member
= CALL_EXPR_ARG (t
, 0);
5811 /* We don't use build_cplus_new here because it complains about
5812 abstract bases. Leaving the call unwrapped means that it has the
5813 wrong type, but cxx_eval_constant_expression doesn't care. */
5814 init
= unshare_expr (t
);
5816 if (TREE_CODE (member
) == INDIRECT_REF
)
5817 member
= TREE_OPERAND (member
, 0);
5818 if (TREE_CODE (member
) == NOP_EXPR
)
5822 if (TREE_CODE (op
) == ADDR_EXPR
)
5824 gcc_assert (same_type_ignoring_top_level_qualifiers_p
5825 (TREE_TYPE (TREE_TYPE (op
)),
5826 TREE_TYPE (TREE_TYPE (member
))));
5827 /* Initializing a cv-qualified member; we need to look through
5831 else if (op
== current_class_ptr
5832 && (same_type_ignoring_top_level_qualifiers_p
5833 (TREE_TYPE (TREE_TYPE (member
)),
5834 current_class_type
)))
5835 /* Delegating constructor. */
5839 /* This is an initializer for an empty base; keep it for now so
5840 we can check it in cxx_eval_bare_aggregate. */
5841 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member
))));
5844 if (TREE_CODE (member
) == ADDR_EXPR
)
5845 member
= TREE_OPERAND (member
, 0);
5846 if (TREE_CODE (member
) == COMPONENT_REF
5847 /* If we're initializing a member of a subaggregate, it's a vtable
5848 pointer. Leave it as COMPONENT_REF so we remember the path to get
5850 && TREE_CODE (TREE_OPERAND (member
, 0)) != COMPONENT_REF
)
5851 member
= TREE_OPERAND (member
, 1);
5852 CONSTRUCTOR_APPEND_ELT (*vec
, member
, init
);
5856 /* Make sure that there are no statements after LAST in the constructor
5857 body represented by LIST. */
5860 check_constexpr_ctor_body (tree last
, tree list
)
5863 if (TREE_CODE (list
) == STATEMENT_LIST
)
5865 tree_stmt_iterator i
= tsi_last (list
);
5866 for (; !tsi_end_p (i
); tsi_prev (&i
))
5868 tree t
= tsi_stmt (i
);
5871 if (TREE_CODE (t
) == BIND_EXPR
)
5873 if (!check_constexpr_ctor_body (last
, BIND_EXPR_BODY (t
)))
5878 /* We currently allow typedefs and static_assert.
5879 FIXME allow them in the standard, too. */
5880 if (TREE_CODE (t
) != STATIC_ASSERT
)
5887 else if (list
!= last
5888 && TREE_CODE (list
) != STATIC_ASSERT
)
5892 error ("constexpr constructor does not have empty body");
5893 DECL_DECLARED_CONSTEXPR_P (current_function_decl
) = false;
5898 /* Build compile-time evalable representations of member-initializer list
5899 for a constexpr constructor. */
5902 build_constexpr_constructor_member_initializers (tree type
, tree body
)
5904 VEC(constructor_elt
,gc
) *vec
= NULL
;
5906 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
5907 || TREE_CODE (body
) == EH_SPEC_BLOCK
)
5908 body
= TREE_OPERAND (body
, 0);
5909 if (TREE_CODE (body
) == STATEMENT_LIST
)
5910 body
= STATEMENT_LIST_HEAD (body
)->stmt
;
5911 body
= BIND_EXPR_BODY (body
);
5912 if (TREE_CODE (body
) == CLEANUP_POINT_EXPR
)
5914 body
= TREE_OPERAND (body
, 0);
5915 if (TREE_CODE (body
) == EXPR_STMT
)
5916 body
= TREE_OPERAND (body
, 0);
5917 if (TREE_CODE (body
) == INIT_EXPR
5918 && (same_type_ignoring_top_level_qualifiers_p
5919 (TREE_TYPE (TREE_OPERAND (body
, 0)),
5920 current_class_type
)))
5923 return TREE_OPERAND (body
, 1);
5925 ok
= build_data_member_initialization (body
, &vec
);
5927 else if (TREE_CODE (body
) == STATEMENT_LIST
)
5929 tree_stmt_iterator i
;
5930 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
5932 ok
= build_data_member_initialization (tsi_stmt (i
), &vec
);
5937 else if (TREE_CODE (body
) == TRY_BLOCK
)
5939 error ("body of %<constexpr%> constructor cannot be "
5940 "a function-try-block");
5941 return error_mark_node
;
5943 else if (EXPR_P (body
))
5944 ok
= build_data_member_initialization (body
, &vec
);
5946 gcc_assert (errorcount
> 0);
5949 if (VEC_length (constructor_elt
, vec
) > 0)
5951 /* In a delegating constructor, return the target. */
5952 constructor_elt
*ce
= VEC_index (constructor_elt
, vec
, 0);
5953 if (ce
->index
== current_class_ptr
)
5956 VEC_free (constructor_elt
, gc
, vec
);
5960 return build_constructor (type
, vec
);
5963 return error_mark_node
;
5966 /* Subroutine of register_constexpr_fundef. BODY is the body of a function
5967 declared to be constexpr, or a sub-statement thereof. Returns the
5968 return value if suitable, error_mark_node for a statement not allowed in
5969 a constexpr function, or NULL_TREE if no return value was found. */
5972 constexpr_fn_retval (tree body
)
5974 switch (TREE_CODE (body
))
5976 case STATEMENT_LIST
:
5978 tree_stmt_iterator i
;
5979 tree expr
= NULL_TREE
;
5980 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
5982 tree s
= constexpr_fn_retval (tsi_stmt (i
));
5983 if (s
== error_mark_node
)
5984 return error_mark_node
;
5985 else if (s
== NULL_TREE
)
5986 /* Keep iterating. */;
5988 /* Multiple return statements. */
5989 return error_mark_node
;
5997 return unshare_expr (TREE_OPERAND (body
, 0));
6000 if (TREE_CODE (DECL_EXPR_DECL (body
)) == USING_DECL
)
6002 return error_mark_node
;
6004 case CLEANUP_POINT_EXPR
:
6005 return constexpr_fn_retval (TREE_OPERAND (body
, 0));
6011 return error_mark_node
;
6015 /* Subroutine of register_constexpr_fundef. BODY is the DECL_SAVED_TREE of
6016 FUN; do the necessary transformations to turn it into a single expression
6017 that we can store in the hash table. */
6020 massage_constexpr_body (tree fun
, tree body
)
6022 if (DECL_CONSTRUCTOR_P (fun
))
6023 body
= build_constexpr_constructor_member_initializers
6024 (DECL_CONTEXT (fun
), body
);
6027 if (TREE_CODE (body
) == EH_SPEC_BLOCK
)
6028 body
= EH_SPEC_STMTS (body
);
6029 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
6030 body
= TREE_OPERAND (body
, 0);
6031 if (TREE_CODE (body
) == BIND_EXPR
)
6032 body
= BIND_EXPR_BODY (body
);
6033 body
= constexpr_fn_retval (body
);
6038 /* FUN is a constexpr constructor with massaged body BODY. Return true
6039 if some bases/fields are uninitialized, and complain if COMPLAIN. */
6042 cx_check_missing_mem_inits (tree fun
, tree body
, bool complain
)
6049 if (TREE_CODE (body
) != CONSTRUCTOR
)
6052 nelts
= CONSTRUCTOR_NELTS (body
);
6053 ctype
= DECL_CONTEXT (fun
);
6054 field
= TYPE_FIELDS (ctype
);
6056 if (TREE_CODE (ctype
) == UNION_TYPE
)
6058 if (nelts
== 0 && next_initializable_field (field
))
6061 error ("%<constexpr%> constructor for union %qT must "
6062 "initialize exactly one non-static data member", ctype
);
6069 for (i
= 0; i
<= nelts
; ++i
)
6076 index
= CONSTRUCTOR_ELT (body
, i
)->index
;
6077 /* Skip base and vtable inits. */
6078 if (TREE_CODE (index
) != FIELD_DECL
)
6081 for (; field
!= index
; field
= DECL_CHAIN (field
))
6084 if (TREE_CODE (field
) != FIELD_DECL
6085 || (DECL_C_BIT_FIELD (field
) && !DECL_NAME (field
)))
6087 ftype
= strip_array_types (TREE_TYPE (field
));
6088 if (type_has_constexpr_default_constructor (ftype
))
6090 /* It's OK to skip a member with a trivial constexpr ctor.
6091 A constexpr ctor that isn't trivial should have been
6093 gcc_checking_assert (!TYPE_HAS_COMPLEX_DFLT (ftype
)
6094 || errorcount
!= 0);
6099 error ("uninitialized member %qD in %<constexpr%> constructor",
6103 if (field
== NULL_TREE
)
6105 field
= DECL_CHAIN (field
);
6111 /* We are processing the definition of the constexpr function FUN.
6112 Check that its BODY fulfills the propriate requirements and
6113 enter it in the constexpr function definition table.
6114 For constructor BODY is actually the TREE_LIST of the
6115 member-initializer list. */
6118 register_constexpr_fundef (tree fun
, tree body
)
6120 constexpr_fundef entry
;
6121 constexpr_fundef
**slot
;
6123 if (!is_valid_constexpr_fn (fun
, !DECL_GENERATED_P (fun
)))
6126 body
= massage_constexpr_body (fun
, body
);
6127 if (body
== NULL_TREE
|| body
== error_mark_node
)
6129 if (!DECL_CONSTRUCTOR_P (fun
))
6130 error ("body of constexpr function %qD not a return-statement", fun
);
6134 if (!potential_rvalue_constant_expression (body
))
6136 if (!DECL_GENERATED_P (fun
))
6137 require_potential_rvalue_constant_expression (body
);
6141 if (DECL_CONSTRUCTOR_P (fun
)
6142 && cx_check_missing_mem_inits (fun
, body
, !DECL_GENERATED_P (fun
)))
6145 /* Create the constexpr function table if necessary. */
6146 if (constexpr_fundef_table
== NULL
)
6147 constexpr_fundef_table
= htab_create_ggc (101,
6148 constexpr_fundef_hash
,
6149 constexpr_fundef_equal
,
6153 slot
= (constexpr_fundef
**)
6154 htab_find_slot (constexpr_fundef_table
, &entry
, INSERT
);
6156 gcc_assert (*slot
== NULL
);
6157 *slot
= ggc_alloc_constexpr_fundef ();
6163 /* FUN is a non-constexpr function called in a context that requires a
6164 constant expression. If it comes from a constexpr template, explain why
6165 the instantiation isn't constexpr. */
6168 explain_invalid_constexpr_fn (tree fun
)
6170 static struct pointer_set_t
*diagnosed
;
6172 location_t save_loc
;
6173 /* Only diagnose defaulted functions or instantiations. */
6174 if (!DECL_DEFAULTED_FN (fun
)
6175 && !is_instantiation_of_constexpr (fun
))
6177 if (diagnosed
== NULL
)
6178 diagnosed
= pointer_set_create ();
6179 if (pointer_set_insert (diagnosed
, fun
) != 0)
6180 /* Already explained. */
6183 save_loc
= input_location
;
6184 input_location
= DECL_SOURCE_LOCATION (fun
);
6185 inform (0, "%q+D is not usable as a constexpr function because:", fun
);
6186 /* First check the declaration. */
6187 if (is_valid_constexpr_fn (fun
, true))
6189 /* Then if it's OK, the body. */
6190 if (DECL_DEFAULTED_FN (fun
))
6191 explain_implicit_non_constexpr (fun
);
6194 body
= massage_constexpr_body (fun
, DECL_SAVED_TREE (fun
));
6195 require_potential_rvalue_constant_expression (body
);
6196 if (DECL_CONSTRUCTOR_P (fun
))
6197 cx_check_missing_mem_inits (fun
, body
, true);
6200 input_location
= save_loc
;
6203 /* Objects of this type represent calls to constexpr functions
6204 along with the bindings of parameters to their arguments, for
6205 the purpose of compile time evaluation. */
6207 typedef struct GTY(()) constexpr_call
{
6208 /* Description of the constexpr function definition. */
6209 constexpr_fundef
*fundef
;
6210 /* Parameter bindings environment. A TREE_LIST where each TREE_PURPOSE
6211 is a parameter _DECL and the TREE_VALUE is the value of the parameter.
6212 Note: This arrangement is made to accomodate the use of
6213 iterative_hash_template_arg (see pt.c). If you change this
6214 representation, also change the hash calculation in
6215 cxx_eval_call_expression. */
6217 /* Result of the call.
6218 NULL means the call is being evaluated.
6219 error_mark_node means that the evaluation was erroneous;
6220 otherwise, the actuall value of the call. */
6222 /* The hash of this call; we remember it here to avoid having to
6223 recalculate it when expanding the hash table. */
6227 /* A table of all constexpr calls that have been evaluated by the
6228 compiler in this translation unit. */
6230 static GTY ((param_is (constexpr_call
))) htab_t constexpr_call_table
;
6232 static tree
cxx_eval_constant_expression (const constexpr_call
*, tree
,
6233 bool, bool, bool *);
6234 static tree
cxx_eval_vec_perm_expr (const constexpr_call
*, tree
, bool, bool,
6238 /* Compute a hash value for a constexpr call representation. */
6241 constexpr_call_hash (const void *p
)
6243 const constexpr_call
*info
= (const constexpr_call
*) p
;
6247 /* Return 1 if the objects pointed to by P and Q represent calls
6248 to the same constexpr function with the same arguments.
6249 Otherwise, return 0. */
6252 constexpr_call_equal (const void *p
, const void *q
)
6254 const constexpr_call
*lhs
= (const constexpr_call
*) p
;
6255 const constexpr_call
*rhs
= (const constexpr_call
*) q
;
6260 if (!constexpr_fundef_equal (lhs
->fundef
, rhs
->fundef
))
6262 lhs_bindings
= lhs
->bindings
;
6263 rhs_bindings
= rhs
->bindings
;
6264 while (lhs_bindings
!= NULL
&& rhs_bindings
!= NULL
)
6266 tree lhs_arg
= TREE_VALUE (lhs_bindings
);
6267 tree rhs_arg
= TREE_VALUE (rhs_bindings
);
6268 gcc_assert (TREE_TYPE (lhs_arg
) == TREE_TYPE (rhs_arg
));
6269 if (!cp_tree_equal (lhs_arg
, rhs_arg
))
6271 lhs_bindings
= TREE_CHAIN (lhs_bindings
);
6272 rhs_bindings
= TREE_CHAIN (rhs_bindings
);
6274 return lhs_bindings
== rhs_bindings
;
6277 /* Initialize the constexpr call table, if needed. */
6280 maybe_initialize_constexpr_call_table (void)
6282 if (constexpr_call_table
== NULL
)
6283 constexpr_call_table
= htab_create_ggc (101,
6284 constexpr_call_hash
,
6285 constexpr_call_equal
,
6289 /* Return true if T designates the implied `this' parameter. */
6292 is_this_parameter (tree t
)
6294 return t
== current_class_ptr
;
6297 /* We have an expression tree T that represents a call, either CALL_EXPR
6298 or AGGR_INIT_EXPR. If the call is lexically to a named function,
6299 retrun the _DECL for that function. */
6302 get_function_named_in_call (tree t
)
6305 switch (TREE_CODE (t
))
6308 fun
= CALL_EXPR_FN (t
);
6311 case AGGR_INIT_EXPR
:
6312 fun
= AGGR_INIT_EXPR_FN (t
);
6319 if (TREE_CODE (fun
) == ADDR_EXPR
6320 && TREE_CODE (TREE_OPERAND (fun
, 0)) == FUNCTION_DECL
)
6321 fun
= TREE_OPERAND (fun
, 0);
6325 /* We have an expression tree T that represents a call, either CALL_EXPR
6326 or AGGR_INIT_EXPR. Return the Nth argument. */
6329 get_nth_callarg (tree t
, int n
)
6331 switch (TREE_CODE (t
))
6334 return CALL_EXPR_ARG (t
, n
);
6336 case AGGR_INIT_EXPR
:
6337 return AGGR_INIT_EXPR_ARG (t
, n
);
6345 /* Look up the binding of the function parameter T in a constexpr
6346 function call context CALL. */
6349 lookup_parameter_binding (const constexpr_call
*call
, tree t
)
6351 tree b
= purpose_member (t
, call
->bindings
);
6352 return TREE_VALUE (b
);
6355 /* Attempt to evaluate T which represents a call to a builtin function.
6356 We assume here that all builtin functions evaluate to scalar types
6357 represented by _CST nodes. */
6360 cxx_eval_builtin_function_call (const constexpr_call
*call
, tree t
,
6361 bool allow_non_constant
, bool addr
,
6362 bool *non_constant_p
)
6364 const int nargs
= call_expr_nargs (t
);
6365 tree
*args
= (tree
*) alloca (nargs
* sizeof (tree
));
6368 for (i
= 0; i
< nargs
; ++i
)
6370 args
[i
] = cxx_eval_constant_expression (call
, CALL_EXPR_ARG (t
, i
),
6371 allow_non_constant
, addr
,
6373 if (allow_non_constant
&& *non_constant_p
)
6376 if (*non_constant_p
)
6378 new_call
= build_call_array_loc (EXPR_LOCATION (t
), TREE_TYPE (t
),
6379 CALL_EXPR_FN (t
), nargs
, args
);
6380 return fold (new_call
);
6383 /* TEMP is the constant value of a temporary object of type TYPE. Adjust
6384 the type of the value to match. */
6387 adjust_temp_type (tree type
, tree temp
)
6389 if (TREE_TYPE (temp
) == type
)
6391 /* Avoid wrapping an aggregate value in a NOP_EXPR. */
6392 if (TREE_CODE (temp
) == CONSTRUCTOR
)
6393 return build_constructor (type
, CONSTRUCTOR_ELTS (temp
));
6394 gcc_assert (SCALAR_TYPE_P (type
));
6395 return cp_fold_convert (type
, temp
);
6398 /* Subroutine of cxx_eval_call_expression.
6399 We are processing a call expression (either CALL_EXPR or
6400 AGGR_INIT_EXPR) in the call context of OLD_CALL. Evaluate
6401 all arguments and bind their values to correspondings
6402 parameters, making up the NEW_CALL context. */
6405 cxx_bind_parameters_in_call (const constexpr_call
*old_call
, tree t
,
6406 constexpr_call
*new_call
,
6407 bool allow_non_constant
,
6408 bool *non_constant_p
)
6410 const int nargs
= call_expr_nargs (t
);
6411 tree fun
= new_call
->fundef
->decl
;
6412 tree parms
= DECL_ARGUMENTS (fun
);
6414 for (i
= 0; i
< nargs
; ++i
)
6417 tree type
= parms
? TREE_TYPE (parms
) : void_type_node
;
6418 /* For member function, the first argument is a pointer to the implied
6419 object. And for an object contruction, don't bind `this' before
6420 it is fully constructed. */
6421 if (i
== 0 && DECL_CONSTRUCTOR_P (fun
))
6423 x
= get_nth_callarg (t
, i
);
6424 arg
= cxx_eval_constant_expression (old_call
, x
, allow_non_constant
,
6425 TREE_CODE (type
) == REFERENCE_TYPE
,
6427 /* Don't VERIFY_CONSTANT here. */
6428 if (*non_constant_p
&& allow_non_constant
)
6430 /* Just discard ellipsis args after checking their constantitude. */
6433 if (*non_constant_p
)
6434 /* Don't try to adjust the type of non-constant args. */
6437 /* Make sure the binding has the same type as the parm. */
6438 if (TREE_CODE (type
) != REFERENCE_TYPE
)
6439 arg
= adjust_temp_type (type
, arg
);
6440 new_call
->bindings
= tree_cons (parms
, arg
, new_call
->bindings
);
6442 parms
= TREE_CHAIN (parms
);
6446 /* Variables and functions to manage constexpr call expansion context.
6447 These do not need to be marked for PCH or GC. */
6449 /* FIXME remember and print actual constant arguments. */
6450 static VEC(tree
,heap
) *call_stack
= NULL
;
6451 static int call_stack_tick
;
6452 static int last_cx_error_tick
;
6455 push_cx_call_context (tree call
)
6458 if (!EXPR_HAS_LOCATION (call
))
6459 SET_EXPR_LOCATION (call
, input_location
);
6460 VEC_safe_push (tree
, heap
, call_stack
, call
);
6461 if (VEC_length (tree
, call_stack
) > (unsigned) max_constexpr_depth
)
6467 pop_cx_call_context (void)
6470 VEC_pop (tree
, call_stack
);
6474 cx_error_context (void)
6476 VEC(tree
,heap
) *r
= NULL
;
6477 if (call_stack_tick
!= last_cx_error_tick
6478 && !VEC_empty (tree
, call_stack
))
6480 last_cx_error_tick
= call_stack_tick
;
6484 /* Subroutine of cxx_eval_constant_expression.
6485 Evaluate the call expression tree T in the context of OLD_CALL expression
6489 cxx_eval_call_expression (const constexpr_call
*old_call
, tree t
,
6490 bool allow_non_constant
, bool addr
,
6491 bool *non_constant_p
)
6493 location_t loc
= EXPR_LOC_OR_HERE (t
);
6494 tree fun
= get_function_named_in_call (t
);
6496 constexpr_call new_call
= { NULL
, NULL
, NULL
, 0 };
6497 constexpr_call
**slot
;
6498 constexpr_call
*entry
;
6501 if (TREE_CODE (fun
) != FUNCTION_DECL
)
6503 /* Might be a constexpr function pointer. */
6504 fun
= cxx_eval_constant_expression (old_call
, fun
, allow_non_constant
,
6505 /*addr*/false, non_constant_p
);
6506 if (TREE_CODE (fun
) == ADDR_EXPR
)
6507 fun
= TREE_OPERAND (fun
, 0);
6509 if (TREE_CODE (fun
) != FUNCTION_DECL
)
6511 if (!allow_non_constant
&& !*non_constant_p
)
6512 error_at (loc
, "expression %qE does not designate a constexpr "
6514 *non_constant_p
= true;
6517 if (DECL_CLONED_FUNCTION_P (fun
))
6518 fun
= DECL_CLONED_FUNCTION (fun
);
6519 if (is_builtin_fn (fun
))
6520 return cxx_eval_builtin_function_call (old_call
, t
, allow_non_constant
,
6521 addr
, non_constant_p
);
6522 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
6524 if (!allow_non_constant
)
6526 error_at (loc
, "call to non-constexpr function %qD", fun
);
6527 explain_invalid_constexpr_fn (fun
);
6529 *non_constant_p
= true;
6533 /* Shortcut trivial copy constructor/op=. */
6534 if (call_expr_nargs (t
) == 2 && trivial_fn_p (fun
))
6536 tree arg
= convert_from_reference (get_nth_callarg (t
, 1));
6537 return cxx_eval_constant_expression (old_call
, arg
, allow_non_constant
,
6538 addr
, non_constant_p
);
6541 /* If in direct recursive call, optimize definition search. */
6542 if (old_call
!= NULL
&& old_call
->fundef
->decl
== fun
)
6543 new_call
.fundef
= old_call
->fundef
;
6546 new_call
.fundef
= retrieve_constexpr_fundef (fun
);
6547 if (new_call
.fundef
== NULL
|| new_call
.fundef
->body
== NULL
)
6549 if (!allow_non_constant
)
6551 if (DECL_INITIAL (fun
))
6553 /* The definition of fun was somehow unsuitable. */
6554 error_at (loc
, "%qD called in a constant expression", fun
);
6555 explain_invalid_constexpr_fn (fun
);
6558 error_at (loc
, "%qD used before its definition", fun
);
6560 *non_constant_p
= true;
6564 cxx_bind_parameters_in_call (old_call
, t
, &new_call
,
6565 allow_non_constant
, non_constant_p
);
6566 if (*non_constant_p
)
6569 depth_ok
= push_cx_call_context (t
);
6572 = iterative_hash_template_arg (new_call
.bindings
,
6573 constexpr_fundef_hash (new_call
.fundef
));
6575 /* If we have seen this call before, we are done. */
6576 maybe_initialize_constexpr_call_table ();
6577 slot
= (constexpr_call
**)
6578 htab_find_slot (constexpr_call_table
, &new_call
, INSERT
);
6582 /* We need to keep a pointer to the entry, not just the slot, as the
6583 slot can move in the call to cxx_eval_builtin_function_call. */
6584 *slot
= entry
= ggc_alloc_constexpr_call ();
6587 /* Calls which are in progress have their result set to NULL
6588 so that we can detect circular dependencies. */
6589 else if (entry
->result
== NULL
)
6591 if (!allow_non_constant
)
6592 error ("call has circular dependency");
6593 *non_constant_p
= true;
6594 entry
->result
= result
= error_mark_node
;
6599 if (!allow_non_constant
)
6600 error ("constexpr evaluation depth exceeds maximum of %d (use "
6601 "-fconstexpr-depth= to increase the maximum)",
6602 max_constexpr_depth
);
6603 *non_constant_p
= true;
6604 entry
->result
= result
= error_mark_node
;
6608 result
= entry
->result
;
6609 if (!result
|| result
== error_mark_node
)
6610 result
= (cxx_eval_constant_expression
6611 (&new_call
, new_call
.fundef
->body
,
6612 allow_non_constant
, addr
,
6614 if (result
== error_mark_node
)
6615 *non_constant_p
= true;
6616 if (*non_constant_p
)
6617 entry
->result
= result
= error_mark_node
;
6620 /* If this was a call to initialize an object, set the type of
6621 the CONSTRUCTOR to the type of that object. */
6622 if (DECL_CONSTRUCTOR_P (fun
))
6624 tree ob_arg
= get_nth_callarg (t
, 0);
6625 STRIP_NOPS (ob_arg
);
6626 gcc_assert (TREE_CODE (TREE_TYPE (ob_arg
)) == POINTER_TYPE
6627 && CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (ob_arg
))));
6628 result
= adjust_temp_type (TREE_TYPE (TREE_TYPE (ob_arg
)),
6631 entry
->result
= result
;
6635 pop_cx_call_context ();
6636 return unshare_expr (result
);
6639 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
6642 reduced_constant_expression_p (tree t
)
6644 if (TREE_OVERFLOW_P (t
))
6645 /* Integer overflow makes this not a constant expression. */
6647 /* FIXME are we calling this too much? */
6648 return initializer_constant_valid_p (t
, TREE_TYPE (t
)) != NULL_TREE
;
6651 /* Some expressions may have constant operands but are not constant
6652 themselves, such as 1/0. Call this function (or rather, the macro
6653 following it) to check for that condition.
6655 We only call this in places that require an arithmetic constant, not in
6656 places where we might have a non-constant expression that can be a
6657 component of a constant expression, such as the address of a constexpr
6658 variable that might be dereferenced later. */
6661 verify_constant (tree t
, bool allow_non_constant
, bool *non_constant_p
)
6663 if (!*non_constant_p
&& !reduced_constant_expression_p (t
))
6665 if (!allow_non_constant
)
6667 /* If T was already folded to a _CST with TREE_OVERFLOW set,
6668 printing the folded constant isn't helpful. */
6669 if (TREE_OVERFLOW_P (t
))
6671 permerror (input_location
, "overflow in constant expression");
6672 /* If we're being permissive (and are in an enforcing
6673 context), consider this constant. */
6674 if (flag_permissive
)
6678 error ("%q+E is not a constant expression", t
);
6680 *non_constant_p
= true;
6682 return *non_constant_p
;
6684 #define VERIFY_CONSTANT(X) \
6686 if (verify_constant ((X), allow_non_constant, non_constant_p)) \
6690 /* Subroutine of cxx_eval_constant_expression.
6691 Attempt to reduce the unary expression tree T to a compile time value.
6692 If successful, return the value. Otherwise issue a diagnostic
6693 and return error_mark_node. */
6696 cxx_eval_unary_expression (const constexpr_call
*call
, tree t
,
6697 bool allow_non_constant
, bool addr
,
6698 bool *non_constant_p
)
6701 tree orig_arg
= TREE_OPERAND (t
, 0);
6702 tree arg
= cxx_eval_constant_expression (call
, orig_arg
, allow_non_constant
,
6703 addr
, non_constant_p
);
6704 VERIFY_CONSTANT (arg
);
6705 if (arg
== orig_arg
)
6707 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), arg
);
6708 VERIFY_CONSTANT (r
);
6712 /* Subroutine of cxx_eval_constant_expression.
6713 Like cxx_eval_unary_expression, except for binary expressions. */
6716 cxx_eval_binary_expression (const constexpr_call
*call
, tree t
,
6717 bool allow_non_constant
, bool addr
,
6718 bool *non_constant_p
)
6721 tree orig_lhs
= TREE_OPERAND (t
, 0);
6722 tree orig_rhs
= TREE_OPERAND (t
, 1);
6724 lhs
= cxx_eval_constant_expression (call
, orig_lhs
,
6725 allow_non_constant
, addr
,
6727 VERIFY_CONSTANT (lhs
);
6728 rhs
= cxx_eval_constant_expression (call
, orig_rhs
,
6729 allow_non_constant
, addr
,
6731 VERIFY_CONSTANT (rhs
);
6732 if (lhs
== orig_lhs
&& rhs
== orig_rhs
)
6734 r
= fold_build2 (TREE_CODE (t
), TREE_TYPE (t
), lhs
, rhs
);
6735 VERIFY_CONSTANT (r
);
6739 /* Subroutine of cxx_eval_constant_expression.
6740 Attempt to evaluate condition expressions. Dead branches are not
6744 cxx_eval_conditional_expression (const constexpr_call
*call
, tree t
,
6745 bool allow_non_constant
, bool addr
,
6746 bool *non_constant_p
)
6748 tree val
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 0),
6749 allow_non_constant
, addr
,
6751 VERIFY_CONSTANT (val
);
6752 /* Don't VERIFY_CONSTANT the other operands. */
6753 if (integer_zerop (val
))
6754 return cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 2),
6755 allow_non_constant
, addr
,
6757 return cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 1),
6758 allow_non_constant
, addr
,
6762 /* Subroutine of cxx_eval_constant_expression.
6763 Attempt to reduce a reference to an array slot. */
6766 cxx_eval_array_reference (const constexpr_call
*call
, tree t
,
6767 bool allow_non_constant
, bool addr
,
6768 bool *non_constant_p
)
6770 tree oldary
= TREE_OPERAND (t
, 0);
6771 tree ary
= cxx_eval_constant_expression (call
, oldary
,
6772 allow_non_constant
, addr
,
6777 unsigned len
, elem_nchars
= 1;
6778 if (*non_constant_p
)
6780 oldidx
= TREE_OPERAND (t
, 1);
6781 index
= cxx_eval_constant_expression (call
, oldidx
,
6782 allow_non_constant
, false,
6784 VERIFY_CONSTANT (index
);
6785 if (addr
&& ary
== oldary
&& index
== oldidx
)
6788 return build4 (ARRAY_REF
, TREE_TYPE (t
), ary
, index
, NULL
, NULL
);
6789 elem_type
= TREE_TYPE (TREE_TYPE (ary
));
6790 if (TREE_CODE (ary
) == CONSTRUCTOR
)
6791 len
= CONSTRUCTOR_NELTS (ary
);
6792 else if (TREE_CODE (ary
) == STRING_CST
)
6794 elem_nchars
= (TYPE_PRECISION (elem_type
)
6795 / TYPE_PRECISION (char_type_node
));
6796 len
= (unsigned) TREE_STRING_LENGTH (ary
) / elem_nchars
;
6800 /* We can't do anything with other tree codes, so use
6801 VERIFY_CONSTANT to complain and fail. */
6802 VERIFY_CONSTANT (ary
);
6805 if (compare_tree_int (index
, len
) >= 0)
6807 if (tree_int_cst_lt (index
, array_type_nelts_top (TREE_TYPE (ary
))))
6809 /* If it's within the array bounds but doesn't have an explicit
6810 initializer, it's value-initialized. */
6811 tree val
= build_value_init (elem_type
, tf_warning_or_error
);
6812 return cxx_eval_constant_expression (call
, val
,
6813 allow_non_constant
, addr
,
6817 if (!allow_non_constant
)
6818 error ("array subscript out of bound");
6819 *non_constant_p
= true;
6822 i
= tree_low_cst (index
, 0);
6823 if (TREE_CODE (ary
) == CONSTRUCTOR
)
6824 return VEC_index (constructor_elt
, CONSTRUCTOR_ELTS (ary
), i
)->value
;
6825 else if (elem_nchars
== 1)
6826 return build_int_cst (cv_unqualified (TREE_TYPE (TREE_TYPE (ary
))),
6827 TREE_STRING_POINTER (ary
)[i
]);
6830 tree type
= cv_unqualified (TREE_TYPE (TREE_TYPE (ary
)));
6831 return native_interpret_expr (type
, (const unsigned char *)
6832 TREE_STRING_POINTER (ary
)
6833 + i
* elem_nchars
, elem_nchars
);
6835 /* Don't VERIFY_CONSTANT here. */
6838 /* Subroutine of cxx_eval_constant_expression.
6839 Attempt to reduce a field access of a value of class type. */
6842 cxx_eval_component_reference (const constexpr_call
*call
, tree t
,
6843 bool allow_non_constant
, bool addr
,
6844 bool *non_constant_p
)
6846 unsigned HOST_WIDE_INT i
;
6849 tree part
= TREE_OPERAND (t
, 1);
6850 tree orig_whole
= TREE_OPERAND (t
, 0);
6851 tree whole
= cxx_eval_constant_expression (call
, orig_whole
,
6852 allow_non_constant
, addr
,
6854 if (whole
== orig_whole
)
6857 return fold_build3 (COMPONENT_REF
, TREE_TYPE (t
),
6858 whole
, part
, NULL_TREE
);
6859 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
6861 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
6863 if (!allow_non_constant
)
6864 error ("%qE is not a constant expression", orig_whole
);
6865 *non_constant_p
= true;
6867 if (DECL_MUTABLE_P (part
))
6869 if (!allow_non_constant
)
6870 error ("mutable %qD is not usable in a constant expression", part
);
6871 *non_constant_p
= true;
6873 if (*non_constant_p
)
6875 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
6880 if (TREE_CODE (TREE_TYPE (whole
)) == UNION_TYPE
6881 && CONSTRUCTOR_NELTS (whole
) > 0)
6883 /* DR 1188 says we don't have to deal with this. */
6884 if (!allow_non_constant
)
6885 error ("accessing %qD member instead of initialized %qD member in "
6886 "constant expression", part
, CONSTRUCTOR_ELT (whole
, 0)->index
);
6887 *non_constant_p
= true;
6891 /* If there's no explicit init for this field, it's value-initialized. */
6892 value
= build_value_init (TREE_TYPE (t
), tf_warning_or_error
);
6893 return cxx_eval_constant_expression (call
, value
,
6894 allow_non_constant
, addr
,
6898 /* Subroutine of cxx_eval_constant_expression.
6899 Attempt to reduce a field access of a value of class type that is
6900 expressed as a BIT_FIELD_REF. */
6903 cxx_eval_bit_field_ref (const constexpr_call
*call
, tree t
,
6904 bool allow_non_constant
, bool addr
,
6905 bool *non_constant_p
)
6907 tree orig_whole
= TREE_OPERAND (t
, 0);
6908 tree retval
, fldval
, utype
, mask
;
6909 bool fld_seen
= false;
6910 HOST_WIDE_INT istart
, isize
;
6911 tree whole
= cxx_eval_constant_expression (call
, orig_whole
,
6912 allow_non_constant
, addr
,
6914 tree start
, field
, value
;
6915 unsigned HOST_WIDE_INT i
;
6917 if (whole
== orig_whole
)
6919 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
6921 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
6923 if (!allow_non_constant
)
6924 error ("%qE is not a constant expression", orig_whole
);
6925 *non_constant_p
= true;
6927 if (*non_constant_p
)
6930 start
= TREE_OPERAND (t
, 2);
6931 istart
= tree_low_cst (start
, 0);
6932 isize
= tree_low_cst (TREE_OPERAND (t
, 1), 0);
6933 utype
= TREE_TYPE (t
);
6934 if (!TYPE_UNSIGNED (utype
))
6935 utype
= build_nonstandard_integer_type (TYPE_PRECISION (utype
), 1);
6936 retval
= build_int_cst (utype
, 0);
6937 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
6939 tree bitpos
= bit_position (field
);
6940 if (bitpos
== start
&& DECL_SIZE (field
) == TREE_OPERAND (t
, 1))
6942 if (TREE_CODE (TREE_TYPE (field
)) == INTEGER_TYPE
6943 && TREE_CODE (value
) == INTEGER_CST
6944 && host_integerp (bitpos
, 0)
6945 && host_integerp (DECL_SIZE (field
), 0))
6947 HOST_WIDE_INT bit
= tree_low_cst (bitpos
, 0);
6948 HOST_WIDE_INT sz
= tree_low_cst (DECL_SIZE (field
), 0);
6949 HOST_WIDE_INT shift
;
6950 if (bit
>= istart
&& bit
+ sz
<= istart
+ isize
)
6952 fldval
= fold_convert (utype
, value
);
6953 mask
= build_int_cst_type (utype
, -1);
6954 mask
= fold_build2 (LSHIFT_EXPR
, utype
, mask
,
6955 size_int (TYPE_PRECISION (utype
) - sz
));
6956 mask
= fold_build2 (RSHIFT_EXPR
, utype
, mask
,
6957 size_int (TYPE_PRECISION (utype
) - sz
));
6958 fldval
= fold_build2 (BIT_AND_EXPR
, utype
, fldval
, mask
);
6959 shift
= bit
- istart
;
6960 if (BYTES_BIG_ENDIAN
)
6961 shift
= TYPE_PRECISION (utype
) - shift
- sz
;
6962 fldval
= fold_build2 (LSHIFT_EXPR
, utype
, fldval
,
6964 retval
= fold_build2 (BIT_IOR_EXPR
, utype
, retval
, fldval
);
6970 return fold_convert (TREE_TYPE (t
), retval
);
6972 return error_mark_node
;
6975 /* Subroutine of cxx_eval_constant_expression.
6976 Evaluate a short-circuited logical expression T in the context
6977 of a given constexpr CALL. BAILOUT_VALUE is the value for
6978 early return. CONTINUE_VALUE is used here purely for
6979 sanity check purposes. */
6982 cxx_eval_logical_expression (const constexpr_call
*call
, tree t
,
6983 tree bailout_value
, tree continue_value
,
6984 bool allow_non_constant
, bool addr
,
6985 bool *non_constant_p
)
6988 tree lhs
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 0),
6989 allow_non_constant
, addr
,
6991 VERIFY_CONSTANT (lhs
);
6992 if (tree_int_cst_equal (lhs
, bailout_value
))
6994 gcc_assert (tree_int_cst_equal (lhs
, continue_value
));
6995 r
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 1),
6996 allow_non_constant
, addr
, non_constant_p
);
6997 VERIFY_CONSTANT (r
);
7001 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
7002 CONSTRUCTOR elements to initialize (part of) an object containing that
7003 field. Return a pointer to the constructor_elt corresponding to the
7004 initialization of the field. */
7006 static constructor_elt
*
7007 base_field_constructor_elt (VEC(constructor_elt
,gc
) *v
, tree ref
)
7009 tree aggr
= TREE_OPERAND (ref
, 0);
7010 tree field
= TREE_OPERAND (ref
, 1);
7012 constructor_elt
*ce
;
7014 gcc_assert (TREE_CODE (ref
) == COMPONENT_REF
);
7016 if (TREE_CODE (aggr
) == COMPONENT_REF
)
7018 constructor_elt
*base_ce
7019 = base_field_constructor_elt (v
, aggr
);
7020 v
= CONSTRUCTOR_ELTS (base_ce
->value
);
7023 for (i
= 0; VEC_iterate (constructor_elt
, v
, i
, ce
); ++i
)
7024 if (ce
->index
== field
)
7031 /* Subroutine of cxx_eval_constant_expression.
7032 The expression tree T denotes a C-style array or a C-style
7033 aggregate. Reduce it to a constant expression. */
7036 cxx_eval_bare_aggregate (const constexpr_call
*call
, tree t
,
7037 bool allow_non_constant
, bool addr
,
7038 bool *non_constant_p
)
7040 VEC(constructor_elt
,gc
) *v
= CONSTRUCTOR_ELTS (t
);
7041 VEC(constructor_elt
,gc
) *n
= VEC_alloc (constructor_elt
, gc
,
7042 VEC_length (constructor_elt
, v
));
7043 constructor_elt
*ce
;
7045 bool changed
= false;
7046 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t
));
7047 for (i
= 0; VEC_iterate (constructor_elt
, v
, i
, ce
); ++i
)
7049 tree elt
= cxx_eval_constant_expression (call
, ce
->value
,
7050 allow_non_constant
, addr
,
7052 /* Don't VERIFY_CONSTANT here. */
7053 if (allow_non_constant
&& *non_constant_p
)
7055 if (elt
!= ce
->value
)
7057 if (TREE_CODE (ce
->index
) == COMPONENT_REF
)
7059 /* This is an initialization of a vfield inside a base
7060 subaggregate that we already initialized; push this
7061 initialization into the previous initialization. */
7062 constructor_elt
*inner
= base_field_constructor_elt (n
, ce
->index
);
7065 else if (TREE_CODE (ce
->index
) == NOP_EXPR
)
7067 /* This is an initializer for an empty base; now that we've
7068 checked that it's constant, we can ignore it. */
7069 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (ce
->index
))));
7072 CONSTRUCTOR_APPEND_ELT (n
, ce
->index
, elt
);
7074 if (*non_constant_p
|| !changed
)
7077 VEC_free (constructor_elt
, gc
, n
);
7080 t
= build_constructor (TREE_TYPE (t
), n
);
7081 TREE_CONSTANT (t
) = true;
7085 /* Subroutine of cxx_eval_constant_expression.
7086 The expression tree T is a VEC_INIT_EXPR which denotes the desired
7087 initialization of a non-static data member of array type. Reduce it to a
7090 Note that apart from value-initialization (when VALUE_INIT is true),
7091 this is only intended to support value-initialization and the
7092 initializations done by defaulted constructors for classes with
7093 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
7094 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
7095 for the copy/move constructor. */
7098 cxx_eval_vec_init_1 (const constexpr_call
*call
, tree atype
, tree init
,
7099 bool value_init
, bool allow_non_constant
, bool addr
,
7100 bool *non_constant_p
)
7102 tree elttype
= TREE_TYPE (atype
);
7103 int max
= tree_low_cst (array_type_nelts (atype
), 0);
7104 VEC(constructor_elt
,gc
) *n
= VEC_alloc (constructor_elt
, gc
, max
+ 1);
7105 bool pre_init
= false;
7108 /* For the default constructor, build up a call to the default
7109 constructor of the element type. We only need to handle class types
7110 here, as for a constructor to be constexpr, all members must be
7111 initialized, which for a defaulted default constructor means they must
7112 be of a class type with a constexpr default constructor. */
7113 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
7114 /* We only do this at the lowest level. */;
7115 else if (value_init
)
7117 init
= build_value_init (elttype
, tf_warning_or_error
);
7118 init
= cxx_eval_constant_expression
7119 (call
, init
, allow_non_constant
, addr
, non_constant_p
);
7124 VEC(tree
,gc
) *argvec
= make_tree_vector ();
7125 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
7126 &argvec
, elttype
, LOOKUP_NORMAL
,
7127 tf_warning_or_error
);
7128 release_tree_vector (argvec
);
7129 init
= cxx_eval_constant_expression (call
, init
, allow_non_constant
,
7130 addr
, non_constant_p
);
7134 if (*non_constant_p
&& !allow_non_constant
)
7137 for (i
= 0; i
<= max
; ++i
)
7139 tree idx
= build_int_cst (size_type_node
, i
);
7141 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
7143 /* A multidimensional array; recurse. */
7144 if (value_init
|| init
== NULL_TREE
)
7145 eltinit
= NULL_TREE
;
7147 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
7148 tf_warning_or_error
);
7149 eltinit
= cxx_eval_vec_init_1 (call
, elttype
, eltinit
, value_init
,
7150 allow_non_constant
, addr
,
7155 /* Initializing an element using value or default initialization
7156 we just pre-built above. */
7160 eltinit
= unshare_expr (init
);
7164 /* Copying an element. */
7165 VEC(tree
,gc
) *argvec
;
7166 gcc_assert (same_type_ignoring_top_level_qualifiers_p
7167 (atype
, TREE_TYPE (init
)));
7168 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
7169 tf_warning_or_error
);
7170 if (!real_lvalue_p (init
))
7171 eltinit
= move (eltinit
);
7172 argvec
= make_tree_vector ();
7173 VEC_quick_push (tree
, argvec
, eltinit
);
7174 eltinit
= (build_special_member_call
7175 (NULL_TREE
, complete_ctor_identifier
, &argvec
,
7176 elttype
, LOOKUP_NORMAL
, tf_warning_or_error
));
7177 release_tree_vector (argvec
);
7178 eltinit
= cxx_eval_constant_expression
7179 (call
, eltinit
, allow_non_constant
, addr
, non_constant_p
);
7181 if (*non_constant_p
&& !allow_non_constant
)
7183 CONSTRUCTOR_APPEND_ELT (n
, idx
, eltinit
);
7186 if (!*non_constant_p
)
7188 init
= build_constructor (atype
, n
);
7189 TREE_CONSTANT (init
) = true;
7194 VEC_free (constructor_elt
, gc
, n
);
7199 cxx_eval_vec_init (const constexpr_call
*call
, tree t
,
7200 bool allow_non_constant
, bool addr
,
7201 bool *non_constant_p
)
7203 tree atype
= TREE_TYPE (t
);
7204 tree init
= VEC_INIT_EXPR_INIT (t
);
7205 tree r
= cxx_eval_vec_init_1 (call
, atype
, init
,
7206 VEC_INIT_EXPR_VALUE_INIT (t
),
7207 allow_non_constant
, addr
, non_constant_p
);
7208 if (*non_constant_p
)
7214 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
7215 match. We want to be less strict for simple *& folding; if we have a
7216 non-const temporary that we access through a const pointer, that should
7217 work. We handle this here rather than change fold_indirect_ref_1
7218 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
7219 don't really make sense outside of constant expression evaluation. Also
7220 we want to allow folding to COMPONENT_REF, which could cause trouble
7221 with TBAA in fold_indirect_ref_1.
7223 Try to keep this function synced with fold_indirect_ref_1. */
7226 cxx_fold_indirect_ref (location_t loc
, tree type
, tree op0
, bool *empty_base
)
7232 subtype
= TREE_TYPE (sub
);
7233 if (!POINTER_TYPE_P (subtype
))
7236 if (TREE_CODE (sub
) == ADDR_EXPR
)
7238 tree op
= TREE_OPERAND (sub
, 0);
7239 tree optype
= TREE_TYPE (op
);
7241 /* *&CONST_DECL -> to the value of the const decl. */
7242 if (TREE_CODE (op
) == CONST_DECL
)
7243 return DECL_INITIAL (op
);
7244 /* *&p => p; make sure to handle *&"str"[cst] here. */
7245 if (same_type_ignoring_top_level_qualifiers_p (optype
, type
))
7247 tree fop
= fold_read_from_constant_string (op
);
7253 /* *(foo *)&fooarray => fooarray[0] */
7254 else if (TREE_CODE (optype
) == ARRAY_TYPE
7255 && (same_type_ignoring_top_level_qualifiers_p
7256 (type
, TREE_TYPE (optype
))))
7258 tree type_domain
= TYPE_DOMAIN (optype
);
7259 tree min_val
= size_zero_node
;
7260 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
7261 min_val
= TYPE_MIN_VALUE (type_domain
);
7262 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
7263 NULL_TREE
, NULL_TREE
);
7265 /* *(foo *)&complexfoo => __real__ complexfoo */
7266 else if (TREE_CODE (optype
) == COMPLEX_TYPE
7267 && (same_type_ignoring_top_level_qualifiers_p
7268 (type
, TREE_TYPE (optype
))))
7269 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
7270 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
7271 else if (TREE_CODE (optype
) == VECTOR_TYPE
7272 && (same_type_ignoring_top_level_qualifiers_p
7273 (type
, TREE_TYPE (optype
))))
7275 tree part_width
= TYPE_SIZE (type
);
7276 tree index
= bitsize_int (0);
7277 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
, index
);
7279 /* Also handle conversion to an empty base class, which
7280 is represented with a NOP_EXPR. */
7281 else if (is_empty_class (type
)
7282 && CLASS_TYPE_P (optype
)
7283 && DERIVED_FROM_P (type
, optype
))
7288 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
7289 else if (RECORD_OR_UNION_TYPE_P (optype
))
7291 tree field
= TYPE_FIELDS (optype
);
7292 for (; field
; field
= DECL_CHAIN (field
))
7293 if (TREE_CODE (field
) == FIELD_DECL
7294 && integer_zerop (byte_position (field
))
7295 && (same_type_ignoring_top_level_qualifiers_p
7296 (TREE_TYPE (field
), type
)))
7298 return fold_build3 (COMPONENT_REF
, type
, op
, field
, NULL_TREE
);
7303 else if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
7304 && TREE_CODE (TREE_OPERAND (sub
, 1)) == INTEGER_CST
)
7306 tree op00
= TREE_OPERAND (sub
, 0);
7307 tree op01
= TREE_OPERAND (sub
, 1);
7310 if (TREE_CODE (op00
) == ADDR_EXPR
)
7313 op00
= TREE_OPERAND (op00
, 0);
7314 op00type
= TREE_TYPE (op00
);
7316 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
7317 if (TREE_CODE (op00type
) == VECTOR_TYPE
7318 && (same_type_ignoring_top_level_qualifiers_p
7319 (type
, TREE_TYPE (op00type
))))
7321 HOST_WIDE_INT offset
= tree_low_cst (op01
, 0);
7322 tree part_width
= TYPE_SIZE (type
);
7323 unsigned HOST_WIDE_INT part_widthi
= tree_low_cst (part_width
, 0)/BITS_PER_UNIT
;
7324 unsigned HOST_WIDE_INT indexi
= offset
* BITS_PER_UNIT
;
7325 tree index
= bitsize_int (indexi
);
7327 if (offset
/part_widthi
<= TYPE_VECTOR_SUBPARTS (op00type
))
7328 return fold_build3_loc (loc
,
7329 BIT_FIELD_REF
, type
, op00
,
7333 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
7334 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
7335 && (same_type_ignoring_top_level_qualifiers_p
7336 (type
, TREE_TYPE (op00type
))))
7338 tree size
= TYPE_SIZE_UNIT (type
);
7339 if (tree_int_cst_equal (size
, op01
))
7340 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
7342 /* ((foo *)&fooarray)[1] => fooarray[1] */
7343 else if (TREE_CODE (op00type
) == ARRAY_TYPE
7344 && (same_type_ignoring_top_level_qualifiers_p
7345 (type
, TREE_TYPE (op00type
))))
7347 tree type_domain
= TYPE_DOMAIN (op00type
);
7348 tree min_val
= size_zero_node
;
7349 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
7350 min_val
= TYPE_MIN_VALUE (type_domain
);
7351 op01
= size_binop_loc (loc
, EXACT_DIV_EXPR
, op01
,
7352 TYPE_SIZE_UNIT (type
));
7353 op01
= size_binop_loc (loc
, PLUS_EXPR
, op01
, min_val
);
7354 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
7355 NULL_TREE
, NULL_TREE
);
7357 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
7358 else if (RECORD_OR_UNION_TYPE_P (op00type
))
7360 tree field
= TYPE_FIELDS (op00type
);
7361 for (; field
; field
= DECL_CHAIN (field
))
7362 if (TREE_CODE (field
) == FIELD_DECL
7363 && tree_int_cst_equal (byte_position (field
), op01
)
7364 && (same_type_ignoring_top_level_qualifiers_p
7365 (TREE_TYPE (field
), type
)))
7367 return fold_build3 (COMPONENT_REF
, type
, op00
,
7374 /* *(foo *)fooarrptreturn> (*fooarrptr)[0] */
7375 else if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
7376 && (same_type_ignoring_top_level_qualifiers_p
7377 (type
, TREE_TYPE (TREE_TYPE (subtype
)))))
7380 tree min_val
= size_zero_node
;
7381 sub
= cxx_fold_indirect_ref (loc
, TREE_TYPE (subtype
), sub
, NULL
);
7383 sub
= build1_loc (loc
, INDIRECT_REF
, TREE_TYPE (subtype
), sub
);
7384 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
7385 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
7386 min_val
= TYPE_MIN_VALUE (type_domain
);
7387 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
7395 cxx_eval_indirect_ref (const constexpr_call
*call
, tree t
,
7396 bool allow_non_constant
, bool addr
,
7397 bool *non_constant_p
)
7399 tree orig_op0
= TREE_OPERAND (t
, 0);
7400 tree op0
= cxx_eval_constant_expression (call
, orig_op0
, allow_non_constant
,
7401 /*addr*/false, non_constant_p
);
7402 bool empty_base
= false;
7405 /* Don't VERIFY_CONSTANT here. */
7406 if (*non_constant_p
)
7409 r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), op0
,
7413 r
= cxx_eval_constant_expression (call
, r
, allow_non_constant
,
7414 addr
, non_constant_p
);
7419 if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
)
7421 sub
= TREE_OPERAND (sub
, 0);
7424 if (TREE_CODE (sub
) == ADDR_EXPR
)
7426 /* We couldn't fold to a constant value. Make sure it's not
7427 something we should have been able to fold. */
7428 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
7429 (TREE_TYPE (TREE_TYPE (sub
)), TREE_TYPE (t
)));
7430 /* DR 1188 says we don't have to deal with this. */
7431 if (!allow_non_constant
)
7432 error ("accessing value of %qE through a %qT glvalue in a "
7433 "constant expression", build_fold_indirect_ref (sub
),
7435 *non_constant_p
= true;
7440 /* If we're pulling out the value of an empty base, make sure
7441 that the whole object is constant and then return an empty
7445 VERIFY_CONSTANT (r
);
7446 r
= build_constructor (TREE_TYPE (t
), NULL
);
7447 TREE_CONSTANT (r
) = true;
7455 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
7456 Shared between potential_constant_expression and
7457 cxx_eval_constant_expression. */
7460 non_const_var_error (tree r
)
7462 tree type
= TREE_TYPE (r
);
7463 error ("the value of %qD is not usable in a constant "
7465 /* Avoid error cascade. */
7466 if (DECL_INITIAL (r
) == error_mark_node
)
7468 if (DECL_DECLARED_CONSTEXPR_P (r
))
7469 inform (DECL_SOURCE_LOCATION (r
),
7470 "%qD used in its own initializer", r
);
7471 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
7473 if (!CP_TYPE_CONST_P (type
))
7474 inform (DECL_SOURCE_LOCATION (r
),
7475 "%q#D is not const", r
);
7476 else if (CP_TYPE_VOLATILE_P (type
))
7477 inform (DECL_SOURCE_LOCATION (r
),
7478 "%q#D is volatile", r
);
7479 else if (!DECL_INITIAL (r
)
7480 || !TREE_CONSTANT (DECL_INITIAL (r
)))
7481 inform (DECL_SOURCE_LOCATION (r
),
7482 "%qD was not initialized with a constant "
7489 if (cxx_dialect
>= cxx0x
&& !DECL_DECLARED_CONSTEXPR_P (r
))
7490 inform (DECL_SOURCE_LOCATION (r
),
7491 "%qD was not declared %<constexpr%>", r
);
7493 inform (DECL_SOURCE_LOCATION (r
),
7494 "%qD does not have integral or enumeration type",
7499 /* Evaluate VEC_PERM_EXPR (v1, v2, mask). */
7501 cxx_eval_vec_perm_expr (const constexpr_call
*call
, tree t
,
7502 bool allow_non_constant
, bool addr
,
7503 bool * non_constant_p
)
7508 tree elttype
= TREE_TYPE (t
);
7510 for (i
= 0; i
< 3; i
++)
7512 args
[i
] = cxx_eval_constant_expression (call
, TREE_OPERAND (t
, i
),
7513 allow_non_constant
, addr
,
7515 if (*non_constant_p
)
7519 gcc_assert (TREE_CODE (TREE_TYPE (args
[0])) == VECTOR_TYPE
);
7520 gcc_assert (TREE_CODE (TREE_TYPE (args
[1])) == VECTOR_TYPE
);
7521 gcc_assert (TREE_CODE (TREE_TYPE (args
[2])) == VECTOR_TYPE
);
7523 val
= fold_ternary_loc (EXPR_LOCATION (t
), VEC_PERM_EXPR
, elttype
,
7524 args
[0], args
[1], args
[2]);
7525 if (val
!= NULL_TREE
)
7532 /* Attempt to reduce the expression T to a constant value.
7533 On failure, issue diagnostic and return error_mark_node. */
7534 /* FIXME unify with c_fully_fold */
7537 cxx_eval_constant_expression (const constexpr_call
*call
, tree t
,
7538 bool allow_non_constant
, bool addr
,
7539 bool *non_constant_p
)
7543 if (t
== error_mark_node
)
7545 *non_constant_p
= true;
7548 if (CONSTANT_CLASS_P (t
))
7550 if (TREE_CODE (t
) == PTRMEM_CST
)
7551 t
= cplus_expand_constant (t
);
7554 if (TREE_CODE (t
) != NOP_EXPR
7555 && reduced_constant_expression_p (t
))
7558 switch (TREE_CODE (t
))
7563 /* else fall through. */
7565 r
= integral_constant_value (t
);
7566 if (TREE_CODE (r
) == TARGET_EXPR
7567 && TREE_CODE (TARGET_EXPR_INITIAL (r
)) == CONSTRUCTOR
)
7568 r
= TARGET_EXPR_INITIAL (r
);
7571 if (!allow_non_constant
)
7572 non_const_var_error (r
);
7573 *non_constant_p
= true;
7583 if (call
&& DECL_CONTEXT (t
) == call
->fundef
->decl
)
7585 if (DECL_ARTIFICIAL (t
) && DECL_CONSTRUCTOR_P (DECL_CONTEXT (t
)))
7587 if (!allow_non_constant
)
7588 sorry ("use of the value of the object being constructed "
7589 "in a constant expression");
7590 *non_constant_p
= true;
7593 r
= lookup_parameter_binding (call
, t
);
7596 /* Defer in case this is only used for its type. */;
7599 if (!allow_non_constant
)
7600 error ("%qE is not a constant expression", t
);
7601 *non_constant_p
= true;
7606 case AGGR_INIT_EXPR
:
7607 r
= cxx_eval_call_expression (call
, t
, allow_non_constant
, addr
,
7612 if (!literal_type_p (TREE_TYPE (t
)))
7614 if (!allow_non_constant
)
7616 error ("temporary of non-literal type %qT in a "
7617 "constant expression", TREE_TYPE (t
));
7618 explain_non_literal_class (TREE_TYPE (t
));
7620 *non_constant_p
= true;
7623 /* else fall through. */
7625 /* Pass false for 'addr' because these codes indicate
7626 initialization of a temporary. */
7627 r
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 1),
7628 allow_non_constant
, false,
7630 if (!*non_constant_p
)
7631 /* Adjust the type of the result to the type of the temporary. */
7632 r
= adjust_temp_type (TREE_TYPE (t
), r
);
7636 r
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 1),
7637 allow_non_constant
, addr
,
7642 case NON_LVALUE_EXPR
:
7643 case TRY_CATCH_EXPR
:
7644 case CLEANUP_POINT_EXPR
:
7645 case MUST_NOT_THROW_EXPR
:
7647 r
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 0),
7648 allow_non_constant
, addr
,
7652 /* These differ from cxx_eval_unary_expression in that this doesn't
7653 check for a constant operand or result; an address can be
7654 constant without its operand being, and vice versa. */
7656 r
= cxx_eval_indirect_ref (call
, t
, allow_non_constant
, addr
,
7662 tree oldop
= TREE_OPERAND (t
, 0);
7663 tree op
= cxx_eval_constant_expression (call
, oldop
,
7667 /* Don't VERIFY_CONSTANT here. */
7668 if (*non_constant_p
)
7670 /* This function does more aggressive folding than fold itself. */
7671 r
= build_fold_addr_expr_with_type (op
, TREE_TYPE (t
));
7672 if (TREE_CODE (r
) == ADDR_EXPR
&& TREE_OPERAND (r
, 0) == oldop
)
7680 case FIX_TRUNC_EXPR
:
7685 case TRUTH_NOT_EXPR
:
7686 case FIXED_CONVERT_EXPR
:
7687 r
= cxx_eval_unary_expression (call
, t
, allow_non_constant
, addr
,
7693 /* check_return_expr sometimes wraps a TARGET_EXPR in a
7694 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
7695 introduced by build_call_a. */
7696 tree op0
= TREE_OPERAND (t
, 0);
7697 tree op1
= TREE_OPERAND (t
, 1);
7699 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
7700 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
7701 r
= cxx_eval_constant_expression (call
, op0
, allow_non_constant
,
7702 addr
, non_constant_p
);
7705 /* Check that the LHS is constant and then discard it. */
7706 cxx_eval_constant_expression (call
, op0
, allow_non_constant
,
7707 false, non_constant_p
);
7708 r
= cxx_eval_constant_expression (call
, op1
, allow_non_constant
,
7709 addr
, non_constant_p
);
7714 case POINTER_PLUS_EXPR
:
7718 case TRUNC_DIV_EXPR
:
7720 case FLOOR_DIV_EXPR
:
7721 case ROUND_DIV_EXPR
:
7722 case TRUNC_MOD_EXPR
:
7724 case ROUND_MOD_EXPR
:
7726 case EXACT_DIV_EXPR
:
7736 case TRUTH_XOR_EXPR
:
7743 case UNORDERED_EXPR
:
7752 r
= cxx_eval_binary_expression (call
, t
, allow_non_constant
, addr
,
7756 /* fold can introduce non-IF versions of these; still treat them as
7757 short-circuiting. */
7758 case TRUTH_AND_EXPR
:
7759 case TRUTH_ANDIF_EXPR
:
7760 r
= cxx_eval_logical_expression (call
, t
, boolean_false_node
,
7762 allow_non_constant
, addr
,
7767 case TRUTH_ORIF_EXPR
:
7768 r
= cxx_eval_logical_expression (call
, t
, boolean_true_node
,
7770 allow_non_constant
, addr
,
7775 r
= cxx_eval_array_reference (call
, t
, allow_non_constant
, addr
,
7780 r
= cxx_eval_component_reference (call
, t
, allow_non_constant
, addr
,
7785 r
= cxx_eval_bit_field_ref (call
, t
, allow_non_constant
, addr
,
7791 r
= cxx_eval_conditional_expression (call
, t
, allow_non_constant
, addr
,
7796 r
= cxx_eval_bare_aggregate (call
, t
, allow_non_constant
, addr
,
7801 /* We can get this in a defaulted constructor for a class with a
7802 non-static data member of array type. Either the initializer will
7803 be NULL, meaning default-initialization, or it will be an lvalue
7804 or xvalue of the same type, meaning direct-initialization from the
7805 corresponding member. */
7806 r
= cxx_eval_vec_init (call
, t
, allow_non_constant
, addr
,
7811 r
= cxx_eval_vec_perm_expr (call
, t
, allow_non_constant
, addr
,
7816 case VIEW_CONVERT_EXPR
:
7819 tree oldop
= TREE_OPERAND (t
, 0);
7820 tree op
= cxx_eval_constant_expression (call
, oldop
,
7821 allow_non_constant
, addr
,
7823 if (*non_constant_p
)
7826 /* We didn't fold at the top so we could check for ptr-int
7829 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), op
);
7830 /* Conversion of an out-of-range value has implementation-defined
7831 behavior; the language considers it different from arithmetic
7832 overflow, which is undefined. */
7833 if (TREE_OVERFLOW_P (r
) && !TREE_OVERFLOW_P (op
))
7834 TREE_OVERFLOW (r
) = false;
7838 case EMPTY_CLASS_EXPR
:
7839 /* This is good enough for a function argument that might not get
7840 used, and they can't do anything with it, so just return it. */
7844 case PREINCREMENT_EXPR
:
7845 case POSTINCREMENT_EXPR
:
7846 case PREDECREMENT_EXPR
:
7847 case POSTDECREMENT_EXPR
:
7851 case VEC_DELETE_EXPR
:
7855 /* GCC internal stuff. */
7858 case WITH_CLEANUP_EXPR
:
7859 case STATEMENT_LIST
:
7861 case NON_DEPENDENT_EXPR
:
7865 if (!allow_non_constant
)
7866 error_at (EXPR_LOC_OR_HERE (t
),
7867 "expression %qE is not a constant-expression", t
);
7868 *non_constant_p
= true;
7872 internal_error ("unexpected expression %qE of kind %s", t
,
7873 tree_code_name
[TREE_CODE (t
)]);
7874 *non_constant_p
= true;
7878 if (r
== error_mark_node
)
7879 *non_constant_p
= true;
7881 if (*non_constant_p
)
7888 cxx_eval_outermost_constant_expr (tree t
, bool allow_non_constant
)
7890 bool non_constant_p
= false;
7891 tree r
= cxx_eval_constant_expression (NULL
, t
, allow_non_constant
,
7892 false, &non_constant_p
);
7894 verify_constant (r
, allow_non_constant
, &non_constant_p
);
7896 if (TREE_CODE (t
) != CONSTRUCTOR
7897 && cp_has_mutable_p (TREE_TYPE (t
)))
7899 /* We allow a mutable type if the original expression was a
7900 CONSTRUCTOR so that we can do aggregate initialization of
7901 constexpr variables. */
7902 if (!allow_non_constant
)
7903 error ("%qT cannot be the type of a complete constant expression "
7904 "because it has mutable sub-objects", TREE_TYPE (t
));
7905 non_constant_p
= true;
7908 /* Technically we should check this for all subexpressions, but that
7909 runs into problems with our internal representation of pointer
7910 subtraction and the 5.19 rules are still in flux. */
7911 if (CONVERT_EXPR_CODE_P (TREE_CODE (r
))
7912 && ARITHMETIC_TYPE_P (TREE_TYPE (r
))
7913 && TREE_CODE (TREE_OPERAND (r
, 0)) == ADDR_EXPR
)
7915 if (!allow_non_constant
)
7916 error ("conversion from pointer type %qT "
7917 "to arithmetic type %qT in a constant-expression",
7918 TREE_TYPE (TREE_OPERAND (r
, 0)), TREE_TYPE (r
));
7919 non_constant_p
= true;
7922 if (non_constant_p
&& !allow_non_constant
)
7923 return error_mark_node
;
7924 else if (non_constant_p
&& TREE_CONSTANT (t
))
7926 /* This isn't actually constant, so unset TREE_CONSTANT. */
7927 if (EXPR_P (t
) || TREE_CODE (t
) == CONSTRUCTOR
)
7930 r
= build_nop (TREE_TYPE (t
), t
);
7931 TREE_CONSTANT (r
) = false;
7934 else if (non_constant_p
|| r
== t
)
7936 else if (TREE_CODE (r
) == CONSTRUCTOR
&& CLASS_TYPE_P (TREE_TYPE (r
)))
7938 if (TREE_CODE (t
) == TARGET_EXPR
7939 && TARGET_EXPR_INITIAL (t
) == r
)
7943 r
= get_target_expr (r
);
7944 TREE_CONSTANT (r
) = true;
7952 /* Returns true if T is a valid subexpression of a constant expression,
7953 even if it isn't itself a constant expression. */
7956 is_sub_constant_expr (tree t
)
7958 bool non_constant_p
= false;
7959 cxx_eval_constant_expression (NULL
, t
, true, false, &non_constant_p
);
7960 return !non_constant_p
;
7963 /* If T represents a constant expression returns its reduced value.
7964 Otherwise return error_mark_node. If T is dependent, then
7968 cxx_constant_value (tree t
)
7970 return cxx_eval_outermost_constant_expr (t
, false);
7973 /* If T is a constant expression, returns its reduced value.
7974 Otherwise, if T does not have TREE_CONSTANT set, returns T.
7975 Otherwise, returns a version of T without TREE_CONSTANT. */
7978 maybe_constant_value (tree t
)
7982 if (type_dependent_expression_p (t
)
7983 || type_unknown_p (t
)
7984 || BRACE_ENCLOSED_INITIALIZER_P (t
)
7985 || !potential_constant_expression (t
)
7986 || value_dependent_expression_p (t
))
7988 if (TREE_OVERFLOW_P (t
))
7990 t
= build_nop (TREE_TYPE (t
), t
);
7991 TREE_CONSTANT (t
) = false;
7996 r
= cxx_eval_outermost_constant_expr (t
, true);
7997 #ifdef ENABLE_CHECKING
7998 /* cp_tree_equal looks through NOPs, so allow them. */
8000 || CONVERT_EXPR_P (t
)
8001 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
8002 || !cp_tree_equal (r
, t
));
8007 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
8008 than wrapped in a TARGET_EXPR. */
8011 maybe_constant_init (tree t
)
8013 t
= maybe_constant_value (t
);
8014 if (TREE_CODE (t
) == TARGET_EXPR
)
8016 tree init
= TARGET_EXPR_INITIAL (t
);
8017 if (TREE_CODE (init
) == CONSTRUCTOR
8018 && TREE_CONSTANT (init
))
8025 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
8026 /* Return true if the object referred to by REF has automatic or thread
8029 enum { ck_ok
, ck_bad
, ck_unknown
};
8031 check_automatic_or_tls (tree ref
)
8033 enum machine_mode mode
;
8034 HOST_WIDE_INT bitsize
, bitpos
;
8036 int volatilep
= 0, unsignedp
= 0;
8037 tree decl
= get_inner_reference (ref
, &bitsize
, &bitpos
, &offset
,
8038 &mode
, &unsignedp
, &volatilep
, false);
8041 /* If there isn't a decl in the middle, we don't know the linkage here,
8042 and this isn't a constant expression anyway. */
8045 dk
= decl_storage_duration (decl
);
8046 return (dk
== dk_auto
|| dk
== dk_thread
) ? ck_bad
: ck_ok
;
8050 /* Return true if T denotes a potentially constant expression. Issue
8051 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
8052 an lvalue-rvalue conversion is implied.
8054 C++0x [expr.const] used to say
8056 6 An expression is a potential constant expression if it is
8057 a constant expression where all occurences of function
8058 parameters are replaced by arbitrary constant expressions
8059 of the appropriate type.
8061 2 A conditional expression is a constant expression unless it
8062 involves one of the following as a potentially evaluated
8063 subexpression (3.2), but subexpressions of logical AND (5.14),
8064 logical OR (5.15), and conditional (5.16) operations that are
8065 not evaluated are not considered. */
8068 potential_constant_expression_1 (tree t
, bool want_rval
, tsubst_flags_t flags
)
8070 enum { any
= false, rval
= true };
8074 /* C++98 has different rules for the form of a constant expression that
8075 are enforced in the parser, so we can assume that anything that gets
8076 this far is suitable. */
8077 if (cxx_dialect
< cxx0x
)
8080 if (t
== error_mark_node
)
8084 if (TREE_THIS_VOLATILE (t
))
8086 if (flags
& tf_error
)
8087 error ("expression %qE has side-effects", t
);
8090 if (CONSTANT_CLASS_P (t
))
8092 if (TREE_OVERFLOW (t
))
8094 if (flags
& tf_error
)
8096 permerror (EXPR_LOC_OR_HERE (t
),
8097 "overflow in constant expression");
8098 if (flag_permissive
)
8106 switch (TREE_CODE (t
))
8112 case TEMPLATE_ID_EXPR
:
8119 case TEMPLATE_PARM_INDEX
:
8121 case IDENTIFIER_NODE
:
8122 case USERDEF_LITERAL
:
8123 /* We can see a FIELD_DECL in a pointer-to-member expression. */
8129 case AGGR_INIT_EXPR
:
8131 /* -- an invocation of a function other than a constexpr function
8132 or a constexpr constructor. */
8134 tree fun
= get_function_named_in_call (t
);
8135 const int nargs
= call_expr_nargs (t
);
8138 if (is_overloaded_fn (fun
))
8140 if (TREE_CODE (fun
) == FUNCTION_DECL
)
8142 if (builtin_valid_in_constant_expr_p (fun
))
8144 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
8145 /* Allow any built-in function; if the expansion
8146 isn't constant, we'll deal with that then. */
8147 && !is_builtin_fn (fun
))
8149 if (flags
& tf_error
)
8151 error_at (EXPR_LOC_OR_HERE (t
),
8152 "call to non-constexpr function %qD", fun
);
8153 explain_invalid_constexpr_fn (fun
);
8157 /* A call to a non-static member function takes the address
8158 of the object as the first argument. But in a constant
8159 expression the address will be folded away, so look
8161 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
8162 && !DECL_CONSTRUCTOR_P (fun
))
8164 tree x
= get_nth_callarg (t
, 0);
8165 if (is_this_parameter (x
))
8167 if (DECL_CONSTRUCTOR_P (DECL_CONTEXT (x
)))
8169 if (flags
& tf_error
)
8170 sorry ("calling a member function of the "
8171 "object being constructed in a constant "
8175 /* Otherwise OK. */;
8177 else if (!potential_constant_expression_1 (x
, rval
, flags
))
8183 fun
= get_first_fn (fun
);
8184 /* Skip initial arguments to base constructors. */
8185 if (DECL_BASE_CONSTRUCTOR_P (fun
))
8186 i
= num_artificial_parms_for (fun
);
8187 fun
= DECL_ORIGIN (fun
);
8191 if (potential_constant_expression_1 (fun
, rval
, flags
))
8192 /* Might end up being a constant function pointer. */;
8196 for (; i
< nargs
; ++i
)
8198 tree x
= get_nth_callarg (t
, i
);
8199 if (!potential_constant_expression_1 (x
, rval
, flags
))
8205 case NON_LVALUE_EXPR
:
8206 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
8207 -- an lvalue of integral type that refers to a non-volatile
8208 const variable or static data member initialized with
8209 constant expressions, or
8211 -- an lvalue of literal type that refers to non-volatile
8212 object defined with constexpr, or that refers to a
8213 sub-object of such an object; */
8214 return potential_constant_expression_1 (TREE_OPERAND (t
, 0), rval
, flags
);
8217 if (want_rval
&& !decl_constant_var_p (t
)
8218 && !dependent_type_p (TREE_TYPE (t
)))
8220 if (flags
& tf_error
)
8221 non_const_var_error (t
);
8228 case VIEW_CONVERT_EXPR
:
8229 /* -- a reinterpret_cast. FIXME not implemented, and this rule
8230 may change to something more specific to type-punning (DR 1312). */
8232 tree from
= TREE_OPERAND (t
, 0);
8233 return (potential_constant_expression_1
8234 (from
, TREE_CODE (t
) != VIEW_CONVERT_EXPR
, flags
));
8238 /* -- a unary operator & that is applied to an lvalue that
8239 designates an object with thread or automatic storage
8241 t
= TREE_OPERAND (t
, 0);
8243 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
8244 any checking here, as we might dereference the pointer later. If
8245 we remove this code, also remove check_automatic_or_tls. */
8246 i
= check_automatic_or_tls (t
);
8251 if (flags
& tf_error
)
8252 error ("address-of an object %qE with thread local or "
8253 "automatic storage is not a constant expression", t
);
8257 return potential_constant_expression_1 (t
, any
, flags
);
8263 /* -- a class member access unless its postfix-expression is
8264 of literal type or of pointer to literal type. */
8265 /* This test would be redundant, as it follows from the
8266 postfix-expression being a potential constant expression. */
8267 return potential_constant_expression_1 (TREE_OPERAND (t
, 0),
8270 case EXPR_PACK_EXPANSION
:
8271 return potential_constant_expression_1 (PACK_EXPANSION_PATTERN (t
),
8276 tree x
= TREE_OPERAND (t
, 0);
8278 if (is_this_parameter (x
))
8280 if (want_rval
&& DECL_CONTEXT (x
)
8281 && DECL_CONSTRUCTOR_P (DECL_CONTEXT (x
)))
8283 if (flags
& tf_error
)
8284 sorry ("use of the value of the object being constructed "
8285 "in a constant expression");
8290 return potential_constant_expression_1 (x
, rval
, flags
);
8294 case DYNAMIC_CAST_EXPR
:
8295 case PSEUDO_DTOR_EXPR
:
8296 case PREINCREMENT_EXPR
:
8297 case POSTINCREMENT_EXPR
:
8298 case PREDECREMENT_EXPR
:
8299 case POSTDECREMENT_EXPR
:
8303 case VEC_DELETE_EXPR
:
8307 /* GCC internal stuff. */
8310 case WITH_CLEANUP_EXPR
:
8311 case CLEANUP_POINT_EXPR
:
8312 case MUST_NOT_THROW_EXPR
:
8313 case TRY_CATCH_EXPR
:
8314 case STATEMENT_LIST
:
8315 /* Don't bother trying to define a subset of statement-expressions to
8316 be constant-expressions, at least for now. */
8320 case TRANSACTION_EXPR
:
8325 if (flags
& tf_error
)
8326 error ("expression %qE is not a constant-expression", t
);
8330 /* -- a typeid expression whose operand is of polymorphic
8333 tree e
= TREE_OPERAND (t
, 0);
8334 if (!TYPE_P (e
) && !type_dependent_expression_p (e
)
8335 && TYPE_POLYMORPHIC_P (TREE_TYPE (e
)))
8337 if (flags
& tf_error
)
8338 error ("typeid-expression is not a constant expression "
8339 "because %qE is of polymorphic type", e
);
8346 /* -- a subtraction where both operands are pointers. */
8347 if (TYPE_PTR_P (TREE_OPERAND (t
, 0))
8348 && TYPE_PTR_P (TREE_OPERAND (t
, 1)))
8350 if (flags
& tf_error
)
8351 error ("difference of two pointer expressions is not "
8352 "a constant expression");
8364 /* -- a relational or equality operator where at least
8365 one of the operands is a pointer. */
8366 if (TYPE_PTR_P (TREE_OPERAND (t
, 0))
8367 || TYPE_PTR_P (TREE_OPERAND (t
, 1)))
8369 if (flags
& tf_error
)
8370 error ("pointer comparison expression is not a "
8371 "constant expression");
8379 if (TYPE_P (TREE_OPERAND (t
, 0)))
8381 /* else fall through. */
8387 case FIX_TRUNC_EXPR
:
8391 case TRUTH_NOT_EXPR
:
8392 case FIXED_CONVERT_EXPR
:
8393 case UNARY_PLUS_EXPR
:
8394 return potential_constant_expression_1 (TREE_OPERAND (t
, 0), rval
,
8398 case CONST_CAST_EXPR
:
8399 case STATIC_CAST_EXPR
:
8400 case REINTERPRET_CAST_EXPR
:
8401 case IMPLICIT_CONV_EXPR
:
8402 return (potential_constant_expression_1
8403 (TREE_OPERAND (t
, 0),
8404 TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
, flags
));
8407 case NON_DEPENDENT_EXPR
:
8408 /* For convenience. */
8410 return potential_constant_expression_1 (TREE_OPERAND (t
, 0),
8414 return potential_constant_expression_1 (TREE_OPERAND (t
, 1),
8418 if (!literal_type_p (TREE_TYPE (t
)))
8420 if (flags
& tf_error
)
8422 error ("temporary of non-literal type %qT in a "
8423 "constant expression", TREE_TYPE (t
));
8424 explain_non_literal_class (TREE_TYPE (t
));
8429 return potential_constant_expression_1 (TREE_OPERAND (t
, 1),
8434 VEC(constructor_elt
, gc
) *v
= CONSTRUCTOR_ELTS (t
);
8435 constructor_elt
*ce
;
8436 for (i
= 0; VEC_iterate (constructor_elt
, v
, i
, ce
); ++i
)
8437 if (!potential_constant_expression_1 (ce
->value
, want_rval
, flags
))
8444 gcc_assert (TREE_PURPOSE (t
) == NULL_TREE
8445 || DECL_P (TREE_PURPOSE (t
)));
8446 if (!potential_constant_expression_1 (TREE_VALUE (t
), want_rval
,
8449 if (TREE_CHAIN (t
) == NULL_TREE
)
8451 return potential_constant_expression_1 (TREE_CHAIN (t
), want_rval
,
8455 case TRUNC_DIV_EXPR
:
8457 case FLOOR_DIV_EXPR
:
8458 case ROUND_DIV_EXPR
:
8459 case TRUNC_MOD_EXPR
:
8461 case ROUND_MOD_EXPR
:
8463 tree denom
= TREE_OPERAND (t
, 1);
8464 /* We can't call maybe_constant_value on an expression
8465 that hasn't been through fold_non_dependent_expr yet. */
8466 if (!processing_template_decl
)
8467 denom
= maybe_constant_value (denom
);
8468 if (integer_zerop (denom
))
8470 if (flags
& tf_error
)
8471 error ("division by zero is not a constant-expression");
8483 /* check_return_expr sometimes wraps a TARGET_EXPR in a
8484 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
8485 introduced by build_call_a. */
8486 tree op0
= TREE_OPERAND (t
, 0);
8487 tree op1
= TREE_OPERAND (t
, 1);
8489 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
8490 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
8491 return potential_constant_expression_1 (op0
, want_rval
, flags
);
8496 /* If the first operand is the non-short-circuit constant, look at
8497 the second operand; otherwise we only care about the first one for
8499 case TRUTH_AND_EXPR
:
8500 case TRUTH_ANDIF_EXPR
:
8501 tmp
= boolean_true_node
;
8504 case TRUTH_ORIF_EXPR
:
8505 tmp
= boolean_false_node
;
8507 if (TREE_OPERAND (t
, 0) == tmp
)
8508 return potential_constant_expression_1 (TREE_OPERAND (t
, 1), rval
, flags
);
8510 return potential_constant_expression_1 (TREE_OPERAND (t
, 0), rval
, flags
);
8514 case POINTER_PLUS_EXPR
:
8516 case EXACT_DIV_EXPR
:
8526 case TRUTH_XOR_EXPR
:
8527 case UNORDERED_EXPR
:
8540 case ARRAY_RANGE_REF
:
8544 for (i
= 0; i
< 2; ++i
)
8545 if (!potential_constant_expression_1 (TREE_OPERAND (t
, i
),
8552 for (i
= 0; i
< 3; ++i
)
8553 if (!potential_constant_expression_1 (TREE_OPERAND (t
, i
),
8560 /* If the condition is a known constant, we know which of the legs we
8561 care about; otherwise we only require that the condition and
8562 either of the legs be potentially constant. */
8563 tmp
= TREE_OPERAND (t
, 0);
8564 if (!potential_constant_expression_1 (tmp
, rval
, flags
))
8566 else if (integer_zerop (tmp
))
8567 return potential_constant_expression_1 (TREE_OPERAND (t
, 2),
8569 else if (TREE_CODE (tmp
) == INTEGER_CST
)
8570 return potential_constant_expression_1 (TREE_OPERAND (t
, 1),
8572 for (i
= 1; i
< 3; ++i
)
8573 if (potential_constant_expression_1 (TREE_OPERAND (t
, i
),
8574 want_rval
, tf_none
))
8576 if (flags
& tf_error
)
8577 error ("expression %qE is not a constant-expression", t
);
8581 if (VEC_INIT_EXPR_IS_CONSTEXPR (t
))
8583 if (flags
& tf_error
)
8585 error ("non-constant array initialization");
8586 diagnose_non_constexpr_vec_init (t
);
8591 sorry ("unexpected AST of kind %s", tree_code_name
[TREE_CODE (t
)]);
8597 /* The main entry point to the above. */
8600 potential_constant_expression (tree t
)
8602 return potential_constant_expression_1 (t
, false, tf_none
);
8605 /* As above, but require a constant rvalue. */
8608 potential_rvalue_constant_expression (tree t
)
8610 return potential_constant_expression_1 (t
, true, tf_none
);
8613 /* Like above, but complain about non-constant expressions. */
8616 require_potential_constant_expression (tree t
)
8618 return potential_constant_expression_1 (t
, false, tf_warning_or_error
);
8621 /* Cross product of the above. */
8624 require_potential_rvalue_constant_expression (tree t
)
8626 return potential_constant_expression_1 (t
, true, tf_warning_or_error
);
8629 /* Constructor for a lambda expression. */
8632 build_lambda_expr (void)
8634 tree lambda
= make_node (LAMBDA_EXPR
);
8635 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda
) = CPLD_NONE
;
8636 LAMBDA_EXPR_CAPTURE_LIST (lambda
) = NULL_TREE
;
8637 LAMBDA_EXPR_THIS_CAPTURE (lambda
) = NULL_TREE
;
8638 LAMBDA_EXPR_PENDING_PROXIES (lambda
) = NULL
;
8639 LAMBDA_EXPR_RETURN_TYPE (lambda
) = NULL_TREE
;
8640 LAMBDA_EXPR_MUTABLE_P (lambda
) = false;
8644 /* Create the closure object for a LAMBDA_EXPR. */
8647 build_lambda_object (tree lambda_expr
)
8649 /* Build aggregate constructor call.
8650 - cp_parser_braced_list
8651 - cp_parser_functional_cast */
8652 VEC(constructor_elt
,gc
) *elts
= NULL
;
8653 tree node
, expr
, type
;
8654 location_t saved_loc
;
8656 if (processing_template_decl
)
8659 /* Make sure any error messages refer to the lambda-introducer. */
8660 saved_loc
= input_location
;
8661 input_location
= LAMBDA_EXPR_LOCATION (lambda_expr
);
8663 for (node
= LAMBDA_EXPR_CAPTURE_LIST (lambda_expr
);
8665 node
= TREE_CHAIN (node
))
8667 tree field
= TREE_PURPOSE (node
);
8668 tree val
= TREE_VALUE (node
);
8670 if (field
== error_mark_node
)
8672 expr
= error_mark_node
;
8679 /* Mere mortals can't copy arrays with aggregate initialization, so
8680 do some magic to make it work here. */
8681 if (TREE_CODE (TREE_TYPE (field
)) == ARRAY_TYPE
)
8682 val
= build_array_copy (val
);
8683 else if (DECL_NORMAL_CAPTURE_P (field
)
8684 && TREE_CODE (TREE_TYPE (field
)) != REFERENCE_TYPE
)
8686 /* "the entities that are captured by copy are used to
8687 direct-initialize each corresponding non-static data
8688 member of the resulting closure object."
8690 There's normally no way to express direct-initialization
8691 from an element of a CONSTRUCTOR, so we build up a special
8692 TARGET_EXPR to bypass the usual copy-initialization. */
8693 val
= force_rvalue (val
, tf_warning_or_error
);
8694 if (TREE_CODE (val
) == TARGET_EXPR
)
8695 TARGET_EXPR_DIRECT_INIT_P (val
) = true;
8698 CONSTRUCTOR_APPEND_ELT (elts
, DECL_NAME (field
), val
);
8701 expr
= build_constructor (init_list_type_node
, elts
);
8702 CONSTRUCTOR_IS_DIRECT_INIT (expr
) = 1;
8704 /* N2927: "[The closure] class type is not an aggregate."
8705 But we briefly treat it as an aggregate to make this simpler. */
8706 type
= LAMBDA_EXPR_CLOSURE (lambda_expr
);
8707 CLASSTYPE_NON_AGGREGATE (type
) = 0;
8708 expr
= finish_compound_literal (type
, expr
, tf_warning_or_error
);
8709 CLASSTYPE_NON_AGGREGATE (type
) = 1;
8712 input_location
= saved_loc
;
8716 /* Return an initialized RECORD_TYPE for LAMBDA.
8717 LAMBDA must have its explicit captures already. */
8720 begin_lambda_type (tree lambda
)
8725 /* Unique name. This is just like an unnamed class, but we cannot use
8726 make_anon_name because of certain checks against TYPE_ANONYMOUS_P. */
8728 name
= make_lambda_name ();
8730 /* Create the new RECORD_TYPE for this lambda. */
8731 type
= xref_tag (/*tag_code=*/record_type
,
8733 /*scope=*/ts_within_enclosing_non_class
,
8734 /*template_header_p=*/false);
8737 /* Designate it as a struct so that we can use aggregate initialization. */
8738 CLASSTYPE_DECLARED_CLASS (type
) = false;
8740 /* Clear base types. */
8741 xref_basetypes (type
, /*bases=*/NULL_TREE
);
8743 /* Start the class. */
8744 type
= begin_class_definition (type
);
8745 if (type
== error_mark_node
)
8746 return error_mark_node
;
8748 /* Cross-reference the expression and the type. */
8749 LAMBDA_EXPR_CLOSURE (lambda
) = type
;
8750 CLASSTYPE_LAMBDA_EXPR (type
) = lambda
;
8755 /* Returns the type to use for the return type of the operator() of a
8759 lambda_return_type (tree expr
)
8761 if (expr
== NULL_TREE
)
8762 return void_type_node
;
8763 if (type_unknown_p (expr
)
8764 || BRACE_ENCLOSED_INITIALIZER_P (expr
))
8766 cxx_incomplete_type_error (expr
, TREE_TYPE (expr
));
8767 return void_type_node
;
8769 gcc_checking_assert (!type_dependent_expression_p (expr
));
8770 return cv_unqualified (type_decays_to (unlowered_expr_type (expr
)));
8773 /* Given a LAMBDA_EXPR or closure type LAMBDA, return the op() of the
8777 lambda_function (tree lambda
)
8780 if (TREE_CODE (lambda
) == LAMBDA_EXPR
)
8781 type
= LAMBDA_EXPR_CLOSURE (lambda
);
8784 gcc_assert (LAMBDA_TYPE_P (type
));
8785 /* Don't let debug_tree cause instantiation. */
8786 if (CLASSTYPE_TEMPLATE_INSTANTIATION (type
)
8787 && !COMPLETE_OR_OPEN_TYPE_P (type
))
8789 lambda
= lookup_member (type
, ansi_opname (CALL_EXPR
),
8790 /*protect=*/0, /*want_type=*/false,
8791 tf_warning_or_error
);
8793 lambda
= BASELINK_FUNCTIONS (lambda
);
8797 /* Returns the type to use for the FIELD_DECL corresponding to the
8799 The caller should add REFERENCE_TYPE for capture by reference. */
8802 lambda_capture_field_type (tree expr
)
8805 if (type_dependent_expression_p (expr
))
8807 type
= cxx_make_type (DECLTYPE_TYPE
);
8808 DECLTYPE_TYPE_EXPR (type
) = expr
;
8809 DECLTYPE_FOR_LAMBDA_CAPTURE (type
) = true;
8810 SET_TYPE_STRUCTURAL_EQUALITY (type
);
8813 type
= non_reference (unlowered_expr_type (expr
));
8817 /* Insert the deduced return type for an auto function. */
8820 apply_deduced_return_type (tree fco
, tree return_type
)
8824 if (return_type
== error_mark_node
)
8827 if (LAMBDA_FUNCTION_P (fco
))
8829 tree lambda
= CLASSTYPE_LAMBDA_EXPR (current_class_type
);
8830 LAMBDA_EXPR_RETURN_TYPE (lambda
) = return_type
;
8833 if (DECL_CONV_FN_P (fco
))
8834 DECL_NAME (fco
) = mangle_conv_op_name_for_type (return_type
);
8836 TREE_TYPE (fco
) = change_return_type (return_type
, TREE_TYPE (fco
));
8838 result
= DECL_RESULT (fco
);
8839 if (result
== NULL_TREE
)
8841 if (TREE_TYPE (result
) == return_type
)
8844 /* We already have a DECL_RESULT from start_preparsed_function.
8845 Now we need to redo the work it and allocate_struct_function
8846 did to reflect the new type. */
8847 gcc_assert (current_function_decl
== fco
);
8848 result
= build_decl (input_location
, RESULT_DECL
, NULL_TREE
,
8849 TYPE_MAIN_VARIANT (return_type
));
8850 DECL_ARTIFICIAL (result
) = 1;
8851 DECL_IGNORED_P (result
) = 1;
8852 cp_apply_type_quals_to_decl (cp_type_quals (return_type
),
8855 DECL_RESULT (fco
) = result
;
8857 if (!processing_template_decl
)
8859 bool aggr
= aggregate_value_p (result
, fco
);
8860 #ifdef PCC_STATIC_STRUCT_RETURN
8861 cfun
->returns_pcc_struct
= aggr
;
8863 cfun
->returns_struct
= aggr
;
8868 /* DECL is a local variable or parameter from the surrounding scope of a
8869 lambda-expression. Returns the decltype for a use of the capture field
8870 for DECL even if it hasn't been captured yet. */
8873 capture_decltype (tree decl
)
8875 tree lam
= CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (current_function_decl
));
8876 /* FIXME do lookup instead of list walk? */
8877 tree cap
= value_member (decl
, LAMBDA_EXPR_CAPTURE_LIST (lam
));
8881 type
= TREE_TYPE (TREE_PURPOSE (cap
));
8883 switch (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lam
))
8886 error ("%qD is not captured", decl
);
8887 return error_mark_node
;
8890 type
= TREE_TYPE (decl
);
8891 if (TREE_CODE (type
) == REFERENCE_TYPE
8892 && TREE_CODE (TREE_TYPE (type
)) != FUNCTION_TYPE
)
8893 type
= TREE_TYPE (type
);
8896 case CPLD_REFERENCE
:
8897 type
= TREE_TYPE (decl
);
8898 if (TREE_CODE (type
) != REFERENCE_TYPE
)
8899 type
= build_reference_type (TREE_TYPE (decl
));
8906 if (TREE_CODE (type
) != REFERENCE_TYPE
)
8908 if (!LAMBDA_EXPR_MUTABLE_P (lam
))
8909 type
= cp_build_qualified_type (type
, (cp_type_quals (type
)
8911 type
= build_reference_type (type
);
8916 /* Returns true iff DECL is a lambda capture proxy variable created by
8917 build_capture_proxy. */
8920 is_capture_proxy (tree decl
)
8922 return (TREE_CODE (decl
) == VAR_DECL
8923 && DECL_HAS_VALUE_EXPR_P (decl
)
8924 && !DECL_ANON_UNION_VAR_P (decl
)
8925 && LAMBDA_FUNCTION_P (DECL_CONTEXT (decl
)));
8928 /* Returns true iff DECL is a capture proxy for a normal capture
8929 (i.e. without explicit initializer). */
8932 is_normal_capture_proxy (tree decl
)
8936 if (!is_capture_proxy (decl
))
8937 /* It's not a capture proxy. */
8940 /* It is a capture proxy, is it a normal capture? */
8941 val
= DECL_VALUE_EXPR (decl
);
8942 gcc_assert (TREE_CODE (val
) == COMPONENT_REF
);
8943 val
= TREE_OPERAND (val
, 1);
8944 return DECL_NORMAL_CAPTURE_P (val
);
8947 /* VAR is a capture proxy created by build_capture_proxy; add it to the
8948 current function, which is the operator() for the appropriate lambda. */
8951 insert_capture_proxy (tree var
)
8953 cp_binding_level
*b
;
8957 /* Put the capture proxy in the extra body block so that it won't clash
8958 with a later local variable. */
8959 b
= current_binding_level
;
8960 for (skip
= 0; ; ++skip
)
8962 cp_binding_level
*n
= b
->level_chain
;
8963 if (n
->kind
== sk_function_parms
)
8967 pushdecl_with_scope (var
, b
, false);
8969 /* And put a DECL_EXPR in the STATEMENT_LIST for the same block. */
8970 var
= build_stmt (DECL_SOURCE_LOCATION (var
), DECL_EXPR
, var
);
8971 stmt_list
= VEC_index (tree
, stmt_list_stack
,
8972 VEC_length (tree
, stmt_list_stack
) - 1 - skip
);
8973 gcc_assert (stmt_list
);
8974 append_to_statement_list_force (var
, &stmt_list
);
8977 /* We've just finished processing a lambda; if the containing scope is also
8978 a lambda, insert any capture proxies that were created while processing
8979 the nested lambda. */
8982 insert_pending_capture_proxies (void)
8985 VEC(tree
,gc
) *proxies
;
8988 if (!current_function_decl
|| !LAMBDA_FUNCTION_P (current_function_decl
))
8991 lam
= CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (current_function_decl
));
8992 proxies
= LAMBDA_EXPR_PENDING_PROXIES (lam
);
8993 for (i
= 0; i
< VEC_length (tree
, proxies
); ++i
)
8995 tree var
= VEC_index (tree
, proxies
, i
);
8996 insert_capture_proxy (var
);
8998 release_tree_vector (LAMBDA_EXPR_PENDING_PROXIES (lam
));
8999 LAMBDA_EXPR_PENDING_PROXIES (lam
) = NULL
;
9002 /* Given REF, a COMPONENT_REF designating a field in the lambda closure,
9003 return the type we want the proxy to have: the type of the field itself,
9004 with added const-qualification if the lambda isn't mutable and the
9005 capture is by value. */
9008 lambda_proxy_type (tree ref
)
9011 if (REFERENCE_REF_P (ref
))
9012 ref
= TREE_OPERAND (ref
, 0);
9013 type
= TREE_TYPE (ref
);
9014 if (!dependent_type_p (type
))
9016 type
= cxx_make_type (DECLTYPE_TYPE
);
9017 DECLTYPE_TYPE_EXPR (type
) = ref
;
9018 DECLTYPE_FOR_LAMBDA_PROXY (type
) = true;
9019 SET_TYPE_STRUCTURAL_EQUALITY (type
);
9023 /* MEMBER is a capture field in a lambda closure class. Now that we're
9024 inside the operator(), build a placeholder var for future lookups and
9028 build_capture_proxy (tree member
)
9030 tree var
, object
, fn
, closure
, name
, lam
, type
;
9032 closure
= DECL_CONTEXT (member
);
9033 fn
= lambda_function (closure
);
9034 lam
= CLASSTYPE_LAMBDA_EXPR (closure
);
9036 /* The proxy variable forwards to the capture field. */
9037 object
= build_fold_indirect_ref (DECL_ARGUMENTS (fn
));
9038 object
= finish_non_static_data_member (member
, object
, NULL_TREE
);
9039 if (REFERENCE_REF_P (object
))
9040 object
= TREE_OPERAND (object
, 0);
9042 /* Remove the __ inserted by add_capture. */
9043 name
= get_identifier (IDENTIFIER_POINTER (DECL_NAME (member
)) + 2);
9045 type
= lambda_proxy_type (object
);
9046 var
= build_decl (input_location
, VAR_DECL
, name
, type
);
9047 SET_DECL_VALUE_EXPR (var
, object
);
9048 DECL_HAS_VALUE_EXPR_P (var
) = 1;
9049 DECL_ARTIFICIAL (var
) = 1;
9050 TREE_USED (var
) = 1;
9051 DECL_CONTEXT (var
) = fn
;
9053 if (name
== this_identifier
)
9055 gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (lam
) == member
);
9056 LAMBDA_EXPR_THIS_CAPTURE (lam
) = var
;
9059 if (fn
== current_function_decl
)
9060 insert_capture_proxy (var
);
9062 VEC_safe_push (tree
, gc
, LAMBDA_EXPR_PENDING_PROXIES (lam
), var
);
9067 /* From an ID and INITIALIZER, create a capture (by reference if
9068 BY_REFERENCE_P is true), add it to the capture-list for LAMBDA,
9072 add_capture (tree lambda
, tree id
, tree initializer
, bool by_reference_p
,
9073 bool explicit_init_p
)
9076 tree type
, member
, name
;
9078 type
= lambda_capture_field_type (initializer
);
9081 type
= build_reference_type (type
);
9082 if (!real_lvalue_p (initializer
))
9083 error ("cannot capture %qE by reference", initializer
);
9086 /* Capture by copy requires a complete type. */
9087 type
= complete_type (type
);
9089 /* Add __ to the beginning of the field name so that user code
9090 won't find the field with name lookup. We can't just leave the name
9091 unset because template instantiation uses the name to find
9092 instantiated fields. */
9093 buf
= (char *) alloca (IDENTIFIER_LENGTH (id
) + 3);
9094 buf
[1] = buf
[0] = '_';
9095 memcpy (buf
+ 2, IDENTIFIER_POINTER (id
),
9096 IDENTIFIER_LENGTH (id
) + 1);
9097 name
= get_identifier (buf
);
9099 /* If TREE_TYPE isn't set, we're still in the introducer, so check
9101 if (!LAMBDA_EXPR_CLOSURE (lambda
))
9103 if (IDENTIFIER_MARKED (name
))
9105 pedwarn (input_location
, 0,
9106 "already captured %qD in lambda expression", id
);
9109 IDENTIFIER_MARKED (name
) = true;
9112 /* Make member variable. */
9113 member
= build_lang_decl (FIELD_DECL
, name
, type
);
9115 if (!explicit_init_p
)
9116 /* Normal captures are invisible to name lookup but uses are replaced
9117 with references to the capture field; we implement this by only
9118 really making them invisible in unevaluated context; see
9119 qualify_lookup. For now, let's make explicitly initialized captures
9121 DECL_NORMAL_CAPTURE_P (member
) = true;
9123 if (id
== this_identifier
)
9124 LAMBDA_EXPR_THIS_CAPTURE (lambda
) = member
;
9126 /* Add it to the appropriate closure class if we've started it. */
9127 if (current_class_type
9128 && current_class_type
== LAMBDA_EXPR_CLOSURE (lambda
))
9129 finish_member_declaration (member
);
9131 LAMBDA_EXPR_CAPTURE_LIST (lambda
)
9132 = tree_cons (member
, initializer
, LAMBDA_EXPR_CAPTURE_LIST (lambda
));
9134 if (LAMBDA_EXPR_CLOSURE (lambda
))
9135 return build_capture_proxy (member
);
9136 /* For explicit captures we haven't started the function yet, so we wait
9137 and build the proxy from cp_parser_lambda_body. */
9141 /* Register all the capture members on the list CAPTURES, which is the
9142 LAMBDA_EXPR_CAPTURE_LIST for the lambda after the introducer. */
9145 register_capture_members (tree captures
)
9147 if (captures
== NULL_TREE
)
9150 register_capture_members (TREE_CHAIN (captures
));
9151 /* We set this in add_capture to avoid duplicates. */
9152 IDENTIFIER_MARKED (DECL_NAME (TREE_PURPOSE (captures
))) = false;
9153 finish_member_declaration (TREE_PURPOSE (captures
));
9156 /* Similar to add_capture, except this works on a stack of nested lambdas.
9157 BY_REFERENCE_P in this case is derived from the default capture mode.
9158 Returns the capture for the lambda at the bottom of the stack. */
9161 add_default_capture (tree lambda_stack
, tree id
, tree initializer
)
9163 bool this_capture_p
= (id
== this_identifier
);
9165 tree var
= NULL_TREE
;
9167 tree saved_class_type
= current_class_type
;
9171 for (node
= lambda_stack
;
9173 node
= TREE_CHAIN (node
))
9175 tree lambda
= TREE_VALUE (node
);
9177 current_class_type
= LAMBDA_EXPR_CLOSURE (lambda
);
9178 var
= add_capture (lambda
,
9183 && (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda
)
9184 == CPLD_REFERENCE
)),
9185 /*explicit_init_p=*/false);
9186 initializer
= convert_from_reference (var
);
9189 current_class_type
= saved_class_type
;
9194 /* Return the capture pertaining to a use of 'this' in LAMBDA, in the form of an
9195 INDIRECT_REF, possibly adding it through default capturing. */
9198 lambda_expr_this_capture (tree lambda
)
9202 tree this_capture
= LAMBDA_EXPR_THIS_CAPTURE (lambda
);
9204 /* Try to default capture 'this' if we can. */
9206 && LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda
) != CPLD_NONE
)
9208 tree containing_function
= TYPE_CONTEXT (LAMBDA_EXPR_CLOSURE (lambda
));
9209 tree lambda_stack
= tree_cons (NULL_TREE
, lambda
, NULL_TREE
);
9210 tree init
= NULL_TREE
;
9212 /* If we are in a lambda function, we can move out until we hit:
9213 1. a non-lambda function,
9214 2. a lambda function capturing 'this', or
9215 3. a non-default capturing lambda function. */
9216 while (LAMBDA_FUNCTION_P (containing_function
))
9219 = CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (containing_function
));
9221 if (LAMBDA_EXPR_THIS_CAPTURE (lambda
))
9223 /* An outer lambda has already captured 'this'. */
9224 init
= LAMBDA_EXPR_THIS_CAPTURE (lambda
);
9228 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda
) == CPLD_NONE
)
9229 /* An outer lambda won't let us capture 'this'. */
9232 lambda_stack
= tree_cons (NULL_TREE
,
9236 containing_function
= decl_function_context (containing_function
);
9239 if (!init
&& DECL_NONSTATIC_MEMBER_FUNCTION_P (containing_function
)
9240 && !LAMBDA_FUNCTION_P (containing_function
))
9241 /* First parameter is 'this'. */
9242 init
= DECL_ARGUMENTS (containing_function
);
9245 this_capture
= add_default_capture (lambda_stack
,
9246 /*id=*/this_identifier
,
9252 error ("%<this%> was not captured for this lambda function");
9253 result
= error_mark_node
;
9257 /* To make sure that current_class_ref is for the lambda. */
9258 gcc_assert (TYPE_MAIN_VARIANT (TREE_TYPE (current_class_ref
))
9259 == LAMBDA_EXPR_CLOSURE (lambda
));
9261 result
= this_capture
;
9263 /* If 'this' is captured, each use of 'this' is transformed into an
9264 access to the corresponding unnamed data member of the closure
9265 type cast (_expr.cast_ 5.4) to the type of 'this'. [ The cast
9266 ensures that the transformed expression is an rvalue. ] */
9267 result
= rvalue (result
);
9273 /* Returns the method basetype of the innermost non-lambda function, or
9274 NULL_TREE if none. */
9277 nonlambda_method_basetype (void)
9280 if (!current_class_ref
)
9283 type
= current_class_type
;
9284 if (!LAMBDA_TYPE_P (type
))
9287 /* Find the nearest enclosing non-lambda function. */
9288 fn
= TYPE_NAME (type
);
9290 fn
= decl_function_context (fn
);
9291 while (fn
&& LAMBDA_FUNCTION_P (fn
));
9293 if (!fn
|| !DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
9296 return TYPE_METHOD_BASETYPE (TREE_TYPE (fn
));
9299 /* If the closure TYPE has a static op(), also add a conversion to function
9303 maybe_add_lambda_conv_op (tree type
)
9305 bool nested
= (current_function_decl
!= NULL_TREE
);
9306 tree callop
= lambda_function (type
);
9307 tree rettype
, name
, fntype
, fn
, body
, compound_stmt
;
9308 tree thistype
, stattype
, statfn
, convfn
, call
, arg
;
9309 VEC (tree
, gc
) *argvec
;
9311 if (LAMBDA_EXPR_CAPTURE_LIST (CLASSTYPE_LAMBDA_EXPR (type
)) != NULL_TREE
)
9314 if (processing_template_decl
)
9317 stattype
= build_function_type (TREE_TYPE (TREE_TYPE (callop
)),
9318 FUNCTION_ARG_CHAIN (callop
));
9320 /* First build up the conversion op. */
9322 rettype
= build_pointer_type (stattype
);
9323 name
= mangle_conv_op_name_for_type (rettype
);
9324 thistype
= cp_build_qualified_type (type
, TYPE_QUAL_CONST
);
9325 fntype
= build_method_type_directly (thistype
, rettype
, void_list_node
);
9326 fn
= convfn
= build_lang_decl (FUNCTION_DECL
, name
, fntype
);
9327 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (callop
);
9329 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
9330 && DECL_ALIGN (fn
) < 2 * BITS_PER_UNIT
)
9331 DECL_ALIGN (fn
) = 2 * BITS_PER_UNIT
;
9333 SET_OVERLOADED_OPERATOR_CODE (fn
, TYPE_EXPR
);
9334 grokclassfn (type
, fn
, NO_SPECIAL
);
9335 set_linkage_according_to_type (type
, fn
);
9336 rest_of_decl_compilation (fn
, toplevel_bindings_p (), at_eof
);
9337 DECL_IN_AGGR_P (fn
) = 1;
9338 DECL_ARTIFICIAL (fn
) = 1;
9339 DECL_NOT_REALLY_EXTERN (fn
) = 1;
9340 DECL_DECLARED_INLINE_P (fn
) = 1;
9341 DECL_ARGUMENTS (fn
) = build_this_parm (fntype
, TYPE_QUAL_CONST
);
9343 add_method (type
, fn
, NULL_TREE
);
9345 /* Generic thunk code fails for varargs; we'll complain in mark_used if
9346 the conversion op is used. */
9347 if (varargs_function_p (callop
))
9349 DECL_DELETED_FN (fn
) = 1;
9353 /* Now build up the thunk to be returned. */
9355 name
= get_identifier ("_FUN");
9356 fn
= statfn
= build_lang_decl (FUNCTION_DECL
, name
, stattype
);
9357 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (callop
);
9358 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
9359 && DECL_ALIGN (fn
) < 2 * BITS_PER_UNIT
)
9360 DECL_ALIGN (fn
) = 2 * BITS_PER_UNIT
;
9361 grokclassfn (type
, fn
, NO_SPECIAL
);
9362 set_linkage_according_to_type (type
, fn
);
9363 rest_of_decl_compilation (fn
, toplevel_bindings_p (), at_eof
);
9364 DECL_IN_AGGR_P (fn
) = 1;
9365 DECL_ARTIFICIAL (fn
) = 1;
9366 DECL_NOT_REALLY_EXTERN (fn
) = 1;
9367 DECL_DECLARED_INLINE_P (fn
) = 1;
9368 DECL_STATIC_FUNCTION_P (fn
) = 1;
9369 DECL_ARGUMENTS (fn
) = copy_list (DECL_CHAIN (DECL_ARGUMENTS (callop
)));
9370 for (arg
= DECL_ARGUMENTS (fn
); arg
; arg
= DECL_CHAIN (arg
))
9371 DECL_CONTEXT (arg
) = fn
;
9373 add_method (type
, fn
, NULL_TREE
);
9376 push_function_context ();
9378 /* Still increment function_depth so that we don't GC in the
9379 middle of an expression. */
9382 /* Generate the body of the thunk. */
9384 start_preparsed_function (statfn
, NULL_TREE
,
9385 SF_PRE_PARSED
| SF_INCLASS_INLINE
);
9386 if (DECL_ONE_ONLY (statfn
))
9388 /* Put the thunk in the same comdat group as the call op. */
9389 symtab_add_to_same_comdat_group
9390 ((symtab_node
) cgraph_get_create_node (statfn
),
9391 (symtab_node
) cgraph_get_create_node (callop
));
9393 body
= begin_function_body ();
9394 compound_stmt
= begin_compound_stmt (0);
9396 arg
= build1 (NOP_EXPR
, TREE_TYPE (DECL_ARGUMENTS (callop
)),
9398 argvec
= make_tree_vector ();
9399 VEC_quick_push (tree
, argvec
, arg
);
9400 for (arg
= DECL_ARGUMENTS (statfn
); arg
; arg
= DECL_CHAIN (arg
))
9402 mark_exp_read (arg
);
9403 VEC_safe_push (tree
, gc
, argvec
, arg
);
9405 call
= build_call_a (callop
, VEC_length (tree
, argvec
),
9406 VEC_address (tree
, argvec
));
9407 CALL_FROM_THUNK_P (call
) = 1;
9408 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (call
)))
9409 call
= build_cplus_new (TREE_TYPE (call
), call
, tf_warning_or_error
);
9410 call
= convert_from_reference (call
);
9411 finish_return_stmt (call
);
9413 finish_compound_stmt (compound_stmt
);
9414 finish_function_body (body
);
9416 expand_or_defer_fn (finish_function (2));
9418 /* Generate the body of the conversion op. */
9420 start_preparsed_function (convfn
, NULL_TREE
,
9421 SF_PRE_PARSED
| SF_INCLASS_INLINE
);
9422 body
= begin_function_body ();
9423 compound_stmt
= begin_compound_stmt (0);
9425 finish_return_stmt (decay_conversion (statfn
, tf_warning_or_error
));
9427 finish_compound_stmt (compound_stmt
);
9428 finish_function_body (body
);
9430 expand_or_defer_fn (finish_function (2));
9433 pop_function_context ();
9438 /* Returns true iff VAL is a lambda-related declaration which should
9439 be ignored by unqualified lookup. */
9442 is_lambda_ignored_entity (tree val
)
9444 /* In unevaluated context, look past normal capture proxies. */
9445 if (cp_unevaluated_operand
&& is_normal_capture_proxy (val
))
9448 /* Always ignore lambda fields, their names are only for debugging. */
9449 if (TREE_CODE (val
) == FIELD_DECL
9450 && CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (val
)))
9453 /* None of the lookups that use qualify_lookup want the op() from the
9454 lambda; they want the one from the enclosing class. */
9455 if (TREE_CODE (val
) == FUNCTION_DECL
&& LAMBDA_FUNCTION_P (val
))
9461 #include "gt-cp-semantics.h"