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-2013 Free Software Foundation, Inc.
7 Written by Mark Mitchell (mmitchell@usa.net) based on code found
8 formerly in parse.y and pt.c.
10 This file is part of GCC.
12 GCC is free software; you can redistribute it and/or modify it
13 under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 3, or (at your option)
17 GCC is distributed in the hope that it will be useful, but
18 WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 General Public License for more details.
22 You should have received a copy of the GNU General Public License
23 along with GCC; see the file COPYING3. If not see
24 <http://www.gnu.org/licenses/>. */
28 #include "coretypes.h"
32 #include "c-family/c-common.h"
33 #include "c-family/c-objc.h"
34 #include "tree-inline.h"
39 #include "diagnostic.h"
41 #include "tree-iterator.h"
46 #include "hash-table.h"
48 static bool verify_constant (tree, bool, bool *, bool *);
49 #define VERIFY_CONSTANT(X) \
51 if (verify_constant ((X), allow_non_constant, non_constant_p, overflow_p)) \
55 /* There routines provide a modular interface to perform many parsing
56 operations. They may therefore be used during actual parsing, or
57 during template instantiation, which may be regarded as a
58 degenerate form of parsing. */
60 static tree maybe_convert_cond (tree);
61 static tree finalize_nrv_r (tree *, int *, void *);
62 static tree capture_decltype (tree);
65 /* Deferred Access Checking Overview
66 ---------------------------------
68 Most C++ expressions and declarations require access checking
69 to be performed during parsing. However, in several cases,
70 this has to be treated differently.
72 For member declarations, access checking has to be deferred
73 until more information about the declaration is known. For
85 When we are parsing the function return type `A::X', we don't
86 really know if this is allowed until we parse the function name.
88 Furthermore, some contexts require that access checking is
89 never performed at all. These include class heads, and template
92 Typical use of access checking functions is described here:
94 1. When we enter a context that requires certain access checking
95 mode, the function `push_deferring_access_checks' is called with
96 DEFERRING argument specifying the desired mode. Access checking
97 may be performed immediately (dk_no_deferred), deferred
98 (dk_deferred), or not performed (dk_no_check).
100 2. When a declaration such as a type, or a variable, is encountered,
101 the function `perform_or_defer_access_check' is called. It
102 maintains a vector of all deferred checks.
104 3. The global `current_class_type' or `current_function_decl' is then
105 setup by the parser. `enforce_access' relies on these information
108 4. Upon exiting the context mentioned in step 1,
109 `perform_deferred_access_checks' is called to check all declaration
110 stored in the vector. `pop_deferring_access_checks' is then
111 called to restore the previous access checking mode.
113 In case of parsing error, we simply call `pop_deferring_access_checks'
114 without `perform_deferred_access_checks'. */
116 typedef struct GTY(()) deferred_access {
117 /* A vector representing name-lookups for which we have deferred
118 checking access controls. We cannot check the accessibility of
119 names used in a decl-specifier-seq until we know what is being
120 declared because code like:
127 A::B* A::f() { return 0; }
129 is valid, even though `A::B' is not generally accessible. */
130 vec<deferred_access_check, va_gc> * GTY(()) deferred_access_checks;
132 /* The current mode of access checks. */
133 enum deferring_kind deferring_access_checks_kind;
137 /* Data for deferred access checking. */
138 static GTY(()) vec<deferred_access, va_gc> *deferred_access_stack;
139 static GTY(()) unsigned deferred_access_no_check;
141 /* Save the current deferred access states and start deferred
142 access checking iff DEFER_P is true. */
145 push_deferring_access_checks (deferring_kind deferring)
147 /* For context like template instantiation, access checking
148 disabling applies to all nested context. */
149 if (deferred_access_no_check || deferring == dk_no_check)
150 deferred_access_no_check++;
153 deferred_access e = {NULL, deferring};
154 vec_safe_push (deferred_access_stack, e);
158 /* Save the current deferred access states and start deferred access
159 checking, continuing the set of deferred checks in CHECKS. */
162 reopen_deferring_access_checks (vec<deferred_access_check, va_gc> * checks)
164 push_deferring_access_checks (dk_deferred);
165 if (!deferred_access_no_check)
166 deferred_access_stack->last().deferred_access_checks = checks;
169 /* Resume deferring access checks again after we stopped doing
173 resume_deferring_access_checks (void)
175 if (!deferred_access_no_check)
176 deferred_access_stack->last().deferring_access_checks_kind = dk_deferred;
179 /* Stop deferring access checks. */
182 stop_deferring_access_checks (void)
184 if (!deferred_access_no_check)
185 deferred_access_stack->last().deferring_access_checks_kind = dk_no_deferred;
188 /* Discard the current deferred access checks and restore the
192 pop_deferring_access_checks (void)
194 if (deferred_access_no_check)
195 deferred_access_no_check--;
197 deferred_access_stack->pop ();
200 /* Returns a TREE_LIST representing the deferred checks.
201 The TREE_PURPOSE of each node is the type through which the
202 access occurred; the TREE_VALUE is the declaration named.
205 vec<deferred_access_check, va_gc> *
206 get_deferred_access_checks (void)
208 if (deferred_access_no_check)
211 return (deferred_access_stack->last().deferred_access_checks);
214 /* Take current deferred checks and combine with the
215 previous states if we also defer checks previously.
216 Otherwise perform checks now. */
219 pop_to_parent_deferring_access_checks (void)
221 if (deferred_access_no_check)
222 deferred_access_no_check--;
225 vec<deferred_access_check, va_gc> *checks;
226 deferred_access *ptr;
228 checks = (deferred_access_stack->last ().deferred_access_checks);
230 deferred_access_stack->pop ();
231 ptr = &deferred_access_stack->last ();
232 if (ptr->deferring_access_checks_kind == dk_no_deferred)
235 perform_access_checks (checks, tf_warning_or_error);
239 /* Merge with parent. */
241 deferred_access_check *chk, *probe;
243 FOR_EACH_VEC_SAFE_ELT (checks, i, chk)
245 FOR_EACH_VEC_SAFE_ELT (ptr->deferred_access_checks, j, probe)
247 if (probe->binfo == chk->binfo &&
248 probe->decl == chk->decl &&
249 probe->diag_decl == chk->diag_decl)
252 /* Insert into parent's checks. */
253 vec_safe_push (ptr->deferred_access_checks, *chk);
260 /* Perform the access checks in CHECKS. The TREE_PURPOSE of each node
261 is the BINFO indicating the qualifying scope used to access the
262 DECL node stored in the TREE_VALUE of the node. If CHECKS is empty
263 or we aren't in SFINAE context or all the checks succeed return TRUE,
267 perform_access_checks (vec<deferred_access_check, va_gc> *checks,
268 tsubst_flags_t complain)
271 deferred_access_check *chk;
272 location_t loc = input_location;
278 FOR_EACH_VEC_SAFE_ELT (checks, i, chk)
280 input_location = chk->loc;
281 ok &= enforce_access (chk->binfo, chk->decl, chk->diag_decl, complain);
284 input_location = loc;
285 return (complain & tf_error) ? true : ok;
288 /* Perform the deferred access checks.
290 After performing the checks, we still have to keep the list
291 `deferred_access_stack->deferred_access_checks' since we may want
292 to check access for them again later in a different context.
299 A::X A::a, x; // No error for `A::a', error for `x'
301 We have to perform deferred access of `A::X', first with `A::a',
302 next with `x'. Return value like perform_access_checks above. */
305 perform_deferred_access_checks (tsubst_flags_t complain)
307 return perform_access_checks (get_deferred_access_checks (), complain);
310 /* Defer checking the accessibility of DECL, when looked up in
311 BINFO. DIAG_DECL is the declaration to use to print diagnostics.
312 Return value like perform_access_checks above. */
315 perform_or_defer_access_check (tree binfo, tree decl, tree diag_decl,
316 tsubst_flags_t complain)
319 deferred_access *ptr;
320 deferred_access_check *chk;
323 /* Exit if we are in a context that no access checking is performed.
325 if (deferred_access_no_check)
328 gcc_assert (TREE_CODE (binfo) == TREE_BINFO);
330 ptr = &deferred_access_stack->last ();
332 /* If we are not supposed to defer access checks, just check now. */
333 if (ptr->deferring_access_checks_kind == dk_no_deferred)
335 bool ok = enforce_access (binfo, decl, diag_decl, complain);
336 return (complain & tf_error) ? true : ok;
339 /* See if we are already going to perform this check. */
340 FOR_EACH_VEC_SAFE_ELT (ptr->deferred_access_checks, i, chk)
342 if (chk->decl == decl && chk->binfo == binfo &&
343 chk->diag_decl == diag_decl)
348 /* If not, record the check. */
349 deferred_access_check new_access = {binfo, decl, diag_decl, input_location};
350 vec_safe_push (ptr->deferred_access_checks, new_access);
355 /* Returns nonzero if the current statement is a full expression,
356 i.e. temporaries created during that statement should be destroyed
357 at the end of the statement. */
360 stmts_are_full_exprs_p (void)
362 return current_stmt_tree ()->stmts_are_full_exprs_p;
365 /* T is a statement. Add it to the statement-tree. This is the C++
366 version. The C/ObjC frontends have a slightly different version of
372 enum tree_code code = TREE_CODE (t);
374 if (EXPR_P (t) && code != LABEL_EXPR)
376 if (!EXPR_HAS_LOCATION (t))
377 SET_EXPR_LOCATION (t, input_location);
379 /* When we expand a statement-tree, we must know whether or not the
380 statements are full-expressions. We record that fact here. */
381 STMT_IS_FULL_EXPR_P (t) = stmts_are_full_exprs_p ();
384 /* Add T to the statement-tree. Non-side-effect statements need to be
385 recorded during statement expressions. */
386 gcc_checking_assert (!stmt_list_stack->is_empty ());
387 append_to_statement_list_force (t, &cur_stmt_list);
392 /* Returns the stmt_tree to which statements are currently being added. */
395 current_stmt_tree (void)
398 ? &cfun->language->base.x_stmt_tree
399 : &scope_chain->x_stmt_tree);
402 /* If statements are full expressions, wrap STMT in a CLEANUP_POINT_EXPR. */
405 maybe_cleanup_point_expr (tree expr)
407 if (!processing_template_decl && stmts_are_full_exprs_p ())
408 expr = fold_build_cleanup_point_expr (TREE_TYPE (expr), expr);
412 /* Like maybe_cleanup_point_expr except have the type of the new expression be
413 void so we don't need to create a temporary variable to hold the inner
414 expression. The reason why we do this is because the original type might be
415 an aggregate and we cannot create a temporary variable for that type. */
418 maybe_cleanup_point_expr_void (tree expr)
420 if (!processing_template_decl && stmts_are_full_exprs_p ())
421 expr = fold_build_cleanup_point_expr (void_type_node, expr);
427 /* Create a declaration statement for the declaration given by the DECL. */
430 add_decl_expr (tree decl)
432 tree r = build_stmt (input_location, DECL_EXPR, decl);
433 if (DECL_INITIAL (decl)
434 || (DECL_SIZE (decl) && TREE_SIDE_EFFECTS (DECL_SIZE (decl))))
435 r = maybe_cleanup_point_expr_void (r);
439 /* Finish a scope. */
442 do_poplevel (tree stmt_list)
446 if (stmts_are_full_exprs_p ())
447 block = poplevel (kept_level_p (), 1, 0);
449 stmt_list = pop_stmt_list (stmt_list);
451 if (!processing_template_decl)
453 stmt_list = c_build_bind_expr (input_location, block, stmt_list);
454 /* ??? See c_end_compound_stmt re statement expressions. */
460 /* Begin a new scope. */
463 do_pushlevel (scope_kind sk)
465 tree ret = push_stmt_list ();
466 if (stmts_are_full_exprs_p ())
467 begin_scope (sk, NULL);
471 /* Queue a cleanup. CLEANUP is an expression/statement to be executed
472 when the current scope is exited. EH_ONLY is true when this is not
473 meant to apply to normal control flow transfer. */
476 push_cleanup (tree decl, tree cleanup, bool eh_only)
478 tree stmt = build_stmt (input_location, CLEANUP_STMT, NULL, cleanup, decl);
479 CLEANUP_EH_ONLY (stmt) = eh_only;
481 CLEANUP_BODY (stmt) = push_stmt_list ();
484 /* Begin a conditional that might contain a declaration. When generating
485 normal code, we want the declaration to appear before the statement
486 containing the conditional. When generating template code, we want the
487 conditional to be rendered as the raw DECL_EXPR. */
490 begin_cond (tree *cond_p)
492 if (processing_template_decl)
493 *cond_p = push_stmt_list ();
496 /* Finish such a conditional. */
499 finish_cond (tree *cond_p, tree expr)
501 if (processing_template_decl)
503 tree cond = pop_stmt_list (*cond_p);
505 if (expr == NULL_TREE)
506 /* Empty condition in 'for'. */
507 gcc_assert (empty_expr_stmt_p (cond));
508 else if (check_for_bare_parameter_packs (expr))
509 expr = error_mark_node;
510 else if (!empty_expr_stmt_p (cond))
511 expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr), cond, expr);
516 /* If *COND_P specifies a conditional with a declaration, transform the
519 for (; A x = 42;) { }
521 while (true) { A x = 42; if (!x) break; }
522 for (;;) { A x = 42; if (!x) break; }
523 The statement list for BODY will be empty if the conditional did
524 not declare anything. */
527 simplify_loop_decl_cond (tree *cond_p, tree body)
531 if (!TREE_SIDE_EFFECTS (body))
535 *cond_p = boolean_true_node;
537 if_stmt = begin_if_stmt ();
538 cond = cp_build_unary_op (TRUTH_NOT_EXPR, cond, 0, tf_warning_or_error);
539 finish_if_stmt_cond (cond, if_stmt);
540 finish_break_stmt ();
541 finish_then_clause (if_stmt);
542 finish_if_stmt (if_stmt);
545 /* Finish a goto-statement. */
548 finish_goto_stmt (tree destination)
550 if (identifier_p (destination))
551 destination = lookup_label (destination);
553 /* We warn about unused labels with -Wunused. That means we have to
554 mark the used labels as used. */
555 if (TREE_CODE (destination) == LABEL_DECL)
556 TREE_USED (destination) = 1;
559 destination = mark_rvalue_use (destination);
560 if (!processing_template_decl)
562 destination = cp_convert (ptr_type_node, destination,
563 tf_warning_or_error);
564 if (error_operand_p (destination))
567 = fold_build_cleanup_point_expr (TREE_TYPE (destination),
572 check_goto (destination);
574 return add_stmt (build_stmt (input_location, GOTO_EXPR, destination));
577 /* COND is the condition-expression for an if, while, etc.,
578 statement. Convert it to a boolean value, if appropriate.
579 In addition, verify sequence points if -Wsequence-point is enabled. */
582 maybe_convert_cond (tree cond)
584 /* Empty conditions remain empty. */
588 /* Wait until we instantiate templates before doing conversion. */
589 if (processing_template_decl)
592 if (warn_sequence_point)
593 verify_sequence_points (cond);
595 /* Do the conversion. */
596 cond = convert_from_reference (cond);
598 if (TREE_CODE (cond) == MODIFY_EXPR
599 && !TREE_NO_WARNING (cond)
602 warning (OPT_Wparentheses,
603 "suggest parentheses around assignment used as truth value");
604 TREE_NO_WARNING (cond) = 1;
607 return condition_conversion (cond);
610 /* Finish an expression-statement, whose EXPRESSION is as indicated. */
613 finish_expr_stmt (tree expr)
617 if (expr != NULL_TREE)
619 if (!processing_template_decl)
621 if (warn_sequence_point)
622 verify_sequence_points (expr);
623 expr = convert_to_void (expr, ICV_STATEMENT, tf_warning_or_error);
625 else if (!type_dependent_expression_p (expr))
626 convert_to_void (build_non_dependent_expr (expr), ICV_STATEMENT,
627 tf_warning_or_error);
629 if (check_for_bare_parameter_packs (expr))
630 expr = error_mark_node;
632 /* Simplification of inner statement expressions, compound exprs,
633 etc can result in us already having an EXPR_STMT. */
634 if (TREE_CODE (expr) != CLEANUP_POINT_EXPR)
636 if (TREE_CODE (expr) != EXPR_STMT)
637 expr = build_stmt (input_location, EXPR_STMT, expr);
638 expr = maybe_cleanup_point_expr_void (expr);
650 /* Begin an if-statement. Returns a newly created IF_STMT if
657 scope = do_pushlevel (sk_cond);
658 r = build_stmt (input_location, IF_STMT, NULL_TREE,
659 NULL_TREE, NULL_TREE, scope);
660 begin_cond (&IF_COND (r));
664 /* Process the COND of an if-statement, which may be given by
668 finish_if_stmt_cond (tree cond, tree if_stmt)
670 finish_cond (&IF_COND (if_stmt), maybe_convert_cond (cond));
672 THEN_CLAUSE (if_stmt) = push_stmt_list ();
675 /* Finish the then-clause of an if-statement, which may be given by
679 finish_then_clause (tree if_stmt)
681 THEN_CLAUSE (if_stmt) = pop_stmt_list (THEN_CLAUSE (if_stmt));
685 /* Begin the else-clause of an if-statement. */
688 begin_else_clause (tree if_stmt)
690 ELSE_CLAUSE (if_stmt) = push_stmt_list ();
693 /* Finish the else-clause of an if-statement, which may be given by
697 finish_else_clause (tree if_stmt)
699 ELSE_CLAUSE (if_stmt) = pop_stmt_list (ELSE_CLAUSE (if_stmt));
702 /* Finish an if-statement. */
705 finish_if_stmt (tree if_stmt)
707 tree scope = IF_SCOPE (if_stmt);
708 IF_SCOPE (if_stmt) = NULL;
709 add_stmt (do_poplevel (scope));
713 /* Begin a while-statement. Returns a newly created WHILE_STMT if
717 begin_while_stmt (void)
720 r = build_stmt (input_location, WHILE_STMT, NULL_TREE, NULL_TREE);
722 WHILE_BODY (r) = do_pushlevel (sk_block);
723 begin_cond (&WHILE_COND (r));
727 /* Process the COND of a while-statement, which may be given by
731 finish_while_stmt_cond (tree cond, tree while_stmt)
733 finish_cond (&WHILE_COND (while_stmt), maybe_convert_cond (cond));
734 simplify_loop_decl_cond (&WHILE_COND (while_stmt), WHILE_BODY (while_stmt));
737 /* Finish a while-statement, which may be given by WHILE_STMT. */
740 finish_while_stmt (tree while_stmt)
742 WHILE_BODY (while_stmt) = do_poplevel (WHILE_BODY (while_stmt));
746 /* Begin a do-statement. Returns a newly created DO_STMT if
752 tree r = build_stmt (input_location, DO_STMT, NULL_TREE, NULL_TREE);
754 DO_BODY (r) = push_stmt_list ();
758 /* Finish the body of a do-statement, which may be given by DO_STMT. */
761 finish_do_body (tree do_stmt)
763 tree body = DO_BODY (do_stmt) = pop_stmt_list (DO_BODY (do_stmt));
765 if (TREE_CODE (body) == STATEMENT_LIST && STATEMENT_LIST_TAIL (body))
766 body = STATEMENT_LIST_TAIL (body)->stmt;
768 if (IS_EMPTY_STMT (body))
769 warning (OPT_Wempty_body,
770 "suggest explicit braces around empty body in %<do%> statement");
773 /* Finish a do-statement, which may be given by DO_STMT, and whose
774 COND is as indicated. */
777 finish_do_stmt (tree cond, tree do_stmt)
779 cond = maybe_convert_cond (cond);
780 DO_COND (do_stmt) = cond;
784 /* Finish a return-statement. The EXPRESSION returned, if any, is as
788 finish_return_stmt (tree expr)
793 expr = check_return_expr (expr, &no_warning);
795 if (flag_openmp && !check_omp_return ())
796 return error_mark_node;
797 if (!processing_template_decl)
799 if (warn_sequence_point)
800 verify_sequence_points (expr);
802 if (DECL_DESTRUCTOR_P (current_function_decl)
803 || (DECL_CONSTRUCTOR_P (current_function_decl)
804 && targetm.cxx.cdtor_returns_this ()))
806 /* Similarly, all destructors must run destructors for
807 base-classes before returning. So, all returns in a
808 destructor get sent to the DTOR_LABEL; finish_function emits
809 code to return a value there. */
810 return finish_goto_stmt (cdtor_label);
814 r = build_stmt (input_location, RETURN_EXPR, expr);
815 TREE_NO_WARNING (r) |= no_warning;
816 r = maybe_cleanup_point_expr_void (r);
823 /* Begin the scope of a for-statement or a range-for-statement.
824 Both the returned trees are to be used in a call to
825 begin_for_stmt or begin_range_for_stmt. */
828 begin_for_scope (tree *init)
830 tree scope = NULL_TREE;
831 if (flag_new_for_scope > 0)
832 scope = do_pushlevel (sk_for);
834 if (processing_template_decl)
835 *init = push_stmt_list ();
842 /* Begin a for-statement. Returns a new FOR_STMT.
843 SCOPE and INIT should be the return of begin_for_scope,
847 begin_for_stmt (tree scope, tree init)
851 r = build_stmt (input_location, FOR_STMT, NULL_TREE, NULL_TREE,
852 NULL_TREE, NULL_TREE, NULL_TREE);
854 if (scope == NULL_TREE)
856 gcc_assert (!init || !(flag_new_for_scope > 0));
858 scope = begin_for_scope (&init);
860 FOR_INIT_STMT (r) = init;
861 FOR_SCOPE (r) = scope;
866 /* Finish the for-init-statement of a for-statement, which may be
867 given by FOR_STMT. */
870 finish_for_init_stmt (tree for_stmt)
872 if (processing_template_decl)
873 FOR_INIT_STMT (for_stmt) = pop_stmt_list (FOR_INIT_STMT (for_stmt));
875 FOR_BODY (for_stmt) = do_pushlevel (sk_block);
876 begin_cond (&FOR_COND (for_stmt));
879 /* Finish the COND of a for-statement, which may be given by
883 finish_for_cond (tree cond, tree for_stmt)
885 finish_cond (&FOR_COND (for_stmt), maybe_convert_cond (cond));
886 simplify_loop_decl_cond (&FOR_COND (for_stmt), FOR_BODY (for_stmt));
889 /* Finish the increment-EXPRESSION in a for-statement, which may be
890 given by FOR_STMT. */
893 finish_for_expr (tree expr, tree for_stmt)
897 /* If EXPR is an overloaded function, issue an error; there is no
898 context available to use to perform overload resolution. */
899 if (type_unknown_p (expr))
901 cxx_incomplete_type_error (expr, TREE_TYPE (expr));
902 expr = error_mark_node;
904 if (!processing_template_decl)
906 if (warn_sequence_point)
907 verify_sequence_points (expr);
908 expr = convert_to_void (expr, ICV_THIRD_IN_FOR,
909 tf_warning_or_error);
911 else if (!type_dependent_expression_p (expr))
912 convert_to_void (build_non_dependent_expr (expr), ICV_THIRD_IN_FOR,
913 tf_warning_or_error);
914 expr = maybe_cleanup_point_expr_void (expr);
915 if (check_for_bare_parameter_packs (expr))
916 expr = error_mark_node;
917 FOR_EXPR (for_stmt) = expr;
920 /* Finish the body of a for-statement, which may be given by
921 FOR_STMT. The increment-EXPR for the loop must be
923 It can also finish RANGE_FOR_STMT. */
926 finish_for_stmt (tree for_stmt)
928 if (TREE_CODE (for_stmt) == RANGE_FOR_STMT)
929 RANGE_FOR_BODY (for_stmt) = do_poplevel (RANGE_FOR_BODY (for_stmt));
931 FOR_BODY (for_stmt) = do_poplevel (FOR_BODY (for_stmt));
933 /* Pop the scope for the body of the loop. */
934 if (flag_new_for_scope > 0)
937 tree *scope_ptr = (TREE_CODE (for_stmt) == RANGE_FOR_STMT
938 ? &RANGE_FOR_SCOPE (for_stmt)
939 : &FOR_SCOPE (for_stmt));
942 add_stmt (do_poplevel (scope));
948 /* Begin a range-for-statement. Returns a new RANGE_FOR_STMT.
949 SCOPE and INIT should be the return of begin_for_scope,
951 To finish it call finish_for_stmt(). */
954 begin_range_for_stmt (tree scope, tree init)
958 r = build_stmt (input_location, RANGE_FOR_STMT,
959 NULL_TREE, NULL_TREE, NULL_TREE, NULL_TREE);
961 if (scope == NULL_TREE)
963 gcc_assert (!init || !(flag_new_for_scope > 0));
965 scope = begin_for_scope (&init);
968 /* RANGE_FOR_STMTs do not use nor save the init tree, so we
971 pop_stmt_list (init);
972 RANGE_FOR_SCOPE (r) = scope;
977 /* Finish the head of a range-based for statement, which may
978 be given by RANGE_FOR_STMT. DECL must be the declaration
979 and EXPR must be the loop expression. */
982 finish_range_for_decl (tree range_for_stmt, tree decl, tree expr)
984 RANGE_FOR_DECL (range_for_stmt) = decl;
985 RANGE_FOR_EXPR (range_for_stmt) = expr;
986 add_stmt (range_for_stmt);
987 RANGE_FOR_BODY (range_for_stmt) = do_pushlevel (sk_block);
990 /* Finish a break-statement. */
993 finish_break_stmt (void)
995 /* In switch statements break is sometimes stylistically used after
996 a return statement. This can lead to spurious warnings about
997 control reaching the end of a non-void function when it is
998 inlined. Note that we are calling block_may_fallthru with
999 language specific tree nodes; this works because
1000 block_may_fallthru returns true when given something it does not
1002 if (!block_may_fallthru (cur_stmt_list))
1003 return void_zero_node;
1004 return add_stmt (build_stmt (input_location, BREAK_STMT));
1007 /* Finish a continue-statement. */
1010 finish_continue_stmt (void)
1012 return add_stmt (build_stmt (input_location, CONTINUE_STMT));
1015 /* Begin a switch-statement. Returns a new SWITCH_STMT if
1019 begin_switch_stmt (void)
1023 scope = do_pushlevel (sk_cond);
1024 r = build_stmt (input_location, SWITCH_STMT, NULL_TREE, NULL_TREE, NULL_TREE, scope);
1026 begin_cond (&SWITCH_STMT_COND (r));
1031 /* Finish the cond of a switch-statement. */
1034 finish_switch_cond (tree cond, tree switch_stmt)
1036 tree orig_type = NULL;
1037 if (!processing_template_decl)
1039 /* Convert the condition to an integer or enumeration type. */
1040 cond = build_expr_type_conversion (WANT_INT | WANT_ENUM, cond, true);
1041 if (cond == NULL_TREE)
1043 error ("switch quantity not an integer");
1044 cond = error_mark_node;
1046 orig_type = TREE_TYPE (cond);
1047 if (cond != error_mark_node)
1051 Integral promotions are performed. */
1052 cond = perform_integral_promotions (cond);
1053 cond = maybe_cleanup_point_expr (cond);
1056 if (check_for_bare_parameter_packs (cond))
1057 cond = error_mark_node;
1058 else if (!processing_template_decl && warn_sequence_point)
1059 verify_sequence_points (cond);
1061 finish_cond (&SWITCH_STMT_COND (switch_stmt), cond);
1062 SWITCH_STMT_TYPE (switch_stmt) = orig_type;
1063 add_stmt (switch_stmt);
1064 push_switch (switch_stmt);
1065 SWITCH_STMT_BODY (switch_stmt) = push_stmt_list ();
1068 /* Finish the body of a switch-statement, which may be given by
1069 SWITCH_STMT. The COND to switch on is indicated. */
1072 finish_switch_stmt (tree switch_stmt)
1076 SWITCH_STMT_BODY (switch_stmt) =
1077 pop_stmt_list (SWITCH_STMT_BODY (switch_stmt));
1081 scope = SWITCH_STMT_SCOPE (switch_stmt);
1082 SWITCH_STMT_SCOPE (switch_stmt) = NULL;
1083 add_stmt (do_poplevel (scope));
1086 /* Begin a try-block. Returns a newly-created TRY_BLOCK if
1090 begin_try_block (void)
1092 tree r = build_stmt (input_location, TRY_BLOCK, NULL_TREE, NULL_TREE);
1094 TRY_STMTS (r) = push_stmt_list ();
1098 /* Likewise, for a function-try-block. The block returned in
1099 *COMPOUND_STMT is an artificial outer scope, containing the
1100 function-try-block. */
1103 begin_function_try_block (tree *compound_stmt)
1106 /* This outer scope does not exist in the C++ standard, but we need
1107 a place to put __FUNCTION__ and similar variables. */
1108 *compound_stmt = begin_compound_stmt (0);
1109 r = begin_try_block ();
1110 FN_TRY_BLOCK_P (r) = 1;
1114 /* Finish a try-block, which may be given by TRY_BLOCK. */
1117 finish_try_block (tree try_block)
1119 TRY_STMTS (try_block) = pop_stmt_list (TRY_STMTS (try_block));
1120 TRY_HANDLERS (try_block) = push_stmt_list ();
1123 /* Finish the body of a cleanup try-block, which may be given by
1127 finish_cleanup_try_block (tree try_block)
1129 TRY_STMTS (try_block) = pop_stmt_list (TRY_STMTS (try_block));
1132 /* Finish an implicitly generated try-block, with a cleanup is given
1136 finish_cleanup (tree cleanup, tree try_block)
1138 TRY_HANDLERS (try_block) = cleanup;
1139 CLEANUP_P (try_block) = 1;
1142 /* Likewise, for a function-try-block. */
1145 finish_function_try_block (tree try_block)
1147 finish_try_block (try_block);
1148 /* FIXME : something queer about CTOR_INITIALIZER somehow following
1149 the try block, but moving it inside. */
1150 in_function_try_handler = 1;
1153 /* Finish a handler-sequence for a try-block, which may be given by
1157 finish_handler_sequence (tree try_block)
1159 TRY_HANDLERS (try_block) = pop_stmt_list (TRY_HANDLERS (try_block));
1160 check_handlers (TRY_HANDLERS (try_block));
1163 /* Finish the handler-seq for a function-try-block, given by
1164 TRY_BLOCK. COMPOUND_STMT is the outer block created by
1165 begin_function_try_block. */
1168 finish_function_handler_sequence (tree try_block, tree compound_stmt)
1170 in_function_try_handler = 0;
1171 finish_handler_sequence (try_block);
1172 finish_compound_stmt (compound_stmt);
1175 /* Begin a handler. Returns a HANDLER if appropriate. */
1178 begin_handler (void)
1182 r = build_stmt (input_location, HANDLER, NULL_TREE, NULL_TREE);
1185 /* Create a binding level for the eh_info and the exception object
1187 HANDLER_BODY (r) = do_pushlevel (sk_catch);
1192 /* Finish the handler-parameters for a handler, which may be given by
1193 HANDLER. DECL is the declaration for the catch parameter, or NULL
1194 if this is a `catch (...)' clause. */
1197 finish_handler_parms (tree decl, tree handler)
1199 tree type = NULL_TREE;
1200 if (processing_template_decl)
1204 decl = pushdecl (decl);
1205 decl = push_template_decl (decl);
1206 HANDLER_PARMS (handler) = decl;
1207 type = TREE_TYPE (decl);
1211 type = expand_start_catch_block (decl);
1212 HANDLER_TYPE (handler) = type;
1215 /* Finish a handler, which may be given by HANDLER. The BLOCKs are
1216 the return value from the matching call to finish_handler_parms. */
1219 finish_handler (tree handler)
1221 if (!processing_template_decl)
1222 expand_end_catch_block ();
1223 HANDLER_BODY (handler) = do_poplevel (HANDLER_BODY (handler));
1226 /* Begin a compound statement. FLAGS contains some bits that control the
1227 behavior and context. If BCS_NO_SCOPE is set, the compound statement
1228 does not define a scope. If BCS_FN_BODY is set, this is the outermost
1229 block of a function. If BCS_TRY_BLOCK is set, this is the block
1230 created on behalf of a TRY statement. Returns a token to be passed to
1231 finish_compound_stmt. */
1234 begin_compound_stmt (unsigned int flags)
1238 if (flags & BCS_NO_SCOPE)
1240 r = push_stmt_list ();
1241 STATEMENT_LIST_NO_SCOPE (r) = 1;
1243 /* Normally, we try hard to keep the BLOCK for a statement-expression.
1244 But, if it's a statement-expression with a scopeless block, there's
1245 nothing to keep, and we don't want to accidentally keep a block
1246 *inside* the scopeless block. */
1247 keep_next_level (false);
1250 r = do_pushlevel (flags & BCS_TRY_BLOCK ? sk_try : sk_block);
1252 /* When processing a template, we need to remember where the braces were,
1253 so that we can set up identical scopes when instantiating the template
1254 later. BIND_EXPR is a handy candidate for this.
1255 Note that do_poplevel won't create a BIND_EXPR itself here (and thus
1256 result in nested BIND_EXPRs), since we don't build BLOCK nodes when
1257 processing templates. */
1258 if (processing_template_decl)
1260 r = build3 (BIND_EXPR, NULL, NULL, r, NULL);
1261 BIND_EXPR_TRY_BLOCK (r) = (flags & BCS_TRY_BLOCK) != 0;
1262 BIND_EXPR_BODY_BLOCK (r) = (flags & BCS_FN_BODY) != 0;
1263 TREE_SIDE_EFFECTS (r) = 1;
1269 /* Finish a compound-statement, which is given by STMT. */
1272 finish_compound_stmt (tree stmt)
1274 if (TREE_CODE (stmt) == BIND_EXPR)
1276 tree body = do_poplevel (BIND_EXPR_BODY (stmt));
1277 /* If the STATEMENT_LIST is empty and this BIND_EXPR isn't special,
1278 discard the BIND_EXPR so it can be merged with the containing
1280 if (TREE_CODE (body) == STATEMENT_LIST
1281 && STATEMENT_LIST_HEAD (body) == NULL
1282 && !BIND_EXPR_BODY_BLOCK (stmt)
1283 && !BIND_EXPR_TRY_BLOCK (stmt))
1286 BIND_EXPR_BODY (stmt) = body;
1288 else if (STATEMENT_LIST_NO_SCOPE (stmt))
1289 stmt = pop_stmt_list (stmt);
1292 /* Destroy any ObjC "super" receivers that may have been
1294 objc_clear_super_receiver ();
1296 stmt = do_poplevel (stmt);
1299 /* ??? See c_end_compound_stmt wrt statement expressions. */
1304 /* Finish an asm-statement, whose components are a STRING, some
1305 OUTPUT_OPERANDS, some INPUT_OPERANDS, some CLOBBERS and some
1306 LABELS. Also note whether the asm-statement should be
1307 considered volatile. */
1310 finish_asm_stmt (int volatile_p, tree string, tree output_operands,
1311 tree input_operands, tree clobbers, tree labels)
1315 int ninputs = list_length (input_operands);
1316 int noutputs = list_length (output_operands);
1318 if (!processing_template_decl)
1320 const char *constraint;
1321 const char **oconstraints;
1322 bool allows_mem, allows_reg, is_inout;
1326 oconstraints = XALLOCAVEC (const char *, noutputs);
1328 string = resolve_asm_operand_names (string, output_operands,
1329 input_operands, labels);
1331 for (i = 0, t = output_operands; t; t = TREE_CHAIN (t), ++i)
1333 operand = TREE_VALUE (t);
1335 /* ??? Really, this should not be here. Users should be using a
1336 proper lvalue, dammit. But there's a long history of using
1337 casts in the output operands. In cases like longlong.h, this
1338 becomes a primitive form of typechecking -- if the cast can be
1339 removed, then the output operand had a type of the proper width;
1340 otherwise we'll get an error. Gross, but ... */
1341 STRIP_NOPS (operand);
1343 operand = mark_lvalue_use (operand);
1345 if (!lvalue_or_else (operand, lv_asm, tf_warning_or_error))
1346 operand = error_mark_node;
1348 if (operand != error_mark_node
1349 && (TREE_READONLY (operand)
1350 || CP_TYPE_CONST_P (TREE_TYPE (operand))
1351 /* Functions are not modifiable, even though they are
1353 || TREE_CODE (TREE_TYPE (operand)) == FUNCTION_TYPE
1354 || TREE_CODE (TREE_TYPE (operand)) == METHOD_TYPE
1355 /* If it's an aggregate and any field is const, then it is
1356 effectively const. */
1357 || (CLASS_TYPE_P (TREE_TYPE (operand))
1358 && C_TYPE_FIELDS_READONLY (TREE_TYPE (operand)))))
1359 cxx_readonly_error (operand, lv_asm);
1361 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t)));
1362 oconstraints[i] = constraint;
1364 if (parse_output_constraint (&constraint, i, ninputs, noutputs,
1365 &allows_mem, &allows_reg, &is_inout))
1367 /* If the operand is going to end up in memory,
1368 mark it addressable. */
1369 if (!allows_reg && !cxx_mark_addressable (operand))
1370 operand = error_mark_node;
1373 operand = error_mark_node;
1375 TREE_VALUE (t) = operand;
1378 for (i = 0, t = input_operands; t; ++i, t = TREE_CHAIN (t))
1380 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t)));
1381 bool constraint_parsed
1382 = parse_input_constraint (&constraint, i, ninputs, noutputs, 0,
1383 oconstraints, &allows_mem, &allows_reg);
1384 /* If the operand is going to end up in memory, don't call
1385 decay_conversion. */
1386 if (constraint_parsed && !allows_reg && allows_mem)
1387 operand = mark_lvalue_use (TREE_VALUE (t));
1389 operand = decay_conversion (TREE_VALUE (t), tf_warning_or_error);
1391 /* If the type of the operand hasn't been determined (e.g.,
1392 because it involves an overloaded function), then issue
1393 an error message. There's no context available to
1394 resolve the overloading. */
1395 if (TREE_TYPE (operand) == unknown_type_node)
1397 error ("type of asm operand %qE could not be determined",
1399 operand = error_mark_node;
1402 if (constraint_parsed)
1404 /* If the operand is going to end up in memory,
1405 mark it addressable. */
1406 if (!allows_reg && allows_mem)
1408 /* Strip the nops as we allow this case. FIXME, this really
1409 should be rejected or made deprecated. */
1410 STRIP_NOPS (operand);
1411 if (!cxx_mark_addressable (operand))
1412 operand = error_mark_node;
1414 else if (!allows_reg && !allows_mem)
1416 /* If constraint allows neither register nor memory,
1417 try harder to get a constant. */
1418 tree constop = maybe_constant_value (operand);
1419 if (TREE_CONSTANT (constop))
1424 operand = error_mark_node;
1426 TREE_VALUE (t) = operand;
1430 r = build_stmt (input_location, ASM_EXPR, string,
1431 output_operands, input_operands,
1433 ASM_VOLATILE_P (r) = volatile_p || noutputs == 0;
1434 r = maybe_cleanup_point_expr_void (r);
1435 return add_stmt (r);
1438 /* Finish a label with the indicated NAME. Returns the new label. */
1441 finish_label_stmt (tree name)
1443 tree decl = define_label (input_location, name);
1445 if (decl == error_mark_node)
1446 return error_mark_node;
1448 add_stmt (build_stmt (input_location, LABEL_EXPR, decl));
1453 /* Finish a series of declarations for local labels. G++ allows users
1454 to declare "local" labels, i.e., labels with scope. This extension
1455 is useful when writing code involving statement-expressions. */
1458 finish_label_decl (tree name)
1460 if (!at_function_scope_p ())
1462 error ("__label__ declarations are only allowed in function scopes");
1466 add_decl_expr (declare_local_label (name));
1469 /* When DECL goes out of scope, make sure that CLEANUP is executed. */
1472 finish_decl_cleanup (tree decl, tree cleanup)
1474 push_cleanup (decl, cleanup, false);
1477 /* If the current scope exits with an exception, run CLEANUP. */
1480 finish_eh_cleanup (tree cleanup)
1482 push_cleanup (NULL, cleanup, true);
1485 /* The MEM_INITS is a list of mem-initializers, in reverse of the
1486 order they were written by the user. Each node is as for
1487 emit_mem_initializers. */
1490 finish_mem_initializers (tree mem_inits)
1492 /* Reorder the MEM_INITS so that they are in the order they appeared
1493 in the source program. */
1494 mem_inits = nreverse (mem_inits);
1496 if (processing_template_decl)
1500 for (mem = mem_inits; mem; mem = TREE_CHAIN (mem))
1502 /* If the TREE_PURPOSE is a TYPE_PACK_EXPANSION, skip the
1503 check for bare parameter packs in the TREE_VALUE, because
1504 any parameter packs in the TREE_VALUE have already been
1505 bound as part of the TREE_PURPOSE. See
1506 make_pack_expansion for more information. */
1507 if (TREE_CODE (TREE_PURPOSE (mem)) != TYPE_PACK_EXPANSION
1508 && check_for_bare_parameter_packs (TREE_VALUE (mem)))
1509 TREE_VALUE (mem) = error_mark_node;
1512 add_stmt (build_min_nt_loc (UNKNOWN_LOCATION,
1513 CTOR_INITIALIZER, mem_inits));
1516 emit_mem_initializers (mem_inits);
1519 /* Obfuscate EXPR if it looks like an id-expression or member access so
1520 that the call to finish_decltype in do_auto_deduction will give the
1524 force_paren_expr (tree expr)
1526 /* This is only needed for decltype(auto) in C++14. */
1527 if (cxx_dialect < cxx1y)
1530 if (!DECL_P (expr) && TREE_CODE (expr) != COMPONENT_REF
1531 && TREE_CODE (expr) != SCOPE_REF)
1534 if (processing_template_decl)
1535 expr = build1 (PAREN_EXPR, TREE_TYPE (expr), expr);
1538 cp_lvalue_kind kind = lvalue_kind (expr);
1539 if ((kind & ~clk_class) != clk_none)
1541 tree type = unlowered_expr_type (expr);
1542 bool rval = !!(kind & clk_rvalueref);
1543 type = cp_build_reference_type (type, rval);
1544 expr = build_static_cast (type, expr, tf_warning_or_error);
1551 /* Finish a parenthesized expression EXPR. */
1554 finish_parenthesized_expr (tree expr)
1557 /* This inhibits warnings in c_common_truthvalue_conversion. */
1558 TREE_NO_WARNING (expr) = 1;
1560 if (TREE_CODE (expr) == OFFSET_REF
1561 || TREE_CODE (expr) == SCOPE_REF)
1562 /* [expr.unary.op]/3 The qualified id of a pointer-to-member must not be
1563 enclosed in parentheses. */
1564 PTRMEM_OK_P (expr) = 0;
1566 if (TREE_CODE (expr) == STRING_CST)
1567 PAREN_STRING_LITERAL_P (expr) = 1;
1569 expr = force_paren_expr (expr);
1574 /* Finish a reference to a non-static data member (DECL) that is not
1575 preceded by `.' or `->'. */
1578 finish_non_static_data_member (tree decl, tree object, tree qualifying_scope)
1580 gcc_assert (TREE_CODE (decl) == FIELD_DECL);
1584 tree scope = qualifying_scope;
1585 if (scope == NULL_TREE)
1586 scope = context_for_name_lookup (decl);
1587 object = maybe_dummy_object (scope, NULL);
1590 object = maybe_resolve_dummy (object);
1591 if (object == error_mark_node)
1592 return error_mark_node;
1594 /* DR 613: Can use non-static data members without an associated
1595 object in sizeof/decltype/alignof. */
1596 if (is_dummy_object (object) && cp_unevaluated_operand == 0
1597 && (!processing_template_decl || !current_class_ref))
1599 if (current_function_decl
1600 && DECL_STATIC_FUNCTION_P (current_function_decl))
1601 error ("invalid use of member %q+D in static member function", decl);
1603 error ("invalid use of non-static data member %q+D", decl);
1604 error ("from this location");
1606 return error_mark_node;
1609 if (current_class_ptr)
1610 TREE_USED (current_class_ptr) = 1;
1611 if (processing_template_decl && !qualifying_scope)
1613 tree type = TREE_TYPE (decl);
1615 if (TREE_CODE (type) == REFERENCE_TYPE)
1616 /* Quals on the object don't matter. */;
1619 /* Set the cv qualifiers. */
1620 int quals = cp_type_quals (TREE_TYPE (object));
1622 if (DECL_MUTABLE_P (decl))
1623 quals &= ~TYPE_QUAL_CONST;
1625 quals |= cp_type_quals (TREE_TYPE (decl));
1626 type = cp_build_qualified_type (type, quals);
1629 return (convert_from_reference
1630 (build_min (COMPONENT_REF, type, object, decl, NULL_TREE)));
1632 /* If PROCESSING_TEMPLATE_DECL is nonzero here, then
1633 QUALIFYING_SCOPE is also non-null. Wrap this in a SCOPE_REF
1635 else if (processing_template_decl)
1636 return build_qualified_name (TREE_TYPE (decl),
1639 /*template_p=*/false);
1642 tree access_type = TREE_TYPE (object);
1644 perform_or_defer_access_check (TYPE_BINFO (access_type), decl,
1645 decl, tf_warning_or_error);
1647 /* If the data member was named `C::M', convert `*this' to `C'
1649 if (qualifying_scope)
1651 tree binfo = NULL_TREE;
1652 object = build_scoped_ref (object, qualifying_scope,
1656 return build_class_member_access_expr (object, decl,
1657 /*access_path=*/NULL_TREE,
1658 /*preserve_reference=*/false,
1659 tf_warning_or_error);
1663 /* If we are currently parsing a template and we encountered a typedef
1664 TYPEDEF_DECL that is being accessed though CONTEXT, this function
1665 adds the typedef to a list tied to the current template.
1666 At template instantiation time, that list is walked and access check
1667 performed for each typedef.
1668 LOCATION is the location of the usage point of TYPEDEF_DECL. */
1671 add_typedef_to_current_template_for_access_check (tree typedef_decl,
1673 location_t location)
1675 tree template_info = NULL;
1676 tree cs = current_scope ();
1678 if (!is_typedef_decl (typedef_decl)
1680 || !CLASS_TYPE_P (context)
1684 if (CLASS_TYPE_P (cs) || TREE_CODE (cs) == FUNCTION_DECL)
1685 template_info = get_template_info (cs);
1688 && TI_TEMPLATE (template_info)
1689 && !currently_open_class (context))
1690 append_type_to_template_for_access_check (cs, typedef_decl,
1694 /* DECL was the declaration to which a qualified-id resolved. Issue
1695 an error message if it is not accessible. If OBJECT_TYPE is
1696 non-NULL, we have just seen `x->' or `x.' and OBJECT_TYPE is the
1697 type of `*x', or `x', respectively. If the DECL was named as
1698 `A::B' then NESTED_NAME_SPECIFIER is `A'. */
1701 check_accessibility_of_qualified_id (tree decl,
1703 tree nested_name_specifier)
1706 tree qualifying_type = NULL_TREE;
1708 /* If we are parsing a template declaration and if decl is a typedef,
1709 add it to a list tied to the template.
1710 At template instantiation time, that list will be walked and
1711 access check performed. */
1712 add_typedef_to_current_template_for_access_check (decl,
1713 nested_name_specifier
1714 ? nested_name_specifier
1715 : DECL_CONTEXT (decl),
1718 /* If we're not checking, return immediately. */
1719 if (deferred_access_no_check)
1722 /* Determine the SCOPE of DECL. */
1723 scope = context_for_name_lookup (decl);
1724 /* If the SCOPE is not a type, then DECL is not a member. */
1725 if (!TYPE_P (scope))
1727 /* Compute the scope through which DECL is being accessed. */
1729 /* OBJECT_TYPE might not be a class type; consider:
1731 class A { typedef int I; };
1735 In this case, we will have "A::I" as the DECL, but "I" as the
1737 && CLASS_TYPE_P (object_type)
1738 && DERIVED_FROM_P (scope, object_type))
1739 /* If we are processing a `->' or `.' expression, use the type of the
1741 qualifying_type = object_type;
1742 else if (nested_name_specifier)
1744 /* If the reference is to a non-static member of the
1745 current class, treat it as if it were referenced through
1747 if (DECL_NONSTATIC_MEMBER_P (decl)
1748 && current_class_ptr
1749 && DERIVED_FROM_P (scope, current_class_type))
1750 qualifying_type = current_class_type;
1751 /* Otherwise, use the type indicated by the
1752 nested-name-specifier. */
1754 qualifying_type = nested_name_specifier;
1757 /* Otherwise, the name must be from the current class or one of
1759 qualifying_type = currently_open_derived_class (scope);
1762 /* It is possible for qualifying type to be a TEMPLATE_TYPE_PARM
1763 or similar in a default argument value. */
1764 && CLASS_TYPE_P (qualifying_type)
1765 && !dependent_type_p (qualifying_type))
1766 perform_or_defer_access_check (TYPE_BINFO (qualifying_type), decl,
1767 decl, tf_warning_or_error);
1770 /* EXPR is the result of a qualified-id. The QUALIFYING_CLASS was the
1771 class named to the left of the "::" operator. DONE is true if this
1772 expression is a complete postfix-expression; it is false if this
1773 expression is followed by '->', '[', '(', etc. ADDRESS_P is true
1774 iff this expression is the operand of '&'. TEMPLATE_P is true iff
1775 the qualified-id was of the form "A::template B". TEMPLATE_ARG_P
1776 is true iff this qualified name appears as a template argument. */
1779 finish_qualified_id_expr (tree qualifying_class,
1784 bool template_arg_p,
1785 tsubst_flags_t complain)
1787 gcc_assert (TYPE_P (qualifying_class));
1789 if (error_operand_p (expr))
1790 return error_mark_node;
1792 if ((DECL_P (expr) || BASELINK_P (expr))
1793 && !mark_used (expr, complain))
1794 return error_mark_node;
1797 check_template_keyword (expr);
1799 /* If EXPR occurs as the operand of '&', use special handling that
1800 permits a pointer-to-member. */
1801 if (address_p && done)
1803 if (TREE_CODE (expr) == SCOPE_REF)
1804 expr = TREE_OPERAND (expr, 1);
1805 expr = build_offset_ref (qualifying_class, expr,
1806 /*address_p=*/true, complain);
1810 /* No need to check access within an enum. */
1811 if (TREE_CODE (qualifying_class) == ENUMERAL_TYPE)
1814 /* Within the scope of a class, turn references to non-static
1815 members into expression of the form "this->...". */
1817 /* But, within a template argument, we do not want make the
1818 transformation, as there is no "this" pointer. */
1820 else if (TREE_CODE (expr) == FIELD_DECL)
1822 push_deferring_access_checks (dk_no_check);
1823 expr = finish_non_static_data_member (expr, NULL_TREE,
1825 pop_deferring_access_checks ();
1827 else if (BASELINK_P (expr) && !processing_template_decl)
1829 /* See if any of the functions are non-static members. */
1830 /* If so, the expression may be relative to 'this'. */
1831 if (!shared_member_p (expr)
1832 && current_class_ptr
1833 && DERIVED_FROM_P (qualifying_class,
1834 current_nonlambda_class_type ()))
1835 expr = (build_class_member_access_expr
1836 (maybe_dummy_object (qualifying_class, NULL),
1838 BASELINK_ACCESS_BINFO (expr),
1839 /*preserve_reference=*/false,
1842 /* The expression is a qualified name whose address is not
1844 expr = build_offset_ref (qualifying_class, expr, /*address_p=*/false,
1847 else if (BASELINK_P (expr))
1851 /* In a template, return a SCOPE_REF for most qualified-ids
1852 so that we can check access at instantiation time. But if
1853 we're looking at a member of the current instantiation, we
1854 know we have access and building up the SCOPE_REF confuses
1855 non-type template argument handling. */
1856 if (processing_template_decl
1857 && !currently_open_class (qualifying_class))
1858 expr = build_qualified_name (TREE_TYPE (expr),
1859 qualifying_class, expr,
1862 expr = convert_from_reference (expr);
1868 /* Begin a statement-expression. The value returned must be passed to
1869 finish_stmt_expr. */
1872 begin_stmt_expr (void)
1874 return push_stmt_list ();
1877 /* Process the final expression of a statement expression. EXPR can be
1878 NULL, if the final expression is empty. Return a STATEMENT_LIST
1879 containing all the statements in the statement-expression, or
1880 ERROR_MARK_NODE if there was an error. */
1883 finish_stmt_expr_expr (tree expr, tree stmt_expr)
1885 if (error_operand_p (expr))
1887 /* The type of the statement-expression is the type of the last
1889 TREE_TYPE (stmt_expr) = error_mark_node;
1890 return error_mark_node;
1893 /* If the last statement does not have "void" type, then the value
1894 of the last statement is the value of the entire expression. */
1897 tree type = TREE_TYPE (expr);
1899 if (processing_template_decl)
1901 expr = build_stmt (input_location, EXPR_STMT, expr);
1902 expr = add_stmt (expr);
1903 /* Mark the last statement so that we can recognize it as such at
1904 template-instantiation time. */
1905 EXPR_STMT_STMT_EXPR_RESULT (expr) = 1;
1907 else if (VOID_TYPE_P (type))
1909 /* Just treat this like an ordinary statement. */
1910 expr = finish_expr_stmt (expr);
1914 /* It actually has a value we need to deal with. First, force it
1915 to be an rvalue so that we won't need to build up a copy
1916 constructor call later when we try to assign it to something. */
1917 expr = force_rvalue (expr, tf_warning_or_error);
1918 if (error_operand_p (expr))
1919 return error_mark_node;
1921 /* Update for array-to-pointer decay. */
1922 type = TREE_TYPE (expr);
1924 /* Wrap it in a CLEANUP_POINT_EXPR and add it to the list like a
1925 normal statement, but don't convert to void or actually add
1927 if (TREE_CODE (expr) != CLEANUP_POINT_EXPR)
1928 expr = maybe_cleanup_point_expr (expr);
1932 /* The type of the statement-expression is the type of the last
1934 TREE_TYPE (stmt_expr) = type;
1940 /* Finish a statement-expression. EXPR should be the value returned
1941 by the previous begin_stmt_expr. Returns an expression
1942 representing the statement-expression. */
1945 finish_stmt_expr (tree stmt_expr, bool has_no_scope)
1950 if (error_operand_p (stmt_expr))
1952 pop_stmt_list (stmt_expr);
1953 return error_mark_node;
1956 gcc_assert (TREE_CODE (stmt_expr) == STATEMENT_LIST);
1958 type = TREE_TYPE (stmt_expr);
1959 result = pop_stmt_list (stmt_expr);
1960 TREE_TYPE (result) = type;
1962 if (processing_template_decl)
1964 result = build_min (STMT_EXPR, type, result);
1965 TREE_SIDE_EFFECTS (result) = 1;
1966 STMT_EXPR_NO_SCOPE (result) = has_no_scope;
1968 else if (CLASS_TYPE_P (type))
1970 /* Wrap the statement-expression in a TARGET_EXPR so that the
1971 temporary object created by the final expression is destroyed at
1972 the end of the full-expression containing the
1973 statement-expression. */
1974 result = force_target_expr (type, result, tf_warning_or_error);
1980 /* Returns the expression which provides the value of STMT_EXPR. */
1983 stmt_expr_value_expr (tree stmt_expr)
1985 tree t = STMT_EXPR_STMT (stmt_expr);
1987 if (TREE_CODE (t) == BIND_EXPR)
1988 t = BIND_EXPR_BODY (t);
1990 if (TREE_CODE (t) == STATEMENT_LIST && STATEMENT_LIST_TAIL (t))
1991 t = STATEMENT_LIST_TAIL (t)->stmt;
1993 if (TREE_CODE (t) == EXPR_STMT)
1994 t = EXPR_STMT_EXPR (t);
1999 /* Return TRUE iff EXPR_STMT is an empty list of
2000 expression statements. */
2003 empty_expr_stmt_p (tree expr_stmt)
2005 tree body = NULL_TREE;
2007 if (expr_stmt == void_zero_node)
2012 if (TREE_CODE (expr_stmt) == EXPR_STMT)
2013 body = EXPR_STMT_EXPR (expr_stmt);
2014 else if (TREE_CODE (expr_stmt) == STATEMENT_LIST)
2020 if (TREE_CODE (body) == STATEMENT_LIST)
2021 return tsi_end_p (tsi_start (body));
2023 return empty_expr_stmt_p (body);
2028 /* Perform Koenig lookup. FN is the postfix-expression representing
2029 the function (or functions) to call; ARGS are the arguments to the
2030 call; if INCLUDE_STD then the `std' namespace is automatically
2031 considered an associated namespace (used in range-based for loops).
2032 Returns the functions to be considered by overload resolution. */
2035 perform_koenig_lookup (tree fn, vec<tree, va_gc> *args, bool include_std,
2036 tsubst_flags_t complain)
2038 tree identifier = NULL_TREE;
2039 tree functions = NULL_TREE;
2040 tree tmpl_args = NULL_TREE;
2041 bool template_id = false;
2043 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2045 /* Use a separate flag to handle null args. */
2047 tmpl_args = TREE_OPERAND (fn, 1);
2048 fn = TREE_OPERAND (fn, 0);
2051 /* Find the name of the overloaded function. */
2052 if (identifier_p (fn))
2054 else if (is_overloaded_fn (fn))
2057 identifier = DECL_NAME (get_first_fn (functions));
2059 else if (DECL_P (fn))
2062 identifier = DECL_NAME (fn);
2065 /* A call to a namespace-scope function using an unqualified name.
2067 Do Koenig lookup -- unless any of the arguments are
2069 if (!any_type_dependent_arguments_p (args)
2070 && !any_dependent_template_arguments_p (tmpl_args))
2072 fn = lookup_arg_dependent (identifier, functions, args, include_std);
2075 /* The unqualified name could not be resolved. */
2077 fn = unqualified_fn_lookup_error (identifier);
2083 if (fn && template_id)
2084 fn = build2 (TEMPLATE_ID_EXPR, unknown_type_node, fn, tmpl_args);
2089 /* Generate an expression for `FN (ARGS)'. This may change the
2092 If DISALLOW_VIRTUAL is true, the call to FN will be not generated
2093 as a virtual call, even if FN is virtual. (This flag is set when
2094 encountering an expression where the function name is explicitly
2095 qualified. For example a call to `X::f' never generates a virtual
2098 Returns code for the call. */
2101 finish_call_expr (tree fn, vec<tree, va_gc> **args, bool disallow_virtual,
2102 bool koenig_p, tsubst_flags_t complain)
2106 vec<tree, va_gc> *orig_args = NULL;
2108 if (fn == error_mark_node)
2109 return error_mark_node;
2111 gcc_assert (!TYPE_P (fn));
2115 if (processing_template_decl)
2117 /* If the call expression is dependent, build a CALL_EXPR node
2118 with no type; type_dependent_expression_p recognizes
2119 expressions with no type as being dependent. */
2120 if (type_dependent_expression_p (fn)
2121 || any_type_dependent_arguments_p (*args)
2122 /* For a non-static member function that doesn't have an
2123 explicit object argument, we need to specifically
2124 test the type dependency of the "this" pointer because it
2125 is not included in *ARGS even though it is considered to
2126 be part of the list of arguments. Note that this is
2127 related to CWG issues 515 and 1005. */
2128 || (TREE_CODE (fn) != COMPONENT_REF
2129 && non_static_member_function_p (fn)
2130 && current_class_ref
2131 && type_dependent_expression_p (current_class_ref)))
2133 result = build_nt_call_vec (fn, *args);
2134 SET_EXPR_LOCATION (result, EXPR_LOC_OR_HERE (fn));
2135 KOENIG_LOOKUP_P (result) = koenig_p;
2140 tree fndecl = OVL_CURRENT (fn);
2141 if (TREE_CODE (fndecl) != FUNCTION_DECL
2142 || !TREE_THIS_VOLATILE (fndecl))
2148 current_function_returns_abnormally = 1;
2152 orig_args = make_tree_vector_copy (*args);
2153 if (!BASELINK_P (fn)
2154 && TREE_CODE (fn) != PSEUDO_DTOR_EXPR
2155 && TREE_TYPE (fn) != unknown_type_node)
2156 fn = build_non_dependent_expr (fn);
2157 make_args_non_dependent (*args);
2160 if (TREE_CODE (fn) == COMPONENT_REF)
2162 tree member = TREE_OPERAND (fn, 1);
2163 if (BASELINK_P (member))
2165 tree object = TREE_OPERAND (fn, 0);
2166 return build_new_method_call (object, member,
2169 ? LOOKUP_NORMAL | LOOKUP_NONVIRTUAL
2176 if (is_overloaded_fn (fn))
2177 fn = baselink_for_fns (fn);
2180 if (BASELINK_P (fn))
2184 /* A call to a member function. From [over.call.func]:
2186 If the keyword this is in scope and refers to the class of
2187 that member function, or a derived class thereof, then the
2188 function call is transformed into a qualified function call
2189 using (*this) as the postfix-expression to the left of the
2190 . operator.... [Otherwise] a contrived object of type T
2191 becomes the implied object argument.
2195 struct A { void f(); };
2196 struct B : public A {};
2197 struct C : public A { void g() { B::f(); }};
2199 "the class of that member function" refers to `A'. But 11.2
2200 [class.access.base] says that we need to convert 'this' to B* as
2201 part of the access, so we pass 'B' to maybe_dummy_object. */
2203 object = maybe_dummy_object (BINFO_TYPE (BASELINK_ACCESS_BINFO (fn)),
2206 if (processing_template_decl)
2208 if (type_dependent_expression_p (object))
2210 tree ret = build_nt_call_vec (orig_fn, orig_args);
2211 release_tree_vector (orig_args);
2214 object = build_non_dependent_expr (object);
2217 result = build_new_method_call (object, fn, args, NULL_TREE,
2219 ? LOOKUP_NORMAL|LOOKUP_NONVIRTUAL
2224 else if (is_overloaded_fn (fn))
2226 /* If the function is an overloaded builtin, resolve it. */
2227 if (TREE_CODE (fn) == FUNCTION_DECL
2228 && (DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL
2229 || DECL_BUILT_IN_CLASS (fn) == BUILT_IN_MD))
2230 result = resolve_overloaded_builtin (input_location, fn, *args);
2234 if (warn_sizeof_pointer_memaccess
2235 && !vec_safe_is_empty (*args)
2236 && !processing_template_decl)
2238 location_t sizeof_arg_loc[3];
2241 for (i = 0; i < 3; i++)
2245 sizeof_arg_loc[i] = UNKNOWN_LOCATION;
2246 sizeof_arg[i] = NULL_TREE;
2247 if (i >= (*args)->length ())
2250 if (TREE_CODE (t) != SIZEOF_EXPR)
2252 if (SIZEOF_EXPR_TYPE_P (t))
2253 sizeof_arg[i] = TREE_TYPE (TREE_OPERAND (t, 0));
2255 sizeof_arg[i] = TREE_OPERAND (t, 0);
2256 sizeof_arg_loc[i] = EXPR_LOCATION (t);
2258 sizeof_pointer_memaccess_warning
2259 (sizeof_arg_loc, fn, *args,
2260 sizeof_arg, same_type_ignoring_top_level_qualifiers_p);
2263 /* A call to a namespace-scope function. */
2264 result = build_new_function_call (fn, args, koenig_p, complain);
2267 else if (TREE_CODE (fn) == PSEUDO_DTOR_EXPR)
2269 if (!vec_safe_is_empty (*args))
2270 error ("arguments to destructor are not allowed");
2271 /* Mark the pseudo-destructor call as having side-effects so
2272 that we do not issue warnings about its use. */
2273 result = build1 (NOP_EXPR,
2275 TREE_OPERAND (fn, 0));
2276 TREE_SIDE_EFFECTS (result) = 1;
2278 else if (CLASS_TYPE_P (TREE_TYPE (fn)))
2279 /* If the "function" is really an object of class type, it might
2280 have an overloaded `operator ()'. */
2281 result = build_op_call (fn, args, complain);
2284 /* A call where the function is unknown. */
2285 result = cp_build_function_call_vec (fn, args, complain);
2287 if (processing_template_decl && result != error_mark_node)
2289 if (INDIRECT_REF_P (result))
2290 result = TREE_OPERAND (result, 0);
2291 result = build_call_vec (TREE_TYPE (result), orig_fn, orig_args);
2292 SET_EXPR_LOCATION (result, input_location);
2293 KOENIG_LOOKUP_P (result) = koenig_p;
2294 release_tree_vector (orig_args);
2295 result = convert_from_reference (result);
2300 /* Free garbage OVERLOADs from arg-dependent lookup. */
2301 tree next = NULL_TREE;
2303 fn && TREE_CODE (fn) == OVERLOAD && OVL_ARG_DEPENDENT (fn);
2306 if (processing_template_decl)
2307 /* In a template, we'll re-use them at instantiation time. */
2308 OVL_ARG_DEPENDENT (fn) = false;
2311 next = OVL_CHAIN (fn);
2320 /* Finish a call to a postfix increment or decrement or EXPR. (Which
2321 is indicated by CODE, which should be POSTINCREMENT_EXPR or
2322 POSTDECREMENT_EXPR.) */
2325 finish_increment_expr (tree expr, enum tree_code code)
2327 return build_x_unary_op (input_location, code, expr, tf_warning_or_error);
2330 /* Finish a use of `this'. Returns an expression for `this'. */
2333 finish_this_expr (void)
2337 if (current_class_ptr)
2339 tree type = TREE_TYPE (current_class_ref);
2341 /* In a lambda expression, 'this' refers to the captured 'this'. */
2342 if (LAMBDA_TYPE_P (type))
2343 result = lambda_expr_this_capture (CLASSTYPE_LAMBDA_EXPR (type));
2345 result = current_class_ptr;
2347 else if (current_function_decl
2348 && DECL_STATIC_FUNCTION_P (current_function_decl))
2350 error ("%<this%> is unavailable for static member functions");
2351 result = error_mark_node;
2355 if (current_function_decl)
2356 error ("invalid use of %<this%> in non-member function");
2358 error ("invalid use of %<this%> at top level");
2359 result = error_mark_node;
2362 /* The keyword 'this' is a prvalue expression. */
2363 result = rvalue (result);
2368 /* Finish a pseudo-destructor expression. If SCOPE is NULL, the
2369 expression was of the form `OBJECT.~DESTRUCTOR' where DESTRUCTOR is
2370 the TYPE for the type given. If SCOPE is non-NULL, the expression
2371 was of the form `OBJECT.SCOPE::~DESTRUCTOR'. */
2374 finish_pseudo_destructor_expr (tree object, tree scope, tree destructor)
2376 if (object == error_mark_node || destructor == error_mark_node)
2377 return error_mark_node;
2379 gcc_assert (TYPE_P (destructor));
2381 if (!processing_template_decl)
2383 if (scope == error_mark_node)
2385 error ("invalid qualifying scope in pseudo-destructor name");
2386 return error_mark_node;
2388 if (is_auto (destructor))
2389 destructor = TREE_TYPE (object);
2390 if (scope && TYPE_P (scope) && !check_dtor_name (scope, destructor))
2392 error ("qualified type %qT does not match destructor name ~%qT",
2394 return error_mark_node;
2398 /* [expr.pseudo] says both:
2400 The type designated by the pseudo-destructor-name shall be
2401 the same as the object type.
2405 The cv-unqualified versions of the object type and of the
2406 type designated by the pseudo-destructor-name shall be the
2409 We implement the more generous second sentence, since that is
2410 what most other compilers do. */
2411 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (object),
2414 error ("%qE is not of type %qT", object, destructor);
2415 return error_mark_node;
2419 return build3 (PSEUDO_DTOR_EXPR, void_type_node, object, scope, destructor);
2422 /* Finish an expression of the form CODE EXPR. */
2425 finish_unary_op_expr (location_t loc, enum tree_code code, tree expr,
2426 tsubst_flags_t complain)
2428 tree result = build_x_unary_op (loc, code, expr, complain);
2429 if ((complain & tf_warning)
2430 && TREE_OVERFLOW_P (result) && !TREE_OVERFLOW_P (expr))
2431 overflow_warning (input_location, result);
2436 /* Finish a compound-literal expression. TYPE is the type to which
2437 the CONSTRUCTOR in COMPOUND_LITERAL is being cast. */
2440 finish_compound_literal (tree type, tree compound_literal,
2441 tsubst_flags_t complain)
2443 if (type == error_mark_node)
2444 return error_mark_node;
2446 if (TREE_CODE (type) == REFERENCE_TYPE)
2449 = finish_compound_literal (TREE_TYPE (type), compound_literal,
2451 return cp_build_c_cast (type, compound_literal, complain);
2454 if (!TYPE_OBJ_P (type))
2456 if (complain & tf_error)
2457 error ("compound literal of non-object type %qT", type);
2458 return error_mark_node;
2461 if (processing_template_decl)
2463 TREE_TYPE (compound_literal) = type;
2464 /* Mark the expression as a compound literal. */
2465 TREE_HAS_CONSTRUCTOR (compound_literal) = 1;
2466 return compound_literal;
2469 type = complete_type (type);
2471 if (TYPE_NON_AGGREGATE_CLASS (type))
2473 /* Trying to deal with a CONSTRUCTOR instead of a TREE_LIST
2474 everywhere that deals with function arguments would be a pain, so
2475 just wrap it in a TREE_LIST. The parser set a flag so we know
2476 that it came from T{} rather than T({}). */
2477 CONSTRUCTOR_IS_DIRECT_INIT (compound_literal) = 1;
2478 compound_literal = build_tree_list (NULL_TREE, compound_literal);
2479 return build_functional_cast (type, compound_literal, complain);
2482 if (TREE_CODE (type) == ARRAY_TYPE
2483 && check_array_initializer (NULL_TREE, type, compound_literal))
2484 return error_mark_node;
2485 compound_literal = reshape_init (type, compound_literal, complain);
2486 if (SCALAR_TYPE_P (type)
2487 && !BRACE_ENCLOSED_INITIALIZER_P (compound_literal)
2488 && (complain & tf_warning_or_error))
2489 check_narrowing (type, compound_literal);
2490 if (TREE_CODE (type) == ARRAY_TYPE
2491 && TYPE_DOMAIN (type) == NULL_TREE)
2493 cp_complete_array_type_or_error (&type, compound_literal,
2495 if (type == error_mark_node)
2496 return error_mark_node;
2498 compound_literal = digest_init (type, compound_literal, complain);
2499 if (TREE_CODE (compound_literal) == CONSTRUCTOR)
2500 TREE_HAS_CONSTRUCTOR (compound_literal) = true;
2501 /* Put static/constant array temporaries in static variables, but always
2502 represent class temporaries with TARGET_EXPR so we elide copies. */
2503 if ((!at_function_scope_p () || CP_TYPE_CONST_P (type))
2504 && TREE_CODE (type) == ARRAY_TYPE
2505 && !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
2506 && initializer_constant_valid_p (compound_literal, type))
2508 tree decl = create_temporary_var (type);
2509 DECL_INITIAL (decl) = compound_literal;
2510 TREE_STATIC (decl) = 1;
2511 if (literal_type_p (type) && CP_TYPE_CONST_NON_VOLATILE_P (type))
2513 /* 5.19 says that a constant expression can include an
2514 lvalue-rvalue conversion applied to "a glvalue of literal type
2515 that refers to a non-volatile temporary object initialized
2516 with a constant expression". Rather than try to communicate
2517 that this VAR_DECL is a temporary, just mark it constexpr. */
2518 DECL_DECLARED_CONSTEXPR_P (decl) = true;
2519 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = true;
2520 TREE_CONSTANT (decl) = true;
2522 cp_apply_type_quals_to_decl (cp_type_quals (type), decl);
2523 decl = pushdecl_top_level (decl);
2524 DECL_NAME (decl) = make_anon_name ();
2525 SET_DECL_ASSEMBLER_NAME (decl, DECL_NAME (decl));
2529 return get_target_expr_sfinae (compound_literal, complain);
2532 /* Return the declaration for the function-name variable indicated by
2536 finish_fname (tree id)
2540 decl = fname_decl (input_location, C_RID_CODE (id), id);
2541 if (processing_template_decl && current_function_decl)
2542 decl = DECL_NAME (decl);
2546 /* Finish a translation unit. */
2549 finish_translation_unit (void)
2551 /* In case there were missing closebraces,
2552 get us back to the global binding level. */
2554 while (current_namespace != global_namespace)
2557 /* Do file scope __FUNCTION__ et al. */
2558 finish_fname_decls ();
2561 /* Finish a template type parameter, specified as AGGR IDENTIFIER.
2562 Returns the parameter. */
2565 finish_template_type_parm (tree aggr, tree identifier)
2567 if (aggr != class_type_node)
2569 permerror (input_location, "template type parameters must use the keyword %<class%> or %<typename%>");
2570 aggr = class_type_node;
2573 return build_tree_list (aggr, identifier);
2576 /* Finish a template template parameter, specified as AGGR IDENTIFIER.
2577 Returns the parameter. */
2580 finish_template_template_parm (tree aggr, tree identifier)
2582 tree decl = build_decl (input_location,
2583 TYPE_DECL, identifier, NULL_TREE);
2584 tree tmpl = build_lang_decl (TEMPLATE_DECL, identifier, NULL_TREE);
2585 DECL_TEMPLATE_PARMS (tmpl) = current_template_parms;
2586 DECL_TEMPLATE_RESULT (tmpl) = decl;
2587 DECL_ARTIFICIAL (decl) = 1;
2588 end_template_decl ();
2590 gcc_assert (DECL_TEMPLATE_PARMS (tmpl));
2592 check_default_tmpl_args (decl, DECL_TEMPLATE_PARMS (tmpl),
2593 /*is_primary=*/true, /*is_partial=*/false,
2596 return finish_template_type_parm (aggr, tmpl);
2599 /* ARGUMENT is the default-argument value for a template template
2600 parameter. If ARGUMENT is invalid, issue error messages and return
2601 the ERROR_MARK_NODE. Otherwise, ARGUMENT itself is returned. */
2604 check_template_template_default_arg (tree argument)
2606 if (TREE_CODE (argument) != TEMPLATE_DECL
2607 && TREE_CODE (argument) != TEMPLATE_TEMPLATE_PARM
2608 && TREE_CODE (argument) != UNBOUND_CLASS_TEMPLATE)
2610 if (TREE_CODE (argument) == TYPE_DECL)
2611 error ("invalid use of type %qT as a default value for a template "
2612 "template-parameter", TREE_TYPE (argument));
2614 error ("invalid default argument for a template template parameter");
2615 return error_mark_node;
2621 /* Begin a class definition, as indicated by T. */
2624 begin_class_definition (tree t)
2626 if (error_operand_p (t) || error_operand_p (TYPE_MAIN_DECL (t)))
2627 return error_mark_node;
2629 if (processing_template_parmlist)
2631 error ("definition of %q#T inside template parameter list", t);
2632 return error_mark_node;
2635 /* According to the C++ ABI, decimal classes defined in ISO/IEC TR 24733
2636 are passed the same as decimal scalar types. */
2637 if (TREE_CODE (t) == RECORD_TYPE
2638 && !processing_template_decl)
2640 tree ns = TYPE_CONTEXT (t);
2641 if (ns && TREE_CODE (ns) == NAMESPACE_DECL
2642 && DECL_CONTEXT (ns) == std_node
2644 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (ns)), "decimal"))
2646 const char *n = TYPE_NAME_STRING (t);
2647 if ((strcmp (n, "decimal32") == 0)
2648 || (strcmp (n, "decimal64") == 0)
2649 || (strcmp (n, "decimal128") == 0))
2650 TYPE_TRANSPARENT_AGGR (t) = 1;
2654 /* A non-implicit typename comes from code like:
2656 template <typename T> struct A {
2657 template <typename U> struct A<T>::B ...
2659 This is erroneous. */
2660 else if (TREE_CODE (t) == TYPENAME_TYPE)
2662 error ("invalid definition of qualified type %qT", t);
2663 t = error_mark_node;
2666 if (t == error_mark_node || ! MAYBE_CLASS_TYPE_P (t))
2668 t = make_class_type (RECORD_TYPE);
2669 pushtag (make_anon_name (), t, /*tag_scope=*/ts_current);
2672 if (TYPE_BEING_DEFINED (t))
2674 t = make_class_type (TREE_CODE (t));
2675 pushtag (TYPE_IDENTIFIER (t), t, /*tag_scope=*/ts_current);
2677 maybe_process_partial_specialization (t);
2679 TYPE_BEING_DEFINED (t) = 1;
2681 if (flag_pack_struct)
2684 TYPE_PACKED (t) = 1;
2685 /* Even though the type is being defined for the first time
2686 here, there might have been a forward declaration, so there
2687 might be cv-qualified variants of T. */
2688 for (v = TYPE_NEXT_VARIANT (t); v; v = TYPE_NEXT_VARIANT (v))
2689 TYPE_PACKED (v) = 1;
2691 /* Reset the interface data, at the earliest possible
2692 moment, as it might have been set via a class foo;
2694 if (! TYPE_ANONYMOUS_P (t))
2696 struct c_fileinfo *finfo = get_fileinfo (input_filename);
2697 CLASSTYPE_INTERFACE_ONLY (t) = finfo->interface_only;
2698 SET_CLASSTYPE_INTERFACE_UNKNOWN_X
2699 (t, finfo->interface_unknown);
2701 reset_specialization();
2703 /* Make a declaration for this class in its own scope. */
2704 build_self_reference ();
2709 /* Finish the member declaration given by DECL. */
2712 finish_member_declaration (tree decl)
2714 if (decl == error_mark_node || decl == NULL_TREE)
2717 if (decl == void_type_node)
2718 /* The COMPONENT was a friend, not a member, and so there's
2719 nothing for us to do. */
2722 /* We should see only one DECL at a time. */
2723 gcc_assert (DECL_CHAIN (decl) == NULL_TREE);
2725 /* Set up access control for DECL. */
2727 = (current_access_specifier == access_private_node);
2728 TREE_PROTECTED (decl)
2729 = (current_access_specifier == access_protected_node);
2730 if (TREE_CODE (decl) == TEMPLATE_DECL)
2732 TREE_PRIVATE (DECL_TEMPLATE_RESULT (decl)) = TREE_PRIVATE (decl);
2733 TREE_PROTECTED (DECL_TEMPLATE_RESULT (decl)) = TREE_PROTECTED (decl);
2736 /* Mark the DECL as a member of the current class, unless it's
2737 a member of an enumeration. */
2738 if (TREE_CODE (decl) != CONST_DECL)
2739 DECL_CONTEXT (decl) = current_class_type;
2741 /* Check for bare parameter packs in the member variable declaration. */
2742 if (TREE_CODE (decl) == FIELD_DECL)
2744 if (check_for_bare_parameter_packs (TREE_TYPE (decl)))
2745 TREE_TYPE (decl) = error_mark_node;
2746 if (check_for_bare_parameter_packs (DECL_ATTRIBUTES (decl)))
2747 DECL_ATTRIBUTES (decl) = NULL_TREE;
2752 A C language linkage is ignored for the names of class members
2753 and the member function type of class member functions. */
2754 if (DECL_LANG_SPECIFIC (decl) && DECL_LANGUAGE (decl) == lang_c)
2755 SET_DECL_LANGUAGE (decl, lang_cplusplus);
2757 /* Put functions on the TYPE_METHODS list and everything else on the
2758 TYPE_FIELDS list. Note that these are built up in reverse order.
2759 We reverse them (to obtain declaration order) in finish_struct. */
2760 if (DECL_DECLARES_FUNCTION_P (decl))
2762 /* We also need to add this function to the
2763 CLASSTYPE_METHOD_VEC. */
2764 if (add_method (current_class_type, decl, NULL_TREE))
2766 DECL_CHAIN (decl) = TYPE_METHODS (current_class_type);
2767 TYPE_METHODS (current_class_type) = decl;
2769 maybe_add_class_template_decl_list (current_class_type, decl,
2773 /* Enter the DECL into the scope of the class, if the class
2774 isn't a closure (whose fields are supposed to be unnamed). */
2775 else if (CLASSTYPE_LAMBDA_EXPR (current_class_type)
2776 || pushdecl_class_level (decl))
2778 if (TREE_CODE (decl) == USING_DECL)
2780 /* For now, ignore class-scope USING_DECLS, so that
2781 debugging backends do not see them. */
2782 DECL_IGNORED_P (decl) = 1;
2785 /* All TYPE_DECLs go at the end of TYPE_FIELDS. Ordinary fields
2786 go at the beginning. The reason is that lookup_field_1
2787 searches the list in order, and we want a field name to
2788 override a type name so that the "struct stat hack" will
2789 work. In particular:
2791 struct S { enum E { }; int E } s;
2794 is valid. In addition, the FIELD_DECLs must be maintained in
2795 declaration order so that class layout works as expected.
2796 However, we don't need that order until class layout, so we
2797 save a little time by putting FIELD_DECLs on in reverse order
2798 here, and then reversing them in finish_struct_1. (We could
2799 also keep a pointer to the correct insertion points in the
2802 if (TREE_CODE (decl) == TYPE_DECL)
2803 TYPE_FIELDS (current_class_type)
2804 = chainon (TYPE_FIELDS (current_class_type), decl);
2807 DECL_CHAIN (decl) = TYPE_FIELDS (current_class_type);
2808 TYPE_FIELDS (current_class_type) = decl;
2811 maybe_add_class_template_decl_list (current_class_type, decl,
2816 note_decl_for_pch (decl);
2819 /* DECL has been declared while we are building a PCH file. Perform
2820 actions that we might normally undertake lazily, but which can be
2821 performed now so that they do not have to be performed in
2822 translation units which include the PCH file. */
2825 note_decl_for_pch (tree decl)
2827 gcc_assert (pch_file);
2829 /* There's a good chance that we'll have to mangle names at some
2830 point, even if only for emission in debugging information. */
2831 if (VAR_OR_FUNCTION_DECL_P (decl)
2832 && !processing_template_decl)
2836 /* Finish processing a complete template declaration. The PARMS are
2837 the template parameters. */
2840 finish_template_decl (tree parms)
2843 end_template_decl ();
2845 end_specialization ();
2848 /* Finish processing a template-id (which names a type) of the form
2849 NAME < ARGS >. Return the TYPE_DECL for the type named by the
2850 template-id. If ENTERING_SCOPE is nonzero we are about to enter
2851 the scope of template-id indicated. */
2854 finish_template_type (tree name, tree args, int entering_scope)
2858 type = lookup_template_class (name, args,
2859 NULL_TREE, NULL_TREE, entering_scope,
2860 tf_warning_or_error | tf_user);
2861 if (type == error_mark_node)
2863 else if (CLASS_TYPE_P (type) && !alias_type_or_template_p (type))
2864 return TYPE_STUB_DECL (type);
2866 return TYPE_NAME (type);
2869 /* Finish processing a BASE_CLASS with the indicated ACCESS_SPECIFIER.
2870 Return a TREE_LIST containing the ACCESS_SPECIFIER and the
2871 BASE_CLASS, or NULL_TREE if an error occurred. The
2872 ACCESS_SPECIFIER is one of
2873 access_{default,public,protected_private}_node. For a virtual base
2874 we set TREE_TYPE. */
2877 finish_base_specifier (tree base, tree access, bool virtual_p)
2881 if (base == error_mark_node)
2883 error ("invalid base-class specification");
2886 else if (! MAYBE_CLASS_TYPE_P (base))
2888 error ("%qT is not a class type", base);
2893 if (cp_type_quals (base) != 0)
2895 /* DR 484: Can a base-specifier name a cv-qualified
2897 base = TYPE_MAIN_VARIANT (base);
2899 result = build_tree_list (access, base);
2901 TREE_TYPE (result) = integer_type_node;
2907 /* If FNS is a member function, a set of member functions, or a
2908 template-id referring to one or more member functions, return a
2909 BASELINK for FNS, incorporating the current access context.
2910 Otherwise, return FNS unchanged. */
2913 baselink_for_fns (tree fns)
2918 if (BASELINK_P (fns)
2919 || error_operand_p (fns))
2922 scope = ovl_scope (fns);
2923 if (!CLASS_TYPE_P (scope))
2926 cl = currently_open_derived_class (scope);
2929 cl = TYPE_BINFO (cl);
2930 return build_baselink (cl, cl, fns, /*optype=*/NULL_TREE);
2933 /* Returns true iff DECL is a variable from a function outside
2937 outer_var_p (tree decl)
2939 return ((VAR_P (decl) || TREE_CODE (decl) == PARM_DECL)
2940 && DECL_FUNCTION_SCOPE_P (decl)
2941 && (DECL_CONTEXT (decl) != current_function_decl
2942 || parsing_nsdmi ()));
2945 /* As above, but also checks that DECL is automatic. */
2948 outer_automatic_var_p (tree decl)
2950 return (outer_var_p (decl)
2951 && !TREE_STATIC (decl));
2954 /* ID_EXPRESSION is a representation of parsed, but unprocessed,
2955 id-expression. (See cp_parser_id_expression for details.) SCOPE,
2956 if non-NULL, is the type or namespace used to explicitly qualify
2957 ID_EXPRESSION. DECL is the entity to which that name has been
2960 *CONSTANT_EXPRESSION_P is true if we are presently parsing a
2961 constant-expression. In that case, *NON_CONSTANT_EXPRESSION_P will
2962 be set to true if this expression isn't permitted in a
2963 constant-expression, but it is otherwise not set by this function.
2964 *ALLOW_NON_CONSTANT_EXPRESSION_P is true if we are parsing a
2965 constant-expression, but a non-constant expression is also
2968 DONE is true if this expression is a complete postfix-expression;
2969 it is false if this expression is followed by '->', '[', '(', etc.
2970 ADDRESS_P is true iff this expression is the operand of '&'.
2971 TEMPLATE_P is true iff the qualified-id was of the form
2972 "A::template B". TEMPLATE_ARG_P is true iff this qualified name
2973 appears as a template argument.
2975 If an error occurs, and it is the kind of error that might cause
2976 the parser to abort a tentative parse, *ERROR_MSG is filled in. It
2977 is the caller's responsibility to issue the message. *ERROR_MSG
2978 will be a string with static storage duration, so the caller need
2981 Return an expression for the entity, after issuing appropriate
2982 diagnostics. This function is also responsible for transforming a
2983 reference to a non-static member into a COMPONENT_REF that makes
2984 the use of "this" explicit.
2986 Upon return, *IDK will be filled in appropriately. */
2988 finish_id_expression (tree id_expression,
2992 bool integral_constant_expression_p,
2993 bool allow_non_integral_constant_expression_p,
2994 bool *non_integral_constant_expression_p,
2998 bool template_arg_p,
2999 const char **error_msg,
3000 location_t location)
3002 decl = strip_using_decl (decl);
3004 /* Initialize the output parameters. */
3005 *idk = CP_ID_KIND_NONE;
3008 if (id_expression == error_mark_node)
3009 return error_mark_node;
3010 /* If we have a template-id, then no further lookup is
3011 required. If the template-id was for a template-class, we
3012 will sometimes have a TYPE_DECL at this point. */
3013 else if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
3014 || TREE_CODE (decl) == TYPE_DECL)
3016 /* Look up the name. */
3019 if (decl == error_mark_node)
3021 /* Name lookup failed. */
3024 || (!dependent_type_p (scope)
3025 && !(identifier_p (id_expression)
3026 && IDENTIFIER_TYPENAME_P (id_expression)
3027 && dependent_type_p (TREE_TYPE (id_expression))))))
3029 /* If the qualifying type is non-dependent (and the name
3030 does not name a conversion operator to a dependent
3031 type), issue an error. */
3032 qualified_name_lookup_error (scope, id_expression, decl, location);
3033 return error_mark_node;
3037 /* It may be resolved via Koenig lookup. */
3038 *idk = CP_ID_KIND_UNQUALIFIED;
3039 return id_expression;
3042 decl = id_expression;
3044 /* If DECL is a variable that would be out of scope under
3045 ANSI/ISO rules, but in scope in the ARM, name lookup
3046 will succeed. Issue a diagnostic here. */
3048 decl = check_for_out_of_scope_variable (decl);
3050 /* Remember that the name was used in the definition of
3051 the current class so that we can check later to see if
3052 the meaning would have been different after the class
3053 was entirely defined. */
3054 if (!scope && decl != error_mark_node && identifier_p (id_expression))
3055 maybe_note_name_used_in_class (id_expression, decl);
3057 /* Disallow uses of local variables from containing functions, except
3058 within lambda-expressions. */
3059 if (!outer_var_p (decl)
3060 /* It's not a use (3.2) if we're in an unevaluated context. */
3061 || cp_unevaluated_operand)
3063 else if (TREE_STATIC (decl))
3065 if (processing_template_decl)
3066 /* For a use of an outer static var, return the identifier so
3067 that we'll look it up again in the instantiation. */
3068 return id_expression;
3072 tree context = DECL_CONTEXT (decl);
3073 tree containing_function = current_function_decl;
3074 tree lambda_stack = NULL_TREE;
3075 tree lambda_expr = NULL_TREE;
3076 tree initializer = convert_from_reference (decl);
3078 /* Mark it as used now even if the use is ill-formed. */
3081 /* Core issue 696: "[At the July 2009 meeting] the CWG expressed
3082 support for an approach in which a reference to a local
3083 [constant] automatic variable in a nested class or lambda body
3084 would enter the expression as an rvalue, which would reduce
3085 the complexity of the problem"
3087 FIXME update for final resolution of core issue 696. */
3088 if (decl_constant_var_p (decl))
3090 if (processing_template_decl)
3091 /* In a template, the constant value may not be in a usable
3092 form, so look it up again at instantiation time. */
3093 return id_expression;
3095 return integral_constant_value (decl);
3098 if (parsing_nsdmi ())
3099 containing_function = NULL_TREE;
3100 /* If we are in a lambda function, we can move out until we hit
3102 2. a non-lambda function, or
3103 3. a non-default capturing lambda function. */
3104 else while (context != containing_function
3105 && LAMBDA_FUNCTION_P (containing_function))
3107 lambda_expr = CLASSTYPE_LAMBDA_EXPR
3108 (DECL_CONTEXT (containing_function));
3110 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr)
3114 lambda_stack = tree_cons (NULL_TREE,
3119 = decl_function_context (containing_function);
3122 if (lambda_expr && TREE_CODE (decl) == VAR_DECL
3123 && DECL_ANON_UNION_VAR_P (decl))
3125 error ("cannot capture member %qD of anonymous union", decl);
3126 return error_mark_node;
3128 if (context == containing_function)
3130 decl = add_default_capture (lambda_stack,
3131 /*id=*/DECL_NAME (decl),
3134 else if (lambda_expr)
3136 error ("%qD is not captured", decl);
3137 return error_mark_node;
3142 ? G_("use of local variable with automatic storage from containing function")
3143 : G_("use of parameter from containing function"));
3144 error (" %q+#D declared here", decl);
3145 return error_mark_node;
3149 /* Also disallow uses of function parameters outside the function
3150 body, except inside an unevaluated context (i.e. decltype). */
3151 if (TREE_CODE (decl) == PARM_DECL
3152 && DECL_CONTEXT (decl) == NULL_TREE
3153 && !cp_unevaluated_operand)
3155 error ("use of parameter %qD outside function body", decl);
3156 return error_mark_node;
3160 /* If we didn't find anything, or what we found was a type,
3161 then this wasn't really an id-expression. */
3162 if (TREE_CODE (decl) == TEMPLATE_DECL
3163 && !DECL_FUNCTION_TEMPLATE_P (decl))
3165 *error_msg = "missing template arguments";
3166 return error_mark_node;
3168 else if (TREE_CODE (decl) == TYPE_DECL
3169 || TREE_CODE (decl) == NAMESPACE_DECL)
3171 *error_msg = "expected primary-expression";
3172 return error_mark_node;
3175 /* If the name resolved to a template parameter, there is no
3176 need to look it up again later. */
3177 if ((TREE_CODE (decl) == CONST_DECL && DECL_TEMPLATE_PARM_P (decl))
3178 || TREE_CODE (decl) == TEMPLATE_PARM_INDEX)
3182 *idk = CP_ID_KIND_NONE;
3183 if (TREE_CODE (decl) == TEMPLATE_PARM_INDEX)
3184 decl = TEMPLATE_PARM_DECL (decl);
3185 r = convert_from_reference (DECL_INITIAL (decl));
3187 if (integral_constant_expression_p
3188 && !dependent_type_p (TREE_TYPE (decl))
3189 && !(INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (r))))
3191 if (!allow_non_integral_constant_expression_p)
3192 error ("template parameter %qD of type %qT is not allowed in "
3193 "an integral constant expression because it is not of "
3194 "integral or enumeration type", decl, TREE_TYPE (decl));
3195 *non_integral_constant_expression_p = true;
3203 /* If the declaration was explicitly qualified indicate
3204 that. The semantics of `A::f(3)' are different than
3205 `f(3)' if `f' is virtual. */
3207 ? CP_ID_KIND_QUALIFIED
3208 : (TREE_CODE (decl) == TEMPLATE_ID_EXPR
3209 ? CP_ID_KIND_TEMPLATE_ID
3210 : CP_ID_KIND_UNQUALIFIED));
3215 An id-expression is type-dependent if it contains an
3216 identifier that was declared with a dependent type.
3218 The standard is not very specific about an id-expression that
3219 names a set of overloaded functions. What if some of them
3220 have dependent types and some of them do not? Presumably,
3221 such a name should be treated as a dependent name. */
3222 /* Assume the name is not dependent. */
3223 dependent_p = false;
3224 if (!processing_template_decl)
3225 /* No names are dependent outside a template. */
3227 else if (TREE_CODE (decl) == CONST_DECL)
3228 /* We don't want to treat enumerators as dependent. */
3230 /* A template-id where the name of the template was not resolved
3231 is definitely dependent. */
3232 else if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
3233 && (identifier_p (TREE_OPERAND (decl, 0))))
3235 /* For anything except an overloaded function, just check its
3237 else if (!is_overloaded_fn (decl))
3239 = dependent_type_p (TREE_TYPE (decl));
3240 /* For a set of overloaded functions, check each of the
3246 if (BASELINK_P (fns))
3247 fns = BASELINK_FUNCTIONS (fns);
3249 /* For a template-id, check to see if the template
3250 arguments are dependent. */
3251 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
3253 tree args = TREE_OPERAND (fns, 1);
3254 dependent_p = any_dependent_template_arguments_p (args);
3255 /* The functions are those referred to by the
3257 fns = TREE_OPERAND (fns, 0);
3260 /* If there are no dependent template arguments, go through
3261 the overloaded functions. */
3262 while (fns && !dependent_p)
3264 tree fn = OVL_CURRENT (fns);
3266 /* Member functions of dependent classes are
3268 if (TREE_CODE (fn) == FUNCTION_DECL
3269 && type_dependent_expression_p (fn))
3271 else if (TREE_CODE (fn) == TEMPLATE_DECL
3272 && dependent_template_p (fn))
3275 fns = OVL_NEXT (fns);
3279 /* If the name was dependent on a template parameter, we will
3280 resolve the name at instantiation time. */
3283 /* Create a SCOPE_REF for qualified names, if the scope is
3289 if (address_p && done)
3290 decl = finish_qualified_id_expr (scope, decl,
3294 tf_warning_or_error);
3297 tree type = NULL_TREE;
3298 if (DECL_P (decl) && !dependent_scope_p (scope))
3299 type = TREE_TYPE (decl);
3300 decl = build_qualified_name (type,
3306 if (TREE_TYPE (decl))
3307 decl = convert_from_reference (decl);
3310 /* A TEMPLATE_ID already contains all the information we
3312 if (TREE_CODE (id_expression) == TEMPLATE_ID_EXPR)
3313 return id_expression;
3314 *idk = CP_ID_KIND_UNQUALIFIED_DEPENDENT;
3315 /* If we found a variable, then name lookup during the
3316 instantiation will always resolve to the same VAR_DECL
3317 (or an instantiation thereof). */
3319 || TREE_CODE (decl) == PARM_DECL)
3322 return convert_from_reference (decl);
3324 /* The same is true for FIELD_DECL, but we also need to
3325 make sure that the syntax is correct. */
3326 else if (TREE_CODE (decl) == FIELD_DECL)
3328 /* Since SCOPE is NULL here, this is an unqualified name.
3329 Access checking has been performed during name lookup
3330 already. Turn off checking to avoid duplicate errors. */
3331 push_deferring_access_checks (dk_no_check);
3332 decl = finish_non_static_data_member
3334 /*qualifying_scope=*/NULL_TREE);
3335 pop_deferring_access_checks ();
3338 return id_expression;
3341 if (TREE_CODE (decl) == NAMESPACE_DECL)
3343 error ("use of namespace %qD as expression", decl);
3344 return error_mark_node;
3346 else if (DECL_CLASS_TEMPLATE_P (decl))
3348 error ("use of class template %qT as expression", decl);
3349 return error_mark_node;
3351 else if (TREE_CODE (decl) == TREE_LIST)
3353 /* Ambiguous reference to base members. */
3354 error ("request for member %qD is ambiguous in "
3355 "multiple inheritance lattice", id_expression);
3356 print_candidates (decl);
3357 return error_mark_node;
3360 /* Mark variable-like entities as used. Functions are similarly
3361 marked either below or after overload resolution. */
3363 || TREE_CODE (decl) == PARM_DECL
3364 || TREE_CODE (decl) == CONST_DECL
3365 || TREE_CODE (decl) == RESULT_DECL)
3366 && !mark_used (decl))
3367 return error_mark_node;
3369 /* Only certain kinds of names are allowed in constant
3370 expression. Template parameters have already
3371 been handled above. */
3372 if (! error_operand_p (decl)
3373 && integral_constant_expression_p
3374 && ! decl_constant_var_p (decl)
3375 && TREE_CODE (decl) != CONST_DECL
3376 && ! builtin_valid_in_constant_expr_p (decl))
3378 if (!allow_non_integral_constant_expression_p)
3380 error ("%qD cannot appear in a constant-expression", decl);
3381 return error_mark_node;
3383 *non_integral_constant_expression_p = true;
3388 && !cp_unevaluated_operand
3389 && DECL_THREAD_LOCAL_P (decl)
3390 && (wrap = get_tls_wrapper_fn (decl)))
3392 /* Replace an evaluated use of the thread_local variable with
3393 a call to its wrapper. */
3394 decl = build_cxx_call (wrap, 0, NULL, tf_warning_or_error);
3398 decl = (adjust_result_of_qualified_name_lookup
3399 (decl, scope, current_nonlambda_class_type()));
3401 if (TREE_CODE (decl) == FUNCTION_DECL)
3405 decl = finish_qualified_id_expr (scope,
3411 tf_warning_or_error);
3413 decl = convert_from_reference (decl);
3415 else if (TREE_CODE (decl) == FIELD_DECL)
3417 /* Since SCOPE is NULL here, this is an unqualified name.
3418 Access checking has been performed during name lookup
3419 already. Turn off checking to avoid duplicate errors. */
3420 push_deferring_access_checks (dk_no_check);
3421 decl = finish_non_static_data_member (decl, NULL_TREE,
3422 /*qualifying_scope=*/NULL_TREE);
3423 pop_deferring_access_checks ();
3425 else if (is_overloaded_fn (decl))
3429 first_fn = get_first_fn (decl);
3430 if (TREE_CODE (first_fn) == TEMPLATE_DECL)
3431 first_fn = DECL_TEMPLATE_RESULT (first_fn);
3433 if (!really_overloaded_fn (decl)
3434 && !mark_used (first_fn))
3435 return error_mark_node;
3438 && TREE_CODE (first_fn) == FUNCTION_DECL
3439 && DECL_FUNCTION_MEMBER_P (first_fn)
3440 && !shared_member_p (decl))
3442 /* A set of member functions. */
3443 decl = maybe_dummy_object (DECL_CONTEXT (first_fn), 0);
3444 return finish_class_member_access_expr (decl, id_expression,
3445 /*template_p=*/false,
3446 tf_warning_or_error);
3449 decl = baselink_for_fns (decl);
3453 if (DECL_P (decl) && DECL_NONLOCAL (decl)
3454 && DECL_CLASS_SCOPE_P (decl))
3456 tree context = context_for_name_lookup (decl);
3457 if (context != current_class_type)
3459 tree path = currently_open_derived_class (context);
3460 perform_or_defer_access_check (TYPE_BINFO (path),
3462 tf_warning_or_error);
3466 decl = convert_from_reference (decl);
3470 if (TREE_DEPRECATED (decl))
3471 warn_deprecated_use (decl, NULL_TREE);
3476 /* Implement the __typeof keyword: Return the type of EXPR, suitable for
3477 use as a type-specifier. */
3480 finish_typeof (tree expr)
3484 if (type_dependent_expression_p (expr))
3486 type = cxx_make_type (TYPEOF_TYPE);
3487 TYPEOF_TYPE_EXPR (type) = expr;
3488 SET_TYPE_STRUCTURAL_EQUALITY (type);
3493 expr = mark_type_use (expr);
3495 type = unlowered_expr_type (expr);
3497 if (!type || type == unknown_type_node)
3499 error ("type of %qE is unknown", expr);
3500 return error_mark_node;
3506 /* Implement the __underlying_type keyword: Return the underlying
3507 type of TYPE, suitable for use as a type-specifier. */
3510 finish_underlying_type (tree type)
3512 tree underlying_type;
3514 if (processing_template_decl)
3516 underlying_type = cxx_make_type (UNDERLYING_TYPE);
3517 UNDERLYING_TYPE_TYPE (underlying_type) = type;
3518 SET_TYPE_STRUCTURAL_EQUALITY (underlying_type);
3520 return underlying_type;
3523 complete_type (type);
3525 if (TREE_CODE (type) != ENUMERAL_TYPE)
3527 error ("%qT is not an enumeration type", type);
3528 return error_mark_node;
3531 underlying_type = ENUM_UNDERLYING_TYPE (type);
3533 /* Fixup necessary in this case because ENUM_UNDERLYING_TYPE
3534 includes TYPE_MIN_VALUE and TYPE_MAX_VALUE information.
3535 See finish_enum_value_list for details. */
3536 if (!ENUM_FIXED_UNDERLYING_TYPE_P (type))
3538 = c_common_type_for_mode (TYPE_MODE (underlying_type),
3539 TYPE_UNSIGNED (underlying_type));
3541 return underlying_type;
3544 /* Implement the __direct_bases keyword: Return the direct base classes
3548 calculate_direct_bases (tree type)
3550 vec<tree, va_gc> *vector = make_tree_vector();
3551 tree bases_vec = NULL_TREE;
3552 vec<tree, va_gc> *base_binfos;
3556 complete_type (type);
3558 if (!NON_UNION_CLASS_TYPE_P (type))
3559 return make_tree_vec (0);
3561 base_binfos = BINFO_BASE_BINFOS (TYPE_BINFO (type));
3563 /* Virtual bases are initialized first */
3564 for (i = 0; base_binfos->iterate (i, &binfo); i++)
3566 if (BINFO_VIRTUAL_P (binfo))
3568 vec_safe_push (vector, binfo);
3572 /* Now non-virtuals */
3573 for (i = 0; base_binfos->iterate (i, &binfo); i++)
3575 if (!BINFO_VIRTUAL_P (binfo))
3577 vec_safe_push (vector, binfo);
3582 bases_vec = make_tree_vec (vector->length ());
3584 for (i = 0; i < vector->length (); ++i)
3586 TREE_VEC_ELT (bases_vec, i) = BINFO_TYPE ((*vector)[i]);
3591 /* Implement the __bases keyword: Return the base classes
3594 /* Find morally non-virtual base classes by walking binfo hierarchy */
3595 /* Virtual base classes are handled separately in finish_bases */
3598 dfs_calculate_bases_pre (tree binfo, void * /*data_*/)
3600 /* Don't walk bases of virtual bases */
3601 return BINFO_VIRTUAL_P (binfo) ? dfs_skip_bases : NULL_TREE;
3605 dfs_calculate_bases_post (tree binfo, void *data_)
3607 vec<tree, va_gc> **data = ((vec<tree, va_gc> **) data_);
3608 if (!BINFO_VIRTUAL_P (binfo))
3610 vec_safe_push (*data, BINFO_TYPE (binfo));
3615 /* Calculates the morally non-virtual base classes of a class */
3616 static vec<tree, va_gc> *
3617 calculate_bases_helper (tree type)
3619 vec<tree, va_gc> *vector = make_tree_vector();
3621 /* Now add non-virtual base classes in order of construction */
3622 dfs_walk_all (TYPE_BINFO (type),
3623 dfs_calculate_bases_pre, dfs_calculate_bases_post, &vector);
3628 calculate_bases (tree type)
3630 vec<tree, va_gc> *vector = make_tree_vector();
3631 tree bases_vec = NULL_TREE;
3633 vec<tree, va_gc> *vbases;
3634 vec<tree, va_gc> *nonvbases;
3637 complete_type (type);
3639 if (!NON_UNION_CLASS_TYPE_P (type))
3640 return make_tree_vec (0);
3642 /* First go through virtual base classes */
3643 for (vbases = CLASSTYPE_VBASECLASSES (type), i = 0;
3644 vec_safe_iterate (vbases, i, &binfo); i++)
3646 vec<tree, va_gc> *vbase_bases;
3647 vbase_bases = calculate_bases_helper (BINFO_TYPE (binfo));
3648 vec_safe_splice (vector, vbase_bases);
3649 release_tree_vector (vbase_bases);
3652 /* Now for the non-virtual bases */
3653 nonvbases = calculate_bases_helper (type);
3654 vec_safe_splice (vector, nonvbases);
3655 release_tree_vector (nonvbases);
3657 /* Last element is entire class, so don't copy */
3658 bases_vec = make_tree_vec (vector->length () - 1);
3660 for (i = 0; i < vector->length () - 1; ++i)
3662 TREE_VEC_ELT (bases_vec, i) = (*vector)[i];
3664 release_tree_vector (vector);
3669 finish_bases (tree type, bool direct)
3671 tree bases = NULL_TREE;
3673 if (!processing_template_decl)
3675 /* Parameter packs can only be used in templates */
3676 error ("Parameter pack __bases only valid in template declaration");
3677 return error_mark_node;
3680 bases = cxx_make_type (BASES);
3681 BASES_TYPE (bases) = type;
3682 BASES_DIRECT (bases) = direct;
3683 SET_TYPE_STRUCTURAL_EQUALITY (bases);
3688 /* Perform C++-specific checks for __builtin_offsetof before calling
3692 finish_offsetof (tree expr)
3694 if (TREE_CODE (expr) == PSEUDO_DTOR_EXPR)
3696 error ("cannot apply %<offsetof%> to destructor %<~%T%>",
3697 TREE_OPERAND (expr, 2));
3698 return error_mark_node;
3700 if (TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE
3701 || TREE_CODE (TREE_TYPE (expr)) == METHOD_TYPE
3702 || TREE_TYPE (expr) == unknown_type_node)
3704 if (TREE_CODE (expr) == INDIRECT_REF)
3705 error ("second operand of %<offsetof%> is neither a single "
3706 "identifier nor a sequence of member accesses and "
3707 "array references");
3710 if (TREE_CODE (expr) == COMPONENT_REF
3711 || TREE_CODE (expr) == COMPOUND_EXPR)
3712 expr = TREE_OPERAND (expr, 1);
3713 error ("cannot apply %<offsetof%> to member function %qD", expr);
3715 return error_mark_node;
3717 if (REFERENCE_REF_P (expr))
3718 expr = TREE_OPERAND (expr, 0);
3719 if (TREE_CODE (expr) == COMPONENT_REF)
3721 tree object = TREE_OPERAND (expr, 0);
3722 if (!complete_type_or_else (TREE_TYPE (object), object))
3723 return error_mark_node;
3725 return fold_offsetof (expr);
3728 /* Replace the AGGR_INIT_EXPR at *TP with an equivalent CALL_EXPR. This
3729 function is broken out from the above for the benefit of the tree-ssa
3733 simplify_aggr_init_expr (tree *tp)
3735 tree aggr_init_expr = *tp;
3737 /* Form an appropriate CALL_EXPR. */
3738 tree fn = AGGR_INIT_EXPR_FN (aggr_init_expr);
3739 tree slot = AGGR_INIT_EXPR_SLOT (aggr_init_expr);
3740 tree type = TREE_TYPE (slot);
3743 enum style_t { ctor, arg, pcc } style;
3745 if (AGGR_INIT_VIA_CTOR_P (aggr_init_expr))
3747 #ifdef PCC_STATIC_STRUCT_RETURN
3753 gcc_assert (TREE_ADDRESSABLE (type));
3757 call_expr = build_call_array_loc (input_location,
3758 TREE_TYPE (TREE_TYPE (TREE_TYPE (fn))),
3760 aggr_init_expr_nargs (aggr_init_expr),
3761 AGGR_INIT_EXPR_ARGP (aggr_init_expr));
3762 TREE_NOTHROW (call_expr) = TREE_NOTHROW (aggr_init_expr);
3766 /* Replace the first argument to the ctor with the address of the
3768 cxx_mark_addressable (slot);
3769 CALL_EXPR_ARG (call_expr, 0) =
3770 build1 (ADDR_EXPR, build_pointer_type (type), slot);
3772 else if (style == arg)
3774 /* Just mark it addressable here, and leave the rest to
3775 expand_call{,_inline}. */
3776 cxx_mark_addressable (slot);
3777 CALL_EXPR_RETURN_SLOT_OPT (call_expr) = true;
3778 call_expr = build2 (INIT_EXPR, TREE_TYPE (call_expr), slot, call_expr);
3780 else if (style == pcc)
3782 /* If we're using the non-reentrant PCC calling convention, then we
3783 need to copy the returned value out of the static buffer into the
3785 push_deferring_access_checks (dk_no_check);
3786 call_expr = build_aggr_init (slot, call_expr,
3787 DIRECT_BIND | LOOKUP_ONLYCONVERTING,
3788 tf_warning_or_error);
3789 pop_deferring_access_checks ();
3790 call_expr = build2 (COMPOUND_EXPR, TREE_TYPE (slot), call_expr, slot);
3793 if (AGGR_INIT_ZERO_FIRST (aggr_init_expr))
3795 tree init = build_zero_init (type, NULL_TREE,
3796 /*static_storage_p=*/false);
3797 init = build2 (INIT_EXPR, void_type_node, slot, init);
3798 call_expr = build2 (COMPOUND_EXPR, TREE_TYPE (call_expr),
3805 /* Emit all thunks to FN that should be emitted when FN is emitted. */
3808 emit_associated_thunks (tree fn)
3810 /* When we use vcall offsets, we emit thunks with the virtual
3811 functions to which they thunk. The whole point of vcall offsets
3812 is so that you can know statically the entire set of thunks that
3813 will ever be needed for a given virtual function, thereby
3814 enabling you to output all the thunks with the function itself. */
3815 if (DECL_VIRTUAL_P (fn)
3816 /* Do not emit thunks for extern template instantiations. */
3817 && ! DECL_REALLY_EXTERN (fn))
3821 for (thunk = DECL_THUNKS (fn); thunk; thunk = DECL_CHAIN (thunk))
3823 if (!THUNK_ALIAS (thunk))
3825 use_thunk (thunk, /*emit_p=*/1);
3826 if (DECL_RESULT_THUNK_P (thunk))
3830 for (probe = DECL_THUNKS (thunk);
3831 probe; probe = DECL_CHAIN (probe))
3832 use_thunk (probe, /*emit_p=*/1);
3836 gcc_assert (!DECL_THUNKS (thunk));
3841 /* Returns true iff FUN is an instantiation of a constexpr function
3845 is_instantiation_of_constexpr (tree fun)
3847 return (DECL_TEMPLOID_INSTANTIATION (fun)
3848 && DECL_DECLARED_CONSTEXPR_P (DECL_TEMPLATE_RESULT
3849 (DECL_TI_TEMPLATE (fun))));
3852 /* Generate RTL for FN. */
3855 expand_or_defer_fn_1 (tree fn)
3857 /* When the parser calls us after finishing the body of a template
3858 function, we don't really want to expand the body. */
3859 if (processing_template_decl)
3861 /* Normally, collection only occurs in rest_of_compilation. So,
3862 if we don't collect here, we never collect junk generated
3863 during the processing of templates until we hit a
3864 non-template function. It's not safe to do this inside a
3865 nested class, though, as the parser may have local state that
3866 is not a GC root. */
3867 if (!function_depth)
3872 gcc_assert (DECL_SAVED_TREE (fn));
3874 /* If this is a constructor or destructor body, we have to clone
3876 if (maybe_clone_body (fn))
3878 /* We don't want to process FN again, so pretend we've written
3879 it out, even though we haven't. */
3880 TREE_ASM_WRITTEN (fn) = 1;
3881 /* If this is an instantiation of a constexpr function, keep
3882 DECL_SAVED_TREE for explain_invalid_constexpr_fn. */
3883 if (!is_instantiation_of_constexpr (fn))
3884 DECL_SAVED_TREE (fn) = NULL_TREE;
3888 /* We make a decision about linkage for these functions at the end
3889 of the compilation. Until that point, we do not want the back
3890 end to output them -- but we do want it to see the bodies of
3891 these functions so that it can inline them as appropriate. */
3892 if (DECL_DECLARED_INLINE_P (fn) || DECL_IMPLICIT_INSTANTIATION (fn))
3894 if (DECL_INTERFACE_KNOWN (fn))
3895 /* We've already made a decision as to how this function will
3899 DECL_EXTERNAL (fn) = 1;
3900 DECL_NOT_REALLY_EXTERN (fn) = 1;
3901 note_vague_linkage_fn (fn);
3902 /* A non-template inline function with external linkage will
3903 always be COMDAT. As we must eventually determine the
3904 linkage of all functions, and as that causes writes to
3905 the data mapped in from the PCH file, it's advantageous
3906 to mark the functions at this point. */
3907 if (!DECL_IMPLICIT_INSTANTIATION (fn))
3909 /* This function must have external linkage, as
3910 otherwise DECL_INTERFACE_KNOWN would have been
3912 gcc_assert (TREE_PUBLIC (fn));
3913 comdat_linkage (fn);
3914 DECL_INTERFACE_KNOWN (fn) = 1;
3918 import_export_decl (fn);
3920 /* If the user wants us to keep all inline functions, then mark
3921 this function as needed so that finish_file will make sure to
3922 output it later. Similarly, all dllexport'd functions must
3923 be emitted; there may be callers in other DLLs. */
3924 if ((flag_keep_inline_functions
3925 && DECL_DECLARED_INLINE_P (fn)
3926 && !DECL_REALLY_EXTERN (fn))
3927 || (flag_keep_inline_dllexport
3928 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (fn))))
3931 DECL_EXTERNAL (fn) = 0;
3935 /* There's no reason to do any of the work here if we're only doing
3936 semantic analysis; this code just generates RTL. */
3937 if (flag_syntax_only)
3944 expand_or_defer_fn (tree fn)
3946 if (expand_or_defer_fn_1 (fn))
3950 /* Expand or defer, at the whim of the compilation unit manager. */
3951 cgraph_finalize_function (fn, function_depth > 1);
3952 emit_associated_thunks (fn);
3962 hash_table <pointer_hash <tree_node> > visited;
3965 /* Helper function for walk_tree, used by finalize_nrv below. */
3968 finalize_nrv_r (tree* tp, int* walk_subtrees, void* data)
3970 struct nrv_data *dp = (struct nrv_data *)data;
3973 /* No need to walk into types. There wouldn't be any need to walk into
3974 non-statements, except that we have to consider STMT_EXPRs. */
3977 /* Change all returns to just refer to the RESULT_DECL; this is a nop,
3978 but differs from using NULL_TREE in that it indicates that we care
3979 about the value of the RESULT_DECL. */
3980 else if (TREE_CODE (*tp) == RETURN_EXPR)
3981 TREE_OPERAND (*tp, 0) = dp->result;
3982 /* Change all cleanups for the NRV to only run when an exception is
3984 else if (TREE_CODE (*tp) == CLEANUP_STMT
3985 && CLEANUP_DECL (*tp) == dp->var)
3986 CLEANUP_EH_ONLY (*tp) = 1;
3987 /* Replace the DECL_EXPR for the NRV with an initialization of the
3988 RESULT_DECL, if needed. */
3989 else if (TREE_CODE (*tp) == DECL_EXPR
3990 && DECL_EXPR_DECL (*tp) == dp->var)
3993 if (DECL_INITIAL (dp->var)
3994 && DECL_INITIAL (dp->var) != error_mark_node)
3995 init = build2 (INIT_EXPR, void_type_node, dp->result,
3996 DECL_INITIAL (dp->var));
3998 init = build_empty_stmt (EXPR_LOCATION (*tp));
3999 DECL_INITIAL (dp->var) = NULL_TREE;
4000 SET_EXPR_LOCATION (init, EXPR_LOCATION (*tp));
4003 /* And replace all uses of the NRV with the RESULT_DECL. */
4004 else if (*tp == dp->var)
4007 /* Avoid walking into the same tree more than once. Unfortunately, we
4008 can't just use walk_tree_without duplicates because it would only call
4009 us for the first occurrence of dp->var in the function body. */
4010 slot = dp->visited.find_slot (*tp, INSERT);
4016 /* Keep iterating. */
4020 /* Called from finish_function to implement the named return value
4021 optimization by overriding all the RETURN_EXPRs and pertinent
4022 CLEANUP_STMTs and replacing all occurrences of VAR with RESULT, the
4023 RESULT_DECL for the function. */
4026 finalize_nrv (tree *tp, tree var, tree result)
4028 struct nrv_data data;
4030 /* Copy name from VAR to RESULT. */
4031 DECL_NAME (result) = DECL_NAME (var);
4032 /* Don't forget that we take its address. */
4033 TREE_ADDRESSABLE (result) = TREE_ADDRESSABLE (var);
4034 /* Finally set DECL_VALUE_EXPR to avoid assigning
4035 a stack slot at -O0 for the original var and debug info
4036 uses RESULT location for VAR. */
4037 SET_DECL_VALUE_EXPR (var, result);
4038 DECL_HAS_VALUE_EXPR_P (var) = 1;
4041 data.result = result;
4042 data.visited.create (37);
4043 cp_walk_tree (tp, finalize_nrv_r, &data, 0);
4044 data.visited.dispose ();
4047 /* Create CP_OMP_CLAUSE_INFO for clause C. Returns true if it is invalid. */
4050 cxx_omp_create_clause_info (tree c, tree type, bool need_default_ctor,
4051 bool need_copy_ctor, bool need_copy_assignment)
4053 int save_errorcount = errorcount;
4056 /* Always allocate 3 elements for simplicity. These are the
4057 function decls for the ctor, dtor, and assignment op.
4058 This layout is known to the three lang hooks,
4059 cxx_omp_clause_default_init, cxx_omp_clause_copy_init,
4060 and cxx_omp_clause_assign_op. */
4061 info = make_tree_vec (3);
4062 CP_OMP_CLAUSE_INFO (c) = info;
4064 if (need_default_ctor || need_copy_ctor)
4066 if (need_default_ctor)
4067 t = get_default_ctor (type);
4069 t = get_copy_ctor (type, tf_warning_or_error);
4071 if (t && !trivial_fn_p (t))
4072 TREE_VEC_ELT (info, 0) = t;
4075 if ((need_default_ctor || need_copy_ctor)
4076 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
4077 TREE_VEC_ELT (info, 1) = get_dtor (type, tf_warning_or_error);
4079 if (need_copy_assignment)
4081 t = get_copy_assign (type);
4083 if (t && !trivial_fn_p (t))
4084 TREE_VEC_ELT (info, 2) = t;
4087 return errorcount != save_errorcount;
4090 /* For all elements of CLAUSES, validate them vs OpenMP constraints.
4091 Remove any elements from the list that are invalid. */
4094 finish_omp_clauses (tree clauses)
4096 bitmap_head generic_head, firstprivate_head, lastprivate_head;
4097 tree c, t, *pc = &clauses;
4100 bitmap_obstack_initialize (NULL);
4101 bitmap_initialize (&generic_head, &bitmap_default_obstack);
4102 bitmap_initialize (&firstprivate_head, &bitmap_default_obstack);
4103 bitmap_initialize (&lastprivate_head, &bitmap_default_obstack);
4105 for (pc = &clauses, c = clauses; c ; c = *pc)
4107 bool remove = false;
4109 switch (OMP_CLAUSE_CODE (c))
4111 case OMP_CLAUSE_SHARED:
4113 goto check_dup_generic;
4114 case OMP_CLAUSE_PRIVATE:
4116 goto check_dup_generic;
4117 case OMP_CLAUSE_REDUCTION:
4119 goto check_dup_generic;
4120 case OMP_CLAUSE_COPYPRIVATE:
4121 name = "copyprivate";
4122 goto check_dup_generic;
4123 case OMP_CLAUSE_COPYIN:
4125 goto check_dup_generic;
4127 t = OMP_CLAUSE_DECL (c);
4128 if (!VAR_P (t) && TREE_CODE (t) != PARM_DECL)
4130 if (processing_template_decl)
4133 error ("%qD is not a variable in clause %qs", t, name);
4135 error ("%qE is not a variable in clause %qs", t, name);
4138 else if (bitmap_bit_p (&generic_head, DECL_UID (t))
4139 || bitmap_bit_p (&firstprivate_head, DECL_UID (t))
4140 || bitmap_bit_p (&lastprivate_head, DECL_UID (t)))
4142 error ("%qD appears more than once in data clauses", t);
4146 bitmap_set_bit (&generic_head, DECL_UID (t));
4149 case OMP_CLAUSE_FIRSTPRIVATE:
4150 t = OMP_CLAUSE_DECL (c);
4151 if (!VAR_P (t) && TREE_CODE (t) != PARM_DECL)
4153 if (processing_template_decl)
4156 error ("%qD is not a variable in clause %<firstprivate%>", t);
4158 error ("%qE is not a variable in clause %<firstprivate%>", t);
4161 else if (bitmap_bit_p (&generic_head, DECL_UID (t))
4162 || bitmap_bit_p (&firstprivate_head, DECL_UID (t)))
4164 error ("%qD appears more than once in data clauses", t);
4168 bitmap_set_bit (&firstprivate_head, DECL_UID (t));
4171 case OMP_CLAUSE_LASTPRIVATE:
4172 t = OMP_CLAUSE_DECL (c);
4173 if (!VAR_P (t) && TREE_CODE (t) != PARM_DECL)
4175 if (processing_template_decl)
4178 error ("%qD is not a variable in clause %<lastprivate%>", t);
4180 error ("%qE is not a variable in clause %<lastprivate%>", t);
4183 else if (bitmap_bit_p (&generic_head, DECL_UID (t))
4184 || bitmap_bit_p (&lastprivate_head, DECL_UID (t)))
4186 error ("%qD appears more than once in data clauses", t);
4190 bitmap_set_bit (&lastprivate_head, DECL_UID (t));
4194 t = OMP_CLAUSE_IF_EXPR (c);
4195 t = maybe_convert_cond (t);
4196 if (t == error_mark_node)
4198 else if (!processing_template_decl)
4199 t = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
4200 OMP_CLAUSE_IF_EXPR (c) = t;
4203 case OMP_CLAUSE_FINAL:
4204 t = OMP_CLAUSE_FINAL_EXPR (c);
4205 t = maybe_convert_cond (t);
4206 if (t == error_mark_node)
4208 else if (!processing_template_decl)
4209 t = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
4210 OMP_CLAUSE_FINAL_EXPR (c) = t;
4213 case OMP_CLAUSE_NUM_THREADS:
4214 t = OMP_CLAUSE_NUM_THREADS_EXPR (c);
4215 if (t == error_mark_node)
4217 else if (!type_dependent_expression_p (t)
4218 && !INTEGRAL_TYPE_P (TREE_TYPE (t)))
4220 error ("num_threads expression must be integral");
4225 t = mark_rvalue_use (t);
4226 if (!processing_template_decl)
4227 t = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
4228 OMP_CLAUSE_NUM_THREADS_EXPR (c) = t;
4232 case OMP_CLAUSE_SCHEDULE:
4233 t = OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c);
4236 else if (t == error_mark_node)
4238 else if (!type_dependent_expression_p (t)
4239 && !INTEGRAL_TYPE_P (TREE_TYPE (t)))
4241 error ("schedule chunk size expression must be integral");
4246 t = mark_rvalue_use (t);
4247 if (!processing_template_decl)
4248 t = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
4249 OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c) = t;
4253 case OMP_CLAUSE_NOWAIT:
4254 case OMP_CLAUSE_ORDERED:
4255 case OMP_CLAUSE_DEFAULT:
4256 case OMP_CLAUSE_UNTIED:
4257 case OMP_CLAUSE_COLLAPSE:
4258 case OMP_CLAUSE_MERGEABLE:
4266 *pc = OMP_CLAUSE_CHAIN (c);
4268 pc = &OMP_CLAUSE_CHAIN (c);
4271 for (pc = &clauses, c = clauses; c ; c = *pc)
4273 enum omp_clause_code c_kind = OMP_CLAUSE_CODE (c);
4274 bool remove = false;
4275 bool need_complete_non_reference = false;
4276 bool need_default_ctor = false;
4277 bool need_copy_ctor = false;
4278 bool need_copy_assignment = false;
4279 bool need_implicitly_determined = false;
4280 tree type, inner_type;
4284 case OMP_CLAUSE_SHARED:
4286 need_implicitly_determined = true;
4288 case OMP_CLAUSE_PRIVATE:
4290 need_complete_non_reference = true;
4291 need_default_ctor = true;
4292 need_implicitly_determined = true;
4294 case OMP_CLAUSE_FIRSTPRIVATE:
4295 name = "firstprivate";
4296 need_complete_non_reference = true;
4297 need_copy_ctor = true;
4298 need_implicitly_determined = true;
4300 case OMP_CLAUSE_LASTPRIVATE:
4301 name = "lastprivate";
4302 need_complete_non_reference = true;
4303 need_copy_assignment = true;
4304 need_implicitly_determined = true;
4306 case OMP_CLAUSE_REDUCTION:
4308 need_implicitly_determined = true;
4310 case OMP_CLAUSE_COPYPRIVATE:
4311 name = "copyprivate";
4312 need_copy_assignment = true;
4314 case OMP_CLAUSE_COPYIN:
4316 need_copy_assignment = true;
4319 pc = &OMP_CLAUSE_CHAIN (c);
4323 t = OMP_CLAUSE_DECL (c);
4324 if (processing_template_decl
4325 && !VAR_P (t) && TREE_CODE (t) != PARM_DECL)
4327 pc = &OMP_CLAUSE_CHAIN (c);
4333 case OMP_CLAUSE_LASTPRIVATE:
4334 if (!bitmap_bit_p (&firstprivate_head, DECL_UID (t)))
4335 need_default_ctor = true;
4338 case OMP_CLAUSE_REDUCTION:
4339 if (AGGREGATE_TYPE_P (TREE_TYPE (t))
4340 || POINTER_TYPE_P (TREE_TYPE (t)))
4342 error ("%qE has invalid type for %<reduction%>", t);
4345 else if (FLOAT_TYPE_P (TREE_TYPE (t)))
4347 enum tree_code r_code = OMP_CLAUSE_REDUCTION_CODE (c);
4357 error ("%qE has invalid type for %<reduction(%s)%>",
4358 t, operator_name_info[r_code].name);
4364 case OMP_CLAUSE_COPYIN:
4365 if (!VAR_P (t) || !DECL_THREAD_LOCAL_P (t))
4367 error ("%qE must be %<threadprivate%> for %<copyin%>", t);
4376 if (need_complete_non_reference || need_copy_assignment)
4378 t = require_complete_type (t);
4379 if (t == error_mark_node)
4381 else if (TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE
4382 && need_complete_non_reference)
4384 error ("%qE has reference type for %qs", t, name);
4388 if (need_implicitly_determined)
4390 const char *share_name = NULL;
4392 if (VAR_P (t) && DECL_THREAD_LOCAL_P (t))
4393 share_name = "threadprivate";
4394 else switch (cxx_omp_predetermined_sharing (t))
4396 case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
4398 case OMP_CLAUSE_DEFAULT_SHARED:
4399 /* const vars may be specified in firstprivate clause. */
4400 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_FIRSTPRIVATE
4401 && cxx_omp_const_qual_no_mutable (t))
4403 share_name = "shared";
4405 case OMP_CLAUSE_DEFAULT_PRIVATE:
4406 share_name = "private";
4413 error ("%qE is predetermined %qs for %qs",
4414 t, share_name, name);
4419 /* We're interested in the base element, not arrays. */
4420 inner_type = type = TREE_TYPE (t);
4421 while (TREE_CODE (inner_type) == ARRAY_TYPE)
4422 inner_type = TREE_TYPE (inner_type);
4424 /* Check for special function availability by building a call to one.
4425 Save the results, because later we won't be in the right context
4426 for making these queries. */
4427 if (CLASS_TYPE_P (inner_type)
4428 && COMPLETE_TYPE_P (inner_type)
4429 && (need_default_ctor || need_copy_ctor || need_copy_assignment)
4430 && !type_dependent_expression_p (t)
4431 && cxx_omp_create_clause_info (c, inner_type, need_default_ctor,
4432 need_copy_ctor, need_copy_assignment))
4436 *pc = OMP_CLAUSE_CHAIN (c);
4438 pc = &OMP_CLAUSE_CHAIN (c);
4441 bitmap_obstack_release (NULL);
4445 /* For all variables in the tree_list VARS, mark them as thread local. */
4448 finish_omp_threadprivate (tree vars)
4452 /* Mark every variable in VARS to be assigned thread local storage. */
4453 for (t = vars; t; t = TREE_CHAIN (t))
4455 tree v = TREE_PURPOSE (t);
4457 if (error_operand_p (v))
4459 else if (!VAR_P (v))
4460 error ("%<threadprivate%> %qD is not file, namespace "
4461 "or block scope variable", v);
4462 /* If V had already been marked threadprivate, it doesn't matter
4463 whether it had been used prior to this point. */
4464 else if (TREE_USED (v)
4465 && (DECL_LANG_SPECIFIC (v) == NULL
4466 || !CP_DECL_THREADPRIVATE_P (v)))
4467 error ("%qE declared %<threadprivate%> after first use", v);
4468 else if (! TREE_STATIC (v) && ! DECL_EXTERNAL (v))
4469 error ("automatic variable %qE cannot be %<threadprivate%>", v);
4470 else if (! COMPLETE_TYPE_P (complete_type (TREE_TYPE (v))))
4471 error ("%<threadprivate%> %qE has incomplete type", v);
4472 else if (TREE_STATIC (v) && TYPE_P (CP_DECL_CONTEXT (v))
4473 && CP_DECL_CONTEXT (v) != current_class_type)
4474 error ("%<threadprivate%> %qE directive not "
4475 "in %qT definition", v, CP_DECL_CONTEXT (v));
4478 /* Allocate a LANG_SPECIFIC structure for V, if needed. */
4479 if (DECL_LANG_SPECIFIC (v) == NULL)
4481 retrofit_lang_decl (v);
4483 /* Make sure that DECL_DISCRIMINATOR_P continues to be true
4484 after the allocation of the lang_decl structure. */
4485 if (DECL_DISCRIMINATOR_P (v))
4486 DECL_LANG_SPECIFIC (v)->u.base.u2sel = 1;
4489 if (! DECL_THREAD_LOCAL_P (v))
4491 DECL_TLS_MODEL (v) = decl_default_tls_model (v);
4492 /* If rtl has been already set for this var, call
4493 make_decl_rtl once again, so that encode_section_info
4494 has a chance to look at the new decl flags. */
4495 if (DECL_RTL_SET_P (v))
4498 CP_DECL_THREADPRIVATE_P (v) = 1;
4503 /* Build an OpenMP structured block. */
4506 begin_omp_structured_block (void)
4508 return do_pushlevel (sk_omp);
4512 finish_omp_structured_block (tree block)
4514 return do_poplevel (block);
4517 /* Similarly, except force the retention of the BLOCK. */
4520 begin_omp_parallel (void)
4522 keep_next_level (true);
4523 return begin_omp_structured_block ();
4527 finish_omp_parallel (tree clauses, tree body)
4531 body = finish_omp_structured_block (body);
4533 stmt = make_node (OMP_PARALLEL);
4534 TREE_TYPE (stmt) = void_type_node;
4535 OMP_PARALLEL_CLAUSES (stmt) = clauses;
4536 OMP_PARALLEL_BODY (stmt) = body;
4538 return add_stmt (stmt);
4542 begin_omp_task (void)
4544 keep_next_level (true);
4545 return begin_omp_structured_block ();
4549 finish_omp_task (tree clauses, tree body)
4553 body = finish_omp_structured_block (body);
4555 stmt = make_node (OMP_TASK);
4556 TREE_TYPE (stmt) = void_type_node;
4557 OMP_TASK_CLAUSES (stmt) = clauses;
4558 OMP_TASK_BODY (stmt) = body;
4560 return add_stmt (stmt);
4563 /* Helper function for finish_omp_for. Convert Ith random access iterator
4564 into integral iterator. Return FALSE if successful. */
4567 handle_omp_for_class_iterator (int i, location_t locus, tree declv, tree initv,
4568 tree condv, tree incrv, tree *body,
4569 tree *pre_body, tree clauses)
4571 tree diff, iter_init, iter_incr = NULL, last;
4572 tree incr_var = NULL, orig_pre_body, orig_body, c;
4573 tree decl = TREE_VEC_ELT (declv, i);
4574 tree init = TREE_VEC_ELT (initv, i);
4575 tree cond = TREE_VEC_ELT (condv, i);
4576 tree incr = TREE_VEC_ELT (incrv, i);
4578 location_t elocus = locus;
4580 if (init && EXPR_HAS_LOCATION (init))
4581 elocus = EXPR_LOCATION (init);
4583 switch (TREE_CODE (cond))
4589 if (TREE_OPERAND (cond, 1) == iter)
4590 cond = build2 (swap_tree_comparison (TREE_CODE (cond)),
4591 TREE_TYPE (cond), iter, TREE_OPERAND (cond, 0));
4592 if (TREE_OPERAND (cond, 0) != iter)
4593 cond = error_mark_node;
4596 tree tem = build_x_binary_op (EXPR_LOCATION (cond),
4599 TREE_OPERAND (cond, 1), ERROR_MARK,
4600 NULL, tf_warning_or_error);
4601 if (error_operand_p (tem))
4606 cond = error_mark_node;
4609 if (cond == error_mark_node)
4611 error_at (elocus, "invalid controlling predicate");
4614 diff = build_x_binary_op (elocus, MINUS_EXPR, TREE_OPERAND (cond, 1),
4615 ERROR_MARK, iter, ERROR_MARK, NULL,
4616 tf_warning_or_error);
4617 if (error_operand_p (diff))
4619 if (TREE_CODE (TREE_TYPE (diff)) != INTEGER_TYPE)
4621 error_at (elocus, "difference between %qE and %qD does not have integer type",
4622 TREE_OPERAND (cond, 1), iter);
4626 switch (TREE_CODE (incr))
4628 case PREINCREMENT_EXPR:
4629 case PREDECREMENT_EXPR:
4630 case POSTINCREMENT_EXPR:
4631 case POSTDECREMENT_EXPR:
4632 if (TREE_OPERAND (incr, 0) != iter)
4634 incr = error_mark_node;
4637 iter_incr = build_x_unary_op (EXPR_LOCATION (incr),
4638 TREE_CODE (incr), iter,
4639 tf_warning_or_error);
4640 if (error_operand_p (iter_incr))
4642 else if (TREE_CODE (incr) == PREINCREMENT_EXPR
4643 || TREE_CODE (incr) == POSTINCREMENT_EXPR)
4644 incr = integer_one_node;
4646 incr = integer_minus_one_node;
4649 if (TREE_OPERAND (incr, 0) != iter)
4650 incr = error_mark_node;
4651 else if (TREE_CODE (TREE_OPERAND (incr, 1)) == PLUS_EXPR
4652 || TREE_CODE (TREE_OPERAND (incr, 1)) == MINUS_EXPR)
4654 tree rhs = TREE_OPERAND (incr, 1);
4655 if (TREE_OPERAND (rhs, 0) == iter)
4657 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs, 1)))
4659 incr = error_mark_node;
4662 iter_incr = build_x_modify_expr (EXPR_LOCATION (rhs),
4663 iter, TREE_CODE (rhs),
4664 TREE_OPERAND (rhs, 1),
4665 tf_warning_or_error);
4666 if (error_operand_p (iter_incr))
4668 incr = TREE_OPERAND (rhs, 1);
4669 incr = cp_convert (TREE_TYPE (diff), incr,
4670 tf_warning_or_error);
4671 if (TREE_CODE (rhs) == MINUS_EXPR)
4673 incr = build1 (NEGATE_EXPR, TREE_TYPE (diff), incr);
4674 incr = fold_if_not_in_template (incr);
4676 if (TREE_CODE (incr) != INTEGER_CST
4677 && (TREE_CODE (incr) != NOP_EXPR
4678 || (TREE_CODE (TREE_OPERAND (incr, 0))
4683 else if (TREE_OPERAND (rhs, 1) == iter)
4685 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs, 0))) != INTEGER_TYPE
4686 || TREE_CODE (rhs) != PLUS_EXPR)
4687 incr = error_mark_node;
4690 iter_incr = build_x_binary_op (EXPR_LOCATION (rhs),
4692 TREE_OPERAND (rhs, 0),
4695 tf_warning_or_error);
4696 if (error_operand_p (iter_incr))
4698 iter_incr = build_x_modify_expr (EXPR_LOCATION (rhs),
4701 tf_warning_or_error);
4702 if (error_operand_p (iter_incr))
4704 incr = TREE_OPERAND (rhs, 0);
4709 incr = error_mark_node;
4712 incr = error_mark_node;
4715 incr = error_mark_node;
4719 if (incr == error_mark_node)
4721 error_at (elocus, "invalid increment expression");
4725 incr = cp_convert (TREE_TYPE (diff), incr, tf_warning_or_error);
4726 for (c = clauses; c ; c = OMP_CLAUSE_CHAIN (c))
4727 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LASTPRIVATE
4728 && OMP_CLAUSE_DECL (c) == iter)
4731 decl = create_temporary_var (TREE_TYPE (diff));
4733 add_decl_expr (decl);
4734 last = create_temporary_var (TREE_TYPE (diff));
4736 add_decl_expr (last);
4737 if (c && iter_incr == NULL)
4739 incr_var = create_temporary_var (TREE_TYPE (diff));
4740 pushdecl (incr_var);
4741 add_decl_expr (incr_var);
4743 gcc_assert (stmts_are_full_exprs_p ());
4745 orig_pre_body = *pre_body;
4746 *pre_body = push_stmt_list ();
4748 add_stmt (orig_pre_body);
4750 finish_expr_stmt (build_x_modify_expr (elocus,
4751 iter, NOP_EXPR, init,
4752 tf_warning_or_error));
4753 init = build_int_cst (TREE_TYPE (diff), 0);
4754 if (c && iter_incr == NULL)
4756 finish_expr_stmt (build_x_modify_expr (elocus,
4758 incr, tf_warning_or_error));
4760 iter_incr = build_x_modify_expr (elocus,
4761 iter, PLUS_EXPR, incr,
4762 tf_warning_or_error);
4764 finish_expr_stmt (build_x_modify_expr (elocus,
4765 last, NOP_EXPR, init,
4766 tf_warning_or_error));
4767 *pre_body = pop_stmt_list (*pre_body);
4769 cond = cp_build_binary_op (elocus,
4770 TREE_CODE (cond), decl, diff,
4771 tf_warning_or_error);
4772 incr = build_modify_expr (elocus, decl, NULL_TREE, PLUS_EXPR,
4773 elocus, incr, NULL_TREE);
4776 *body = push_stmt_list ();
4777 iter_init = build2 (MINUS_EXPR, TREE_TYPE (diff), decl, last);
4778 iter_init = build_x_modify_expr (elocus,
4779 iter, PLUS_EXPR, iter_init,
4780 tf_warning_or_error);
4781 iter_init = build1 (NOP_EXPR, void_type_node, iter_init);
4782 finish_expr_stmt (iter_init);
4783 finish_expr_stmt (build_x_modify_expr (elocus,
4784 last, NOP_EXPR, decl,
4785 tf_warning_or_error));
4786 add_stmt (orig_body);
4787 *body = pop_stmt_list (*body);
4791 OMP_CLAUSE_LASTPRIVATE_STMT (c) = push_stmt_list ();
4792 finish_expr_stmt (iter_incr);
4793 OMP_CLAUSE_LASTPRIVATE_STMT (c)
4794 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (c));
4797 TREE_VEC_ELT (declv, i) = decl;
4798 TREE_VEC_ELT (initv, i) = init;
4799 TREE_VEC_ELT (condv, i) = cond;
4800 TREE_VEC_ELT (incrv, i) = incr;
4805 /* Build and validate an OMP_FOR statement. CLAUSES, BODY, COND, INCR
4806 are directly for their associated operands in the statement. DECL
4807 and INIT are a combo; if DECL is NULL then INIT ought to be a
4808 MODIFY_EXPR, and the DECL should be extracted. PRE_BODY are
4809 optional statements that need to go before the loop into its
4813 finish_omp_for (location_t locus, tree declv, tree initv, tree condv,
4814 tree incrv, tree body, tree pre_body, tree clauses)
4816 tree omp_for = NULL, orig_incr = NULL;
4817 tree decl, init, cond, incr;
4821 gcc_assert (TREE_VEC_LENGTH (declv) == TREE_VEC_LENGTH (initv));
4822 gcc_assert (TREE_VEC_LENGTH (declv) == TREE_VEC_LENGTH (condv));
4823 gcc_assert (TREE_VEC_LENGTH (declv) == TREE_VEC_LENGTH (incrv));
4824 for (i = 0; i < TREE_VEC_LENGTH (declv); i++)
4826 decl = TREE_VEC_ELT (declv, i);
4827 init = TREE_VEC_ELT (initv, i);
4828 cond = TREE_VEC_ELT (condv, i);
4829 incr = TREE_VEC_ELT (incrv, i);
4835 switch (TREE_CODE (init))
4838 decl = TREE_OPERAND (init, 0);
4839 init = TREE_OPERAND (init, 1);
4842 if (TREE_CODE (TREE_OPERAND (init, 1)) == NOP_EXPR)
4844 decl = TREE_OPERAND (init, 0);
4845 init = TREE_OPERAND (init, 2);
4855 "expected iteration declaration or initialization");
4860 if (init && EXPR_HAS_LOCATION (init))
4861 elocus = EXPR_LOCATION (init);
4865 error_at (elocus, "missing controlling predicate");
4871 error_at (elocus, "missing increment expression");
4875 TREE_VEC_ELT (declv, i) = decl;
4876 TREE_VEC_ELT (initv, i) = init;
4879 if (dependent_omp_for_p (declv, initv, condv, incrv))
4883 stmt = make_node (OMP_FOR);
4885 for (i = 0; i < TREE_VEC_LENGTH (declv); i++)
4887 /* This is really just a place-holder. We'll be decomposing this
4888 again and going through the cp_build_modify_expr path below when
4889 we instantiate the thing. */
4890 TREE_VEC_ELT (initv, i)
4891 = build2 (MODIFY_EXPR, void_type_node, TREE_VEC_ELT (declv, i),
4892 TREE_VEC_ELT (initv, i));
4895 TREE_TYPE (stmt) = void_type_node;
4896 OMP_FOR_INIT (stmt) = initv;
4897 OMP_FOR_COND (stmt) = condv;
4898 OMP_FOR_INCR (stmt) = incrv;
4899 OMP_FOR_BODY (stmt) = body;
4900 OMP_FOR_PRE_BODY (stmt) = pre_body;
4901 OMP_FOR_CLAUSES (stmt) = clauses;
4903 SET_EXPR_LOCATION (stmt, locus);
4904 return add_stmt (stmt);
4907 if (processing_template_decl)
4908 orig_incr = make_tree_vec (TREE_VEC_LENGTH (incrv));
4910 for (i = 0; i < TREE_VEC_LENGTH (declv); )
4912 decl = TREE_VEC_ELT (declv, i);
4913 init = TREE_VEC_ELT (initv, i);
4914 cond = TREE_VEC_ELT (condv, i);
4915 incr = TREE_VEC_ELT (incrv, i);
4917 TREE_VEC_ELT (orig_incr, i) = incr;
4920 if (init && EXPR_HAS_LOCATION (init))
4921 elocus = EXPR_LOCATION (init);
4925 error_at (elocus, "expected iteration declaration or initialization");
4929 if (incr && TREE_CODE (incr) == MODOP_EXPR)
4932 TREE_VEC_ELT (orig_incr, i) = incr;
4933 incr = cp_build_modify_expr (TREE_OPERAND (incr, 0),
4934 TREE_CODE (TREE_OPERAND (incr, 1)),
4935 TREE_OPERAND (incr, 2),
4936 tf_warning_or_error);
4939 if (CLASS_TYPE_P (TREE_TYPE (decl)))
4941 if (handle_omp_for_class_iterator (i, locus, declv, initv, condv,
4942 incrv, &body, &pre_body, clauses))
4947 if (!INTEGRAL_TYPE_P (TREE_TYPE (decl))
4948 && !TYPE_PTR_P (TREE_TYPE (decl)))
4950 error_at (elocus, "invalid type for iteration variable %qE", decl);
4954 if (!processing_template_decl)
4956 init = fold_build_cleanup_point_expr (TREE_TYPE (init), init);
4957 init = cp_build_modify_expr (decl, NOP_EXPR, init, tf_warning_or_error);
4960 init = build2 (MODIFY_EXPR, void_type_node, decl, init);
4962 && TREE_SIDE_EFFECTS (cond)
4963 && COMPARISON_CLASS_P (cond)
4964 && !processing_template_decl)
4966 tree t = TREE_OPERAND (cond, 0);
4967 if (TREE_SIDE_EFFECTS (t)
4969 && (TREE_CODE (t) != NOP_EXPR
4970 || TREE_OPERAND (t, 0) != decl))
4971 TREE_OPERAND (cond, 0)
4972 = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
4974 t = TREE_OPERAND (cond, 1);
4975 if (TREE_SIDE_EFFECTS (t)
4977 && (TREE_CODE (t) != NOP_EXPR
4978 || TREE_OPERAND (t, 0) != decl))
4979 TREE_OPERAND (cond, 1)
4980 = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
4982 if (decl == error_mark_node || init == error_mark_node)
4985 TREE_VEC_ELT (declv, i) = decl;
4986 TREE_VEC_ELT (initv, i) = init;
4987 TREE_VEC_ELT (condv, i) = cond;
4988 TREE_VEC_ELT (incrv, i) = incr;
4992 if (IS_EMPTY_STMT (pre_body))
4995 omp_for = c_finish_omp_for (locus, declv, initv, condv, incrv,
4998 if (omp_for == NULL)
5001 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INCR (omp_for)); i++)
5003 decl = TREE_OPERAND (TREE_VEC_ELT (OMP_FOR_INIT (omp_for), i), 0);
5004 incr = TREE_VEC_ELT (OMP_FOR_INCR (omp_for), i);
5006 if (TREE_CODE (incr) != MODIFY_EXPR)
5009 if (TREE_SIDE_EFFECTS (TREE_OPERAND (incr, 1))
5010 && BINARY_CLASS_P (TREE_OPERAND (incr, 1))
5011 && !processing_template_decl)
5013 tree t = TREE_OPERAND (TREE_OPERAND (incr, 1), 0);
5014 if (TREE_SIDE_EFFECTS (t)
5016 && (TREE_CODE (t) != NOP_EXPR
5017 || TREE_OPERAND (t, 0) != decl))
5018 TREE_OPERAND (TREE_OPERAND (incr, 1), 0)
5019 = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
5021 t = TREE_OPERAND (TREE_OPERAND (incr, 1), 1);
5022 if (TREE_SIDE_EFFECTS (t)
5024 && (TREE_CODE (t) != NOP_EXPR
5025 || TREE_OPERAND (t, 0) != decl))
5026 TREE_OPERAND (TREE_OPERAND (incr, 1), 1)
5027 = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
5031 TREE_VEC_ELT (OMP_FOR_INCR (omp_for), i) = TREE_VEC_ELT (orig_incr, i);
5033 if (omp_for != NULL)
5034 OMP_FOR_CLAUSES (omp_for) = clauses;
5039 finish_omp_atomic (enum tree_code code, enum tree_code opcode, tree lhs,
5040 tree rhs, tree v, tree lhs1, tree rhs1)
5055 dependent_p = false;
5058 /* Even in a template, we can detect invalid uses of the atomic
5059 pragma if neither LHS nor RHS is type-dependent. */
5060 if (processing_template_decl)
5062 dependent_p = (type_dependent_expression_p (lhs)
5063 || (rhs && type_dependent_expression_p (rhs))
5064 || (v && type_dependent_expression_p (v))
5065 || (lhs1 && type_dependent_expression_p (lhs1))
5066 || (rhs1 && type_dependent_expression_p (rhs1)));
5069 lhs = build_non_dependent_expr (lhs);
5071 rhs = build_non_dependent_expr (rhs);
5073 v = build_non_dependent_expr (v);
5075 lhs1 = build_non_dependent_expr (lhs1);
5077 rhs1 = build_non_dependent_expr (rhs1);
5082 stmt = c_finish_omp_atomic (input_location, code, opcode, lhs, rhs,
5084 if (stmt == error_mark_node)
5087 if (processing_template_decl)
5089 if (code == OMP_ATOMIC_READ)
5091 stmt = build_min_nt_loc (EXPR_LOCATION (orig_lhs),
5092 OMP_ATOMIC_READ, orig_lhs);
5093 stmt = build2 (MODIFY_EXPR, void_type_node, orig_v, stmt);
5097 if (opcode == NOP_EXPR)
5098 stmt = build2 (MODIFY_EXPR, void_type_node, orig_lhs, orig_rhs);
5100 stmt = build2 (opcode, void_type_node, orig_lhs, orig_rhs);
5102 stmt = build_min_nt_loc (EXPR_LOCATION (orig_rhs1),
5103 COMPOUND_EXPR, orig_rhs1, stmt);
5104 if (code != OMP_ATOMIC)
5106 stmt = build_min_nt_loc (EXPR_LOCATION (orig_lhs1),
5107 code, orig_lhs1, stmt);
5108 stmt = build2 (MODIFY_EXPR, void_type_node, orig_v, stmt);
5111 stmt = build2 (OMP_ATOMIC, void_type_node, integer_zero_node, stmt);
5117 finish_omp_barrier (void)
5119 tree fn = builtin_decl_explicit (BUILT_IN_GOMP_BARRIER);
5120 vec<tree, va_gc> *vec = make_tree_vector ();
5121 tree stmt = finish_call_expr (fn, &vec, false, false, tf_warning_or_error);
5122 release_tree_vector (vec);
5123 finish_expr_stmt (stmt);
5127 finish_omp_flush (void)
5129 tree fn = builtin_decl_explicit (BUILT_IN_SYNC_SYNCHRONIZE);
5130 vec<tree, va_gc> *vec = make_tree_vector ();
5131 tree stmt = finish_call_expr (fn, &vec, false, false, tf_warning_or_error);
5132 release_tree_vector (vec);
5133 finish_expr_stmt (stmt);
5137 finish_omp_taskwait (void)
5139 tree fn = builtin_decl_explicit (BUILT_IN_GOMP_TASKWAIT);
5140 vec<tree, va_gc> *vec = make_tree_vector ();
5141 tree stmt = finish_call_expr (fn, &vec, false, false, tf_warning_or_error);
5142 release_tree_vector (vec);
5143 finish_expr_stmt (stmt);
5147 finish_omp_taskyield (void)
5149 tree fn = builtin_decl_explicit (BUILT_IN_GOMP_TASKYIELD);
5150 vec<tree, va_gc> *vec = make_tree_vector ();
5151 tree stmt = finish_call_expr (fn, &vec, false, false, tf_warning_or_error);
5152 release_tree_vector (vec);
5153 finish_expr_stmt (stmt);
5156 /* Begin a __transaction_atomic or __transaction_relaxed statement.
5157 If PCOMPOUND is non-null, this is for a function-transaction-block, and we
5158 should create an extra compound stmt. */
5161 begin_transaction_stmt (location_t loc, tree *pcompound, int flags)
5166 *pcompound = begin_compound_stmt (0);
5168 r = build_stmt (loc, TRANSACTION_EXPR, NULL_TREE);
5170 /* Only add the statement to the function if support enabled. */
5174 error_at (loc, ((flags & TM_STMT_ATTR_RELAXED) != 0
5175 ? G_("%<__transaction_relaxed%> without "
5176 "transactional memory support enabled")
5177 : G_("%<__transaction_atomic%> without "
5178 "transactional memory support enabled")));
5180 TRANSACTION_EXPR_BODY (r) = push_stmt_list ();
5181 TREE_SIDE_EFFECTS (r) = 1;
5185 /* End a __transaction_atomic or __transaction_relaxed statement.
5186 If COMPOUND_STMT is non-null, this is for a function-transaction-block,
5187 and we should end the compound. If NOEX is non-NULL, we wrap the body in
5188 a MUST_NOT_THROW_EXPR with NOEX as condition. */
5191 finish_transaction_stmt (tree stmt, tree compound_stmt, int flags, tree noex)
5193 TRANSACTION_EXPR_BODY (stmt) = pop_stmt_list (TRANSACTION_EXPR_BODY (stmt));
5194 TRANSACTION_EXPR_OUTER (stmt) = (flags & TM_STMT_ATTR_OUTER) != 0;
5195 TRANSACTION_EXPR_RELAXED (stmt) = (flags & TM_STMT_ATTR_RELAXED) != 0;
5196 TRANSACTION_EXPR_IS_STMT (stmt) = 1;
5198 /* noexcept specifications are not allowed for function transactions. */
5199 gcc_assert (!(noex && compound_stmt));
5202 tree body = build_must_not_throw_expr (TRANSACTION_EXPR_BODY (stmt),
5204 SET_EXPR_LOCATION (body, EXPR_LOCATION (TRANSACTION_EXPR_BODY (stmt)));
5205 TREE_SIDE_EFFECTS (body) = 1;
5206 TRANSACTION_EXPR_BODY (stmt) = body;
5210 finish_compound_stmt (compound_stmt);
5214 /* Build a __transaction_atomic or __transaction_relaxed expression. If
5215 NOEX is non-NULL, we wrap the body in a MUST_NOT_THROW_EXPR with NOEX as
5219 build_transaction_expr (location_t loc, tree expr, int flags, tree noex)
5224 expr = build_must_not_throw_expr (expr, noex);
5225 SET_EXPR_LOCATION (expr, loc);
5226 TREE_SIDE_EFFECTS (expr) = 1;
5228 ret = build1 (TRANSACTION_EXPR, TREE_TYPE (expr), expr);
5229 if (flags & TM_STMT_ATTR_RELAXED)
5230 TRANSACTION_EXPR_RELAXED (ret) = 1;
5231 TREE_SIDE_EFFECTS (ret) = 1;
5232 SET_EXPR_LOCATION (ret, loc);
5237 init_cp_semantics (void)
5241 /* Build a STATIC_ASSERT for a static assertion with the condition
5242 CONDITION and the message text MESSAGE. LOCATION is the location
5243 of the static assertion in the source code. When MEMBER_P, this
5244 static assertion is a member of a class. */
5246 finish_static_assert (tree condition, tree message, location_t location,
5249 if (message == NULL_TREE
5250 || message == error_mark_node
5251 || condition == NULL_TREE
5252 || condition == error_mark_node)
5255 if (check_for_bare_parameter_packs (condition))
5256 condition = error_mark_node;
5258 if (type_dependent_expression_p (condition)
5259 || value_dependent_expression_p (condition))
5261 /* We're in a template; build a STATIC_ASSERT and put it in
5265 assertion = make_node (STATIC_ASSERT);
5266 STATIC_ASSERT_CONDITION (assertion) = condition;
5267 STATIC_ASSERT_MESSAGE (assertion) = message;
5268 STATIC_ASSERT_SOURCE_LOCATION (assertion) = location;
5271 maybe_add_class_template_decl_list (current_class_type,
5275 add_stmt (assertion);
5280 /* Fold the expression and convert it to a boolean value. */
5281 condition = fold_non_dependent_expr (condition);
5282 condition = cp_convert (boolean_type_node, condition, tf_warning_or_error);
5283 condition = maybe_constant_value (condition);
5285 if (TREE_CODE (condition) == INTEGER_CST && !integer_zerop (condition))
5286 /* Do nothing; the condition is satisfied. */
5290 location_t saved_loc = input_location;
5292 input_location = location;
5293 if (TREE_CODE (condition) == INTEGER_CST
5294 && integer_zerop (condition))
5295 /* Report the error. */
5296 error ("static assertion failed: %s", TREE_STRING_POINTER (message));
5297 else if (condition && condition != error_mark_node)
5299 error ("non-constant condition for static assertion");
5300 cxx_constant_value (condition);
5302 input_location = saved_loc;
5306 /* Implements the C++0x decltype keyword. Returns the type of EXPR,
5307 suitable for use as a type-specifier.
5309 ID_EXPRESSION_OR_MEMBER_ACCESS_P is true when EXPR was parsed as an
5310 id-expression or a class member access, FALSE when it was parsed as
5311 a full expression. */
5314 finish_decltype_type (tree expr, bool id_expression_or_member_access_p,
5315 tsubst_flags_t complain)
5317 tree type = NULL_TREE;
5319 if (!expr || error_operand_p (expr))
5320 return error_mark_node;
5323 || TREE_CODE (expr) == TYPE_DECL
5324 || (TREE_CODE (expr) == BIT_NOT_EXPR
5325 && TYPE_P (TREE_OPERAND (expr, 0))))
5327 if (complain & tf_error)
5328 error ("argument to decltype must be an expression");
5329 return error_mark_node;
5332 /* Depending on the resolution of DR 1172, we may later need to distinguish
5333 instantiation-dependent but not type-dependent expressions so that, say,
5334 A<decltype(sizeof(T))>::U doesn't require 'typename'. */
5335 if (instantiation_dependent_expression_p (expr))
5337 type = cxx_make_type (DECLTYPE_TYPE);
5338 DECLTYPE_TYPE_EXPR (type) = expr;
5339 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type)
5340 = id_expression_or_member_access_p;
5341 SET_TYPE_STRUCTURAL_EQUALITY (type);
5346 /* The type denoted by decltype(e) is defined as follows: */
5348 expr = resolve_nondeduced_context (expr);
5350 if (invalid_nonstatic_memfn_p (expr, complain))
5351 return error_mark_node;
5353 if (type_unknown_p (expr))
5355 if (complain & tf_error)
5356 error ("decltype cannot resolve address of overloaded function");
5357 return error_mark_node;
5360 /* To get the size of a static data member declared as an array of
5361 unknown bound, we need to instantiate it. */
5363 && VAR_HAD_UNKNOWN_BOUND (expr)
5364 && DECL_TEMPLATE_INSTANTIATION (expr))
5365 instantiate_decl (expr, /*defer_ok*/true, /*expl_inst_mem*/false);
5367 if (id_expression_or_member_access_p)
5369 /* If e is an id-expression or a class member access (5.2.5
5370 [expr.ref]), decltype(e) is defined as the type of the entity
5371 named by e. If there is no such entity, or e names a set of
5372 overloaded functions, the program is ill-formed. */
5373 if (identifier_p (expr))
5374 expr = lookup_name (expr);
5376 if (INDIRECT_REF_P (expr))
5377 /* This can happen when the expression is, e.g., "a.b". Just
5378 look at the underlying operand. */
5379 expr = TREE_OPERAND (expr, 0);
5381 if (TREE_CODE (expr) == OFFSET_REF
5382 || TREE_CODE (expr) == MEMBER_REF
5383 || TREE_CODE (expr) == SCOPE_REF)
5384 /* We're only interested in the field itself. If it is a
5385 BASELINK, we will need to see through it in the next
5387 expr = TREE_OPERAND (expr, 1);
5389 if (BASELINK_P (expr))
5390 /* See through BASELINK nodes to the underlying function. */
5391 expr = BASELINK_FUNCTIONS (expr);
5393 switch (TREE_CODE (expr))
5396 if (DECL_BIT_FIELD_TYPE (expr))
5398 type = DECL_BIT_FIELD_TYPE (expr);
5401 /* Fall through for fields that aren't bitfields. */
5408 case TEMPLATE_PARM_INDEX:
5409 expr = mark_type_use (expr);
5410 type = TREE_TYPE (expr);
5414 type = error_mark_node;
5419 mark_type_use (expr);
5420 type = is_bitfield_expr_with_lowered_type (expr);
5422 type = TREE_TYPE (TREE_OPERAND (expr, 1));
5430 /* We can get here when the id-expression refers to an
5431 enumerator or non-type template parameter. */
5432 type = TREE_TYPE (expr);
5436 /* Handle instantiated template non-type arguments. */
5437 type = TREE_TYPE (expr);
5443 /* Within a lambda-expression:
5445 Every occurrence of decltype((x)) where x is a possibly
5446 parenthesized id-expression that names an entity of
5447 automatic storage duration is treated as if x were
5448 transformed into an access to a corresponding data member
5449 of the closure type that would have been declared if x
5450 were a use of the denoted entity. */
5451 if (outer_automatic_var_p (expr)
5452 && current_function_decl
5453 && LAMBDA_FUNCTION_P (current_function_decl))
5454 type = capture_decltype (expr);
5455 else if (error_operand_p (expr))
5456 type = error_mark_node;
5457 else if (expr == current_class_ptr)
5458 /* If the expression is just "this", we want the
5459 cv-unqualified pointer for the "this" type. */
5460 type = TYPE_MAIN_VARIANT (TREE_TYPE (expr));
5463 /* Otherwise, where T is the type of e, if e is an lvalue,
5464 decltype(e) is defined as T&; if an xvalue, T&&; otherwise, T. */
5465 cp_lvalue_kind clk = lvalue_kind (expr);
5466 type = unlowered_expr_type (expr);
5467 gcc_assert (TREE_CODE (type) != REFERENCE_TYPE);
5469 /* For vector types, pick a non-opaque variant. */
5470 if (TREE_CODE (type) == VECTOR_TYPE)
5471 type = strip_typedefs (type);
5473 if (clk != clk_none && !(clk & clk_class))
5474 type = cp_build_reference_type (type, (clk & clk_rvalueref));
5478 if (cxx_dialect >= cxx1y && array_of_runtime_bound_p (type))
5480 if (complain & tf_warning_or_error)
5481 pedwarn (input_location, OPT_Wvla,
5482 "taking decltype of array of runtime bound");
5484 return error_mark_node;
5490 /* Called from trait_expr_value to evaluate either __has_nothrow_assign or
5491 __has_nothrow_copy, depending on assign_p. */
5494 classtype_has_nothrow_assign_or_copy_p (tree type, bool assign_p)
5501 ix = lookup_fnfields_1 (type, ansi_assopname (NOP_EXPR));
5504 fns = (*CLASSTYPE_METHOD_VEC (type))[ix];
5506 else if (TYPE_HAS_COPY_CTOR (type))
5508 /* If construction of the copy constructor was postponed, create
5510 if (CLASSTYPE_LAZY_COPY_CTOR (type))
5511 lazily_declare_fn (sfk_copy_constructor, type);
5512 if (CLASSTYPE_LAZY_MOVE_CTOR (type))
5513 lazily_declare_fn (sfk_move_constructor, type);
5514 fns = CLASSTYPE_CONSTRUCTORS (type);
5519 for (; fns; fns = OVL_NEXT (fns))
5521 tree fn = OVL_CURRENT (fns);
5525 if (copy_fn_p (fn) == 0)
5528 else if (copy_fn_p (fn) <= 0)
5531 maybe_instantiate_noexcept (fn);
5532 if (!TYPE_NOTHROW_P (TREE_TYPE (fn)))
5539 /* Actually evaluates the trait. */
5542 trait_expr_value (cp_trait_kind kind, tree type1, tree type2)
5544 enum tree_code type_code1;
5547 type_code1 = TREE_CODE (type1);
5551 case CPTK_HAS_NOTHROW_ASSIGN:
5552 type1 = strip_array_types (type1);
5553 return (!CP_TYPE_CONST_P (type1) && type_code1 != REFERENCE_TYPE
5554 && (trait_expr_value (CPTK_HAS_TRIVIAL_ASSIGN, type1, type2)
5555 || (CLASS_TYPE_P (type1)
5556 && classtype_has_nothrow_assign_or_copy_p (type1,
5559 case CPTK_HAS_TRIVIAL_ASSIGN:
5560 /* ??? The standard seems to be missing the "or array of such a class
5561 type" wording for this trait. */
5562 type1 = strip_array_types (type1);
5563 return (!CP_TYPE_CONST_P (type1) && type_code1 != REFERENCE_TYPE
5564 && (trivial_type_p (type1)
5565 || (CLASS_TYPE_P (type1)
5566 && TYPE_HAS_TRIVIAL_COPY_ASSIGN (type1))));
5568 case CPTK_HAS_NOTHROW_CONSTRUCTOR:
5569 type1 = strip_array_types (type1);
5570 return (trait_expr_value (CPTK_HAS_TRIVIAL_CONSTRUCTOR, type1, type2)
5571 || (CLASS_TYPE_P (type1)
5572 && (t = locate_ctor (type1))
5573 && (maybe_instantiate_noexcept (t),
5574 TYPE_NOTHROW_P (TREE_TYPE (t)))));
5576 case CPTK_HAS_TRIVIAL_CONSTRUCTOR:
5577 type1 = strip_array_types (type1);
5578 return (trivial_type_p (type1)
5579 || (CLASS_TYPE_P (type1) && TYPE_HAS_TRIVIAL_DFLT (type1)));
5581 case CPTK_HAS_NOTHROW_COPY:
5582 type1 = strip_array_types (type1);
5583 return (trait_expr_value (CPTK_HAS_TRIVIAL_COPY, type1, type2)
5584 || (CLASS_TYPE_P (type1)
5585 && classtype_has_nothrow_assign_or_copy_p (type1, false)));
5587 case CPTK_HAS_TRIVIAL_COPY:
5588 /* ??? The standard seems to be missing the "or array of such a class
5589 type" wording for this trait. */
5590 type1 = strip_array_types (type1);
5591 return (trivial_type_p (type1) || type_code1 == REFERENCE_TYPE
5592 || (CLASS_TYPE_P (type1) && TYPE_HAS_TRIVIAL_COPY_CTOR (type1)));
5594 case CPTK_HAS_TRIVIAL_DESTRUCTOR:
5595 type1 = strip_array_types (type1);
5596 return (trivial_type_p (type1) || type_code1 == REFERENCE_TYPE
5597 || (CLASS_TYPE_P (type1)
5598 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type1)));
5600 case CPTK_HAS_VIRTUAL_DESTRUCTOR:
5601 return type_has_virtual_destructor (type1);
5603 case CPTK_IS_ABSTRACT:
5604 return (ABSTRACT_CLASS_TYPE_P (type1));
5606 case CPTK_IS_BASE_OF:
5607 return (NON_UNION_CLASS_TYPE_P (type1) && NON_UNION_CLASS_TYPE_P (type2)
5608 && DERIVED_FROM_P (type1, type2));
5611 return (NON_UNION_CLASS_TYPE_P (type1));
5613 case CPTK_IS_CONVERTIBLE_TO:
5618 return (NON_UNION_CLASS_TYPE_P (type1) && CLASSTYPE_EMPTY_P (type1));
5621 return (type_code1 == ENUMERAL_TYPE);
5624 return (CLASS_TYPE_P (type1) && CLASSTYPE_FINAL (type1));
5626 case CPTK_IS_LITERAL_TYPE:
5627 return (literal_type_p (type1));
5630 return (pod_type_p (type1));
5632 case CPTK_IS_POLYMORPHIC:
5633 return (CLASS_TYPE_P (type1) && TYPE_POLYMORPHIC_P (type1));
5635 case CPTK_IS_STD_LAYOUT:
5636 return (std_layout_type_p (type1));
5638 case CPTK_IS_TRIVIAL:
5639 return (trivial_type_p (type1));
5642 return (type_code1 == UNION_TYPE);
5650 /* If TYPE is an array of unknown bound, or (possibly cv-qualified)
5651 void, or a complete type, returns it, otherwise NULL_TREE. */
5654 check_trait_type (tree type)
5656 if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
5657 && COMPLETE_TYPE_P (TREE_TYPE (type)))
5660 if (VOID_TYPE_P (type))
5663 return complete_type_or_else (strip_array_types (type), NULL_TREE);
5666 /* Process a trait expression. */
5669 finish_trait_expr (cp_trait_kind kind, tree type1, tree type2)
5671 gcc_assert (kind == CPTK_HAS_NOTHROW_ASSIGN
5672 || kind == CPTK_HAS_NOTHROW_CONSTRUCTOR
5673 || kind == CPTK_HAS_NOTHROW_COPY
5674 || kind == CPTK_HAS_TRIVIAL_ASSIGN
5675 || kind == CPTK_HAS_TRIVIAL_CONSTRUCTOR
5676 || kind == CPTK_HAS_TRIVIAL_COPY
5677 || kind == CPTK_HAS_TRIVIAL_DESTRUCTOR
5678 || kind == CPTK_HAS_VIRTUAL_DESTRUCTOR
5679 || kind == CPTK_IS_ABSTRACT
5680 || kind == CPTK_IS_BASE_OF
5681 || kind == CPTK_IS_CLASS
5682 || kind == CPTK_IS_CONVERTIBLE_TO
5683 || kind == CPTK_IS_EMPTY
5684 || kind == CPTK_IS_ENUM
5685 || kind == CPTK_IS_FINAL
5686 || kind == CPTK_IS_LITERAL_TYPE
5687 || kind == CPTK_IS_POD
5688 || kind == CPTK_IS_POLYMORPHIC
5689 || kind == CPTK_IS_STD_LAYOUT
5690 || kind == CPTK_IS_TRIVIAL
5691 || kind == CPTK_IS_UNION);
5693 if (kind == CPTK_IS_CONVERTIBLE_TO)
5695 sorry ("__is_convertible_to");
5696 return error_mark_node;
5699 if (type1 == error_mark_node
5700 || ((kind == CPTK_IS_BASE_OF || kind == CPTK_IS_CONVERTIBLE_TO)
5701 && type2 == error_mark_node))
5702 return error_mark_node;
5704 if (processing_template_decl)
5706 tree trait_expr = make_node (TRAIT_EXPR);
5707 TREE_TYPE (trait_expr) = boolean_type_node;
5708 TRAIT_EXPR_TYPE1 (trait_expr) = type1;
5709 TRAIT_EXPR_TYPE2 (trait_expr) = type2;
5710 TRAIT_EXPR_KIND (trait_expr) = kind;
5716 case CPTK_HAS_NOTHROW_ASSIGN:
5717 case CPTK_HAS_TRIVIAL_ASSIGN:
5718 case CPTK_HAS_NOTHROW_CONSTRUCTOR:
5719 case CPTK_HAS_TRIVIAL_CONSTRUCTOR:
5720 case CPTK_HAS_NOTHROW_COPY:
5721 case CPTK_HAS_TRIVIAL_COPY:
5722 case CPTK_HAS_TRIVIAL_DESTRUCTOR:
5723 case CPTK_HAS_VIRTUAL_DESTRUCTOR:
5724 case CPTK_IS_ABSTRACT:
5727 case CPTK_IS_LITERAL_TYPE:
5729 case CPTK_IS_POLYMORPHIC:
5730 case CPTK_IS_STD_LAYOUT:
5731 case CPTK_IS_TRIVIAL:
5732 if (!check_trait_type (type1))
5733 return error_mark_node;
5736 case CPTK_IS_BASE_OF:
5737 if (NON_UNION_CLASS_TYPE_P (type1) && NON_UNION_CLASS_TYPE_P (type2)
5738 && !same_type_ignoring_top_level_qualifiers_p (type1, type2)
5739 && !complete_type_or_else (type2, NULL_TREE))
5740 /* We already issued an error. */
5741 return error_mark_node;
5749 case CPTK_IS_CONVERTIBLE_TO:
5754 return (trait_expr_value (kind, type1, type2)
5755 ? boolean_true_node : boolean_false_node);
5758 /* Do-nothing variants of functions to handle pragma FLOAT_CONST_DECIMAL64,
5759 which is ignored for C++. */
5762 set_float_const_decimal64 (void)
5767 clear_float_const_decimal64 (void)
5772 float_const_decimal64_p (void)
5778 /* Return true if T is a literal type. */
5781 literal_type_p (tree t)
5783 if (SCALAR_TYPE_P (t)
5784 || TREE_CODE (t) == VECTOR_TYPE
5785 || TREE_CODE (t) == REFERENCE_TYPE)
5787 if (CLASS_TYPE_P (t))
5789 t = complete_type (t);
5790 gcc_assert (COMPLETE_TYPE_P (t) || errorcount);
5791 return CLASSTYPE_LITERAL_P (t);
5793 if (TREE_CODE (t) == ARRAY_TYPE)
5794 return literal_type_p (strip_array_types (t));
5798 /* If DECL is a variable declared `constexpr', require its type
5799 be literal. Return the DECL if OK, otherwise NULL. */
5802 ensure_literal_type_for_constexpr_object (tree decl)
5804 tree type = TREE_TYPE (decl);
5805 if (VAR_P (decl) && DECL_DECLARED_CONSTEXPR_P (decl)
5806 && !processing_template_decl)
5808 if (CLASS_TYPE_P (type) && !COMPLETE_TYPE_P (complete_type (type)))
5809 /* Don't complain here, we'll complain about incompleteness
5810 when we try to initialize the variable. */;
5811 else if (!literal_type_p (type))
5813 error ("the type %qT of constexpr variable %qD is not literal",
5815 explain_non_literal_class (type);
5822 /* Representation of entries in the constexpr function definition table. */
5824 typedef struct GTY(()) constexpr_fundef {
5829 /* This table holds all constexpr function definitions seen in
5830 the current translation unit. */
5832 static GTY ((param_is (constexpr_fundef))) htab_t constexpr_fundef_table;
5834 /* Utility function used for managing the constexpr function table.
5835 Return true if the entries pointed to by P and Q are for the
5836 same constexpr function. */
5839 constexpr_fundef_equal (const void *p, const void *q)
5841 const constexpr_fundef *lhs = (const constexpr_fundef *) p;
5842 const constexpr_fundef *rhs = (const constexpr_fundef *) q;
5843 return lhs->decl == rhs->decl;
5846 /* Utility function used for managing the constexpr function table.
5847 Return a hash value for the entry pointed to by Q. */
5849 static inline hashval_t
5850 constexpr_fundef_hash (const void *p)
5852 const constexpr_fundef *fundef = (const constexpr_fundef *) p;
5853 return DECL_UID (fundef->decl);
5856 /* Return a previously saved definition of function FUN. */
5858 static constexpr_fundef *
5859 retrieve_constexpr_fundef (tree fun)
5861 constexpr_fundef fundef = { NULL, NULL };
5862 if (constexpr_fundef_table == NULL)
5866 return (constexpr_fundef *) htab_find (constexpr_fundef_table, &fundef);
5869 /* Check whether the parameter and return types of FUN are valid for a
5870 constexpr function, and complain if COMPLAIN. */
5873 is_valid_constexpr_fn (tree fun, bool complain)
5875 tree parm = FUNCTION_FIRST_USER_PARM (fun);
5877 for (; parm != NULL; parm = TREE_CHAIN (parm))
5878 if (!literal_type_p (TREE_TYPE (parm)))
5883 error ("invalid type for parameter %d of constexpr "
5884 "function %q+#D", DECL_PARM_INDEX (parm), fun);
5885 explain_non_literal_class (TREE_TYPE (parm));
5889 if (!DECL_CONSTRUCTOR_P (fun))
5891 tree rettype = TREE_TYPE (TREE_TYPE (fun));
5892 if (!literal_type_p (rettype))
5897 error ("invalid return type %qT of constexpr function %q+D",
5899 explain_non_literal_class (rettype);
5903 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun)
5904 && !CLASSTYPE_LITERAL_P (DECL_CONTEXT (fun)))
5909 error ("enclosing class of constexpr non-static member "
5910 "function %q+#D is not a literal type", fun);
5911 explain_non_literal_class (DECL_CONTEXT (fun));
5915 else if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fun)))
5919 error ("%q#T has virtual base classes", DECL_CONTEXT (fun));
5925 /* Subroutine of build_data_member_initialization. MEMBER is a COMPONENT_REF
5926 for a member of an anonymous aggregate, INIT is the initializer for that
5927 member, and VEC_OUTER is the vector of constructor elements for the class
5928 whose constructor we are processing. Add the initializer to the vector
5929 and return true to indicate success. */
5932 build_anon_member_initialization (tree member, tree init,
5933 vec<constructor_elt, va_gc> **vec_outer)
5935 /* MEMBER presents the relevant fields from the inside out, but we need
5936 to build up the initializer from the outside in so that we can reuse
5937 previously built CONSTRUCTORs if this is, say, the second field in an
5938 anonymous struct. So we use a vec as a stack. */
5943 fields.safe_push (TREE_OPERAND (member, 1));
5944 member = TREE_OPERAND (member, 0);
5946 while (ANON_AGGR_TYPE_P (TREE_TYPE (member)));
5948 /* VEC has the constructor elements vector for the context of FIELD.
5949 If FIELD is an anonymous aggregate, we will push inside it. */
5950 vec<constructor_elt, va_gc> **vec = vec_outer;
5952 while (field = fields.pop(),
5953 ANON_AGGR_TYPE_P (TREE_TYPE (field)))
5956 /* If there is already an outer constructor entry for the anonymous
5957 aggregate FIELD, use it; otherwise, insert one. */
5958 if (vec_safe_is_empty (*vec)
5959 || (*vec)->last().index != field)
5961 ctor = build_constructor (TREE_TYPE (field), NULL);
5962 CONSTRUCTOR_APPEND_ELT (*vec, field, ctor);
5965 ctor = (*vec)->last().value;
5966 vec = &CONSTRUCTOR_ELTS (ctor);
5969 /* Now we're at the innermost field, the one that isn't an anonymous
5970 aggregate. Add its initializer to the CONSTRUCTOR and we're done. */
5971 gcc_assert (fields.is_empty());
5973 CONSTRUCTOR_APPEND_ELT (*vec, field, init);
5978 /* Subroutine of build_constexpr_constructor_member_initializers.
5979 The expression tree T represents a data member initialization
5980 in a (constexpr) constructor definition. Build a pairing of
5981 the data member with its initializer, and prepend that pair
5982 to the existing initialization pair INITS. */
5985 build_data_member_initialization (tree t, vec<constructor_elt, va_gc> **vec)
5988 if (TREE_CODE (t) == CLEANUP_POINT_EXPR)
5989 t = TREE_OPERAND (t, 0);
5990 if (TREE_CODE (t) == EXPR_STMT)
5991 t = TREE_OPERAND (t, 0);
5992 if (t == error_mark_node)
5994 if (TREE_CODE (t) == STATEMENT_LIST)
5996 tree_stmt_iterator i;
5997 for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
5999 if (! build_data_member_initialization (tsi_stmt (i), vec))
6004 if (TREE_CODE (t) == CLEANUP_STMT)
6006 /* We can't see a CLEANUP_STMT in a constructor for a literal class,
6007 but we can in a constexpr constructor for a non-literal class. Just
6008 ignore it; either all the initialization will be constant, in which
6009 case the cleanup can't run, or it can't be constexpr.
6010 Still recurse into CLEANUP_BODY. */
6011 return build_data_member_initialization (CLEANUP_BODY (t), vec);
6013 if (TREE_CODE (t) == CONVERT_EXPR)
6014 t = TREE_OPERAND (t, 0);
6015 if (TREE_CODE (t) == INIT_EXPR
6016 || TREE_CODE (t) == MODIFY_EXPR)
6018 member = TREE_OPERAND (t, 0);
6019 init = unshare_expr (TREE_OPERAND (t, 1));
6021 else if (TREE_CODE (t) == CALL_EXPR)
6023 member = CALL_EXPR_ARG (t, 0);
6024 /* We don't use build_cplus_new here because it complains about
6025 abstract bases. Leaving the call unwrapped means that it has the
6026 wrong type, but cxx_eval_constant_expression doesn't care. */
6027 init = unshare_expr (t);
6029 else if (TREE_CODE (t) == DECL_EXPR)
6030 /* Declaring a temporary, don't add it to the CONSTRUCTOR. */
6034 if (INDIRECT_REF_P (member))
6035 member = TREE_OPERAND (member, 0);
6036 if (TREE_CODE (member) == NOP_EXPR)
6040 if (TREE_CODE (op) == ADDR_EXPR)
6042 gcc_assert (same_type_ignoring_top_level_qualifiers_p
6043 (TREE_TYPE (TREE_TYPE (op)),
6044 TREE_TYPE (TREE_TYPE (member))));
6045 /* Initializing a cv-qualified member; we need to look through
6049 else if (op == current_class_ptr
6050 && (same_type_ignoring_top_level_qualifiers_p
6051 (TREE_TYPE (TREE_TYPE (member)),
6052 current_class_type)))
6053 /* Delegating constructor. */
6057 /* This is an initializer for an empty base; keep it for now so
6058 we can check it in cxx_eval_bare_aggregate. */
6059 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member))));
6062 if (TREE_CODE (member) == ADDR_EXPR)
6063 member = TREE_OPERAND (member, 0);
6064 if (TREE_CODE (member) == COMPONENT_REF)
6066 tree aggr = TREE_OPERAND (member, 0);
6067 if (TREE_CODE (aggr) != COMPONENT_REF)
6068 /* Normal member initialization. */
6069 member = TREE_OPERAND (member, 1);
6070 else if (ANON_AGGR_TYPE_P (TREE_TYPE (aggr)))
6071 /* Initializing a member of an anonymous union. */
6072 return build_anon_member_initialization (member, init, vec);
6074 /* We're initializing a vtable pointer in a base. Leave it as
6075 COMPONENT_REF so we remember the path to get to the vfield. */
6076 gcc_assert (TREE_TYPE (member) == vtbl_ptr_type_node);
6079 CONSTRUCTOR_APPEND_ELT (*vec, member, init);
6083 /* Make sure that there are no statements after LAST in the constructor
6084 body represented by LIST. */
6087 check_constexpr_ctor_body (tree last, tree list)
6090 if (TREE_CODE (list) == STATEMENT_LIST)
6092 tree_stmt_iterator i = tsi_last (list);
6093 for (; !tsi_end_p (i); tsi_prev (&i))
6095 tree t = tsi_stmt (i);
6098 if (TREE_CODE (t) == BIND_EXPR)
6100 if (!check_constexpr_ctor_body (last, BIND_EXPR_BODY (t)))
6105 /* We currently allow typedefs and static_assert.
6106 FIXME allow them in the standard, too. */
6107 if (TREE_CODE (t) != STATIC_ASSERT)
6114 else if (list != last
6115 && TREE_CODE (list) != STATIC_ASSERT)
6119 error ("constexpr constructor does not have empty body");
6120 DECL_DECLARED_CONSTEXPR_P (current_function_decl) = false;
6125 /* V is a vector of constructor elements built up for the base and member
6126 initializers of a constructor for TYPE. They need to be in increasing
6127 offset order, which they might not be yet if TYPE has a primary base
6128 which is not first in the base-clause or a vptr and at least one base
6129 all of which are non-primary. */
6131 static vec<constructor_elt, va_gc> *
6132 sort_constexpr_mem_initializers (tree type, vec<constructor_elt, va_gc> *v)
6134 tree pri = CLASSTYPE_PRIMARY_BINFO (type);
6136 constructor_elt elt;
6140 field_type = BINFO_TYPE (pri);
6141 else if (TYPE_CONTAINS_VPTR_P (type))
6142 field_type = vtbl_ptr_type_node;
6146 /* Find the element for the primary base or vptr and move it to the
6147 beginning of the vec. */
6148 vec<constructor_elt, va_gc> &vref = *v;
6150 if (TREE_TYPE (vref[i].index) == field_type)
6157 vref[i] = vref[i-1];
6164 /* Build compile-time evalable representations of member-initializer list
6165 for a constexpr constructor. */
6168 build_constexpr_constructor_member_initializers (tree type, tree body)
6170 vec<constructor_elt, va_gc> *vec = NULL;
6172 if (TREE_CODE (body) == MUST_NOT_THROW_EXPR
6173 || TREE_CODE (body) == EH_SPEC_BLOCK)
6174 body = TREE_OPERAND (body, 0);
6175 if (TREE_CODE (body) == STATEMENT_LIST)
6176 body = STATEMENT_LIST_HEAD (body)->stmt;
6177 body = BIND_EXPR_BODY (body);
6178 if (TREE_CODE (body) == CLEANUP_POINT_EXPR)
6180 body = TREE_OPERAND (body, 0);
6181 if (TREE_CODE (body) == EXPR_STMT)
6182 body = TREE_OPERAND (body, 0);
6183 if (TREE_CODE (body) == INIT_EXPR
6184 && (same_type_ignoring_top_level_qualifiers_p
6185 (TREE_TYPE (TREE_OPERAND (body, 0)),
6186 current_class_type)))
6189 return TREE_OPERAND (body, 1);
6191 ok = build_data_member_initialization (body, &vec);
6193 else if (TREE_CODE (body) == STATEMENT_LIST)
6195 tree_stmt_iterator i;
6196 for (i = tsi_start (body); !tsi_end_p (i); tsi_next (&i))
6198 ok = build_data_member_initialization (tsi_stmt (i), &vec);
6203 else if (TREE_CODE (body) == TRY_BLOCK)
6205 error ("body of %<constexpr%> constructor cannot be "
6206 "a function-try-block");
6207 return error_mark_node;
6209 else if (EXPR_P (body))
6210 ok = build_data_member_initialization (body, &vec);
6212 gcc_assert (errorcount > 0);
6215 if (vec_safe_length (vec) > 0)
6217 /* In a delegating constructor, return the target. */
6218 constructor_elt *ce = &(*vec)[0];
6219 if (ce->index == current_class_ptr)
6226 vec = sort_constexpr_mem_initializers (type, vec);
6227 return build_constructor (type, vec);
6230 return error_mark_node;
6233 /* Subroutine of register_constexpr_fundef. BODY is the body of a function
6234 declared to be constexpr, or a sub-statement thereof. Returns the
6235 return value if suitable, error_mark_node for a statement not allowed in
6236 a constexpr function, or NULL_TREE if no return value was found. */
6239 constexpr_fn_retval (tree body)
6241 switch (TREE_CODE (body))
6243 case STATEMENT_LIST:
6245 tree_stmt_iterator i;
6246 tree expr = NULL_TREE;
6247 for (i = tsi_start (body); !tsi_end_p (i); tsi_next (&i))
6249 tree s = constexpr_fn_retval (tsi_stmt (i));
6250 if (s == error_mark_node)
6251 return error_mark_node;
6252 else if (s == NULL_TREE)
6253 /* Keep iterating. */;
6255 /* Multiple return statements. */
6256 return error_mark_node;
6264 return unshare_expr (TREE_OPERAND (body, 0));
6267 if (TREE_CODE (DECL_EXPR_DECL (body)) == USING_DECL)
6269 return error_mark_node;
6271 case CLEANUP_POINT_EXPR:
6272 return constexpr_fn_retval (TREE_OPERAND (body, 0));
6278 return error_mark_node;
6282 /* Subroutine of register_constexpr_fundef. BODY is the DECL_SAVED_TREE of
6283 FUN; do the necessary transformations to turn it into a single expression
6284 that we can store in the hash table. */
6287 massage_constexpr_body (tree fun, tree body)
6289 if (DECL_CONSTRUCTOR_P (fun))
6290 body = build_constexpr_constructor_member_initializers
6291 (DECL_CONTEXT (fun), body);
6294 if (TREE_CODE (body) == EH_SPEC_BLOCK)
6295 body = EH_SPEC_STMTS (body);
6296 if (TREE_CODE (body) == MUST_NOT_THROW_EXPR)
6297 body = TREE_OPERAND (body, 0);
6298 if (TREE_CODE (body) == BIND_EXPR)
6299 body = BIND_EXPR_BODY (body);
6300 body = constexpr_fn_retval (body);
6305 /* FUN is a constexpr constructor with massaged body BODY. Return true
6306 if some bases/fields are uninitialized, and complain if COMPLAIN. */
6309 cx_check_missing_mem_inits (tree fun, tree body, bool complain)
6316 if (TREE_CODE (body) != CONSTRUCTOR)
6319 nelts = CONSTRUCTOR_NELTS (body);
6320 ctype = DECL_CONTEXT (fun);
6321 field = TYPE_FIELDS (ctype);
6323 if (TREE_CODE (ctype) == UNION_TYPE)
6325 if (nelts == 0 && next_initializable_field (field))
6328 error ("%<constexpr%> constructor for union %qT must "
6329 "initialize exactly one non-static data member", ctype);
6336 for (i = 0; i <= nelts; ++i)
6343 index = CONSTRUCTOR_ELT (body, i)->index;
6344 /* Skip base and vtable inits. */
6345 if (TREE_CODE (index) != FIELD_DECL
6346 || DECL_ARTIFICIAL (index))
6349 for (; field != index; field = DECL_CHAIN (field))
6352 if (TREE_CODE (field) != FIELD_DECL
6353 || (DECL_C_BIT_FIELD (field) && !DECL_NAME (field))
6354 || DECL_ARTIFICIAL (field))
6356 ftype = strip_array_types (TREE_TYPE (field));
6357 if (type_has_constexpr_default_constructor (ftype))
6359 /* It's OK to skip a member with a trivial constexpr ctor.
6360 A constexpr ctor that isn't trivial should have been
6362 gcc_checking_assert (!TYPE_HAS_COMPLEX_DFLT (ftype)
6363 || errorcount != 0);
6368 error ("uninitialized member %qD in %<constexpr%> constructor",
6372 if (field == NULL_TREE)
6374 field = DECL_CHAIN (field);
6380 /* We are processing the definition of the constexpr function FUN.
6381 Check that its BODY fulfills the propriate requirements and
6382 enter it in the constexpr function definition table.
6383 For constructor BODY is actually the TREE_LIST of the
6384 member-initializer list. */
6387 register_constexpr_fundef (tree fun, tree body)
6389 constexpr_fundef entry;
6390 constexpr_fundef **slot;
6392 if (!is_valid_constexpr_fn (fun, !DECL_GENERATED_P (fun)))
6395 body = massage_constexpr_body (fun, body);
6396 if (body == NULL_TREE || body == error_mark_node)
6398 if (!DECL_CONSTRUCTOR_P (fun))
6399 error ("body of constexpr function %qD not a return-statement", fun);
6403 if (!potential_rvalue_constant_expression (body))
6405 if (!DECL_GENERATED_P (fun))
6406 require_potential_rvalue_constant_expression (body);
6410 if (DECL_CONSTRUCTOR_P (fun)
6411 && cx_check_missing_mem_inits (fun, body, !DECL_GENERATED_P (fun)))
6414 /* Create the constexpr function table if necessary. */
6415 if (constexpr_fundef_table == NULL)
6416 constexpr_fundef_table = htab_create_ggc (101,
6417 constexpr_fundef_hash,
6418 constexpr_fundef_equal,
6422 slot = (constexpr_fundef **)
6423 htab_find_slot (constexpr_fundef_table, &entry, INSERT);
6425 gcc_assert (*slot == NULL);
6426 *slot = ggc_alloc_constexpr_fundef ();
6432 /* FUN is a non-constexpr function called in a context that requires a
6433 constant expression. If it comes from a constexpr template, explain why
6434 the instantiation isn't constexpr. */
6437 explain_invalid_constexpr_fn (tree fun)
6439 static struct pointer_set_t *diagnosed;
6441 location_t save_loc;
6442 /* Only diagnose defaulted functions or instantiations. */
6443 if (!DECL_DEFAULTED_FN (fun)
6444 && !is_instantiation_of_constexpr (fun))
6446 if (diagnosed == NULL)
6447 diagnosed = pointer_set_create ();
6448 if (pointer_set_insert (diagnosed, fun) != 0)
6449 /* Already explained. */
6452 save_loc = input_location;
6453 input_location = DECL_SOURCE_LOCATION (fun);
6454 inform (0, "%q+D is not usable as a constexpr function because:", fun);
6455 /* First check the declaration. */
6456 if (is_valid_constexpr_fn (fun, true))
6458 /* Then if it's OK, the body. */
6459 if (DECL_DEFAULTED_FN (fun))
6460 explain_implicit_non_constexpr (fun);
6463 body = massage_constexpr_body (fun, DECL_SAVED_TREE (fun));
6464 require_potential_rvalue_constant_expression (body);
6465 if (DECL_CONSTRUCTOR_P (fun))
6466 cx_check_missing_mem_inits (fun, body, true);
6469 input_location = save_loc;
6472 /* Objects of this type represent calls to constexpr functions
6473 along with the bindings of parameters to their arguments, for
6474 the purpose of compile time evaluation. */
6476 typedef struct GTY(()) constexpr_call {
6477 /* Description of the constexpr function definition. */
6478 constexpr_fundef *fundef;
6479 /* Parameter bindings environment. A TREE_LIST where each TREE_PURPOSE
6480 is a parameter _DECL and the TREE_VALUE is the value of the parameter.
6481 Note: This arrangement is made to accomodate the use of
6482 iterative_hash_template_arg (see pt.c). If you change this
6483 representation, also change the hash calculation in
6484 cxx_eval_call_expression. */
6486 /* Result of the call.
6487 NULL means the call is being evaluated.
6488 error_mark_node means that the evaluation was erroneous;
6489 otherwise, the actuall value of the call. */
6491 /* The hash of this call; we remember it here to avoid having to
6492 recalculate it when expanding the hash table. */
6496 /* A table of all constexpr calls that have been evaluated by the
6497 compiler in this translation unit. */
6499 static GTY ((param_is (constexpr_call))) htab_t constexpr_call_table;
6501 static tree cxx_eval_constant_expression (const constexpr_call *, tree,
6502 bool, bool, bool *, bool *);
6504 /* Compute a hash value for a constexpr call representation. */
6507 constexpr_call_hash (const void *p)
6509 const constexpr_call *info = (const constexpr_call *) p;
6513 /* Return 1 if the objects pointed to by P and Q represent calls
6514 to the same constexpr function with the same arguments.
6515 Otherwise, return 0. */
6518 constexpr_call_equal (const void *p, const void *q)
6520 const constexpr_call *lhs = (const constexpr_call *) p;
6521 const constexpr_call *rhs = (const constexpr_call *) q;
6526 if (!constexpr_fundef_equal (lhs->fundef, rhs->fundef))
6528 lhs_bindings = lhs->bindings;
6529 rhs_bindings = rhs->bindings;
6530 while (lhs_bindings != NULL && rhs_bindings != NULL)
6532 tree lhs_arg = TREE_VALUE (lhs_bindings);
6533 tree rhs_arg = TREE_VALUE (rhs_bindings);
6534 gcc_assert (TREE_TYPE (lhs_arg) == TREE_TYPE (rhs_arg));
6535 if (!cp_tree_equal (lhs_arg, rhs_arg))
6537 lhs_bindings = TREE_CHAIN (lhs_bindings);
6538 rhs_bindings = TREE_CHAIN (rhs_bindings);
6540 return lhs_bindings == rhs_bindings;
6543 /* Initialize the constexpr call table, if needed. */
6546 maybe_initialize_constexpr_call_table (void)
6548 if (constexpr_call_table == NULL)
6549 constexpr_call_table = htab_create_ggc (101,
6550 constexpr_call_hash,
6551 constexpr_call_equal,
6555 /* Return true if T designates the implied `this' parameter. */
6558 is_this_parameter (tree t)
6560 return t == current_class_ptr;
6563 /* We have an expression tree T that represents a call, either CALL_EXPR
6564 or AGGR_INIT_EXPR. If the call is lexically to a named function,
6565 retrun the _DECL for that function. */
6568 get_function_named_in_call (tree t)
6571 switch (TREE_CODE (t))
6574 fun = CALL_EXPR_FN (t);
6577 case AGGR_INIT_EXPR:
6578 fun = AGGR_INIT_EXPR_FN (t);
6585 if (TREE_CODE (fun) == ADDR_EXPR
6586 && TREE_CODE (TREE_OPERAND (fun, 0)) == FUNCTION_DECL)
6587 fun = TREE_OPERAND (fun, 0);
6591 /* We have an expression tree T that represents a call, either CALL_EXPR
6592 or AGGR_INIT_EXPR. Return the Nth argument. */
6595 get_nth_callarg (tree t, int n)
6597 switch (TREE_CODE (t))
6600 return CALL_EXPR_ARG (t, n);
6602 case AGGR_INIT_EXPR:
6603 return AGGR_INIT_EXPR_ARG (t, n);
6611 /* Look up the binding of the function parameter T in a constexpr
6612 function call context CALL. */
6615 lookup_parameter_binding (const constexpr_call *call, tree t)
6617 tree b = purpose_member (t, call->bindings);
6618 return TREE_VALUE (b);
6621 /* Attempt to evaluate T which represents a call to a builtin function.
6622 We assume here that all builtin functions evaluate to scalar types
6623 represented by _CST nodes. */
6626 cxx_eval_builtin_function_call (const constexpr_call *call, tree t,
6627 bool allow_non_constant, bool addr,
6628 bool *non_constant_p, bool *overflow_p)
6630 const int nargs = call_expr_nargs (t);
6631 tree *args = (tree *) alloca (nargs * sizeof (tree));
6634 for (i = 0; i < nargs; ++i)
6636 args[i] = cxx_eval_constant_expression (call, CALL_EXPR_ARG (t, i),
6637 allow_non_constant, addr,
6638 non_constant_p, overflow_p);
6639 if (allow_non_constant && *non_constant_p)
6642 if (*non_constant_p)
6644 new_call = build_call_array_loc (EXPR_LOCATION (t), TREE_TYPE (t),
6645 CALL_EXPR_FN (t), nargs, args);
6646 new_call = fold (new_call);
6647 VERIFY_CONSTANT (new_call);
6651 /* TEMP is the constant value of a temporary object of type TYPE. Adjust
6652 the type of the value to match. */
6655 adjust_temp_type (tree type, tree temp)
6657 if (TREE_TYPE (temp) == type)
6659 /* Avoid wrapping an aggregate value in a NOP_EXPR. */
6660 if (TREE_CODE (temp) == CONSTRUCTOR)
6661 return build_constructor (type, CONSTRUCTOR_ELTS (temp));
6662 gcc_assert (scalarish_type_p (type));
6663 return cp_fold_convert (type, temp);
6666 /* Subroutine of cxx_eval_call_expression.
6667 We are processing a call expression (either CALL_EXPR or
6668 AGGR_INIT_EXPR) in the call context of OLD_CALL. Evaluate
6669 all arguments and bind their values to correspondings
6670 parameters, making up the NEW_CALL context. */
6673 cxx_bind_parameters_in_call (const constexpr_call *old_call, tree t,
6674 constexpr_call *new_call,
6675 bool allow_non_constant,
6676 bool *non_constant_p, bool *overflow_p)
6678 const int nargs = call_expr_nargs (t);
6679 tree fun = new_call->fundef->decl;
6680 tree parms = DECL_ARGUMENTS (fun);
6682 for (i = 0; i < nargs; ++i)
6685 tree type = parms ? TREE_TYPE (parms) : void_type_node;
6686 /* For member function, the first argument is a pointer to the implied
6687 object. And for an object contruction, don't bind `this' before
6688 it is fully constructed. */
6689 if (i == 0 && DECL_CONSTRUCTOR_P (fun))
6691 x = get_nth_callarg (t, i);
6692 if (parms && DECL_BY_REFERENCE (parms))
6694 /* cp_genericize made this a reference for argument passing, but
6695 we don't want to treat it like one for constexpr evaluation. */
6696 gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
6697 gcc_assert (TREE_CODE (TREE_TYPE (x)) == REFERENCE_TYPE);
6698 type = TREE_TYPE (type);
6699 x = convert_from_reference (x);
6701 arg = cxx_eval_constant_expression (old_call, x, allow_non_constant,
6702 TREE_CODE (type) == REFERENCE_TYPE,
6703 non_constant_p, overflow_p);
6704 /* Don't VERIFY_CONSTANT here. */
6705 if (*non_constant_p && allow_non_constant)
6707 /* Just discard ellipsis args after checking their constantitude. */
6710 if (*non_constant_p)
6711 /* Don't try to adjust the type of non-constant args. */
6714 /* Make sure the binding has the same type as the parm. */
6715 if (TREE_CODE (type) != REFERENCE_TYPE)
6716 arg = adjust_temp_type (type, arg);
6717 new_call->bindings = tree_cons (parms, arg, new_call->bindings);
6719 parms = TREE_CHAIN (parms);
6723 /* Variables and functions to manage constexpr call expansion context.
6724 These do not need to be marked for PCH or GC. */
6726 /* FIXME remember and print actual constant arguments. */
6727 static vec<tree> call_stack = vNULL;
6728 static int call_stack_tick;
6729 static int last_cx_error_tick;
6732 push_cx_call_context (tree call)
6735 if (!EXPR_HAS_LOCATION (call))
6736 SET_EXPR_LOCATION (call, input_location);
6737 call_stack.safe_push (call);
6738 if (call_stack.length () > (unsigned) max_constexpr_depth)
6744 pop_cx_call_context (void)
6751 cx_error_context (void)
6753 vec<tree> r = vNULL;
6754 if (call_stack_tick != last_cx_error_tick
6755 && !call_stack.is_empty ())
6757 last_cx_error_tick = call_stack_tick;
6761 /* Subroutine of cxx_eval_constant_expression.
6762 Evaluate the call expression tree T in the context of OLD_CALL expression
6766 cxx_eval_call_expression (const constexpr_call *old_call, tree t,
6767 bool allow_non_constant, bool addr,
6768 bool *non_constant_p, bool *overflow_p)
6770 location_t loc = EXPR_LOC_OR_HERE (t);
6771 tree fun = get_function_named_in_call (t);
6773 constexpr_call new_call = { NULL, NULL, NULL, 0 };
6774 constexpr_call **slot;
6775 constexpr_call *entry;
6778 if (TREE_CODE (fun) != FUNCTION_DECL)
6780 /* Might be a constexpr function pointer. */
6781 fun = cxx_eval_constant_expression (old_call, fun, allow_non_constant,
6782 /*addr*/false, non_constant_p, overflow_p);
6783 if (TREE_CODE (fun) == ADDR_EXPR)
6784 fun = TREE_OPERAND (fun, 0);
6786 if (TREE_CODE (fun) != FUNCTION_DECL)
6788 if (!allow_non_constant && !*non_constant_p)
6789 error_at (loc, "expression %qE does not designate a constexpr "
6791 *non_constant_p = true;
6794 if (DECL_CLONED_FUNCTION_P (fun))
6795 fun = DECL_CLONED_FUNCTION (fun);
6796 if (is_builtin_fn (fun))
6797 return cxx_eval_builtin_function_call (old_call, t, allow_non_constant,
6798 addr, non_constant_p, overflow_p);
6799 if (!DECL_DECLARED_CONSTEXPR_P (fun))
6801 if (!allow_non_constant)
6803 error_at (loc, "call to non-constexpr function %qD", fun);
6804 explain_invalid_constexpr_fn (fun);
6806 *non_constant_p = true;
6810 /* Shortcut trivial copy constructor/op=. */
6811 if (call_expr_nargs (t) == 2 && trivial_fn_p (fun))
6813 tree arg = convert_from_reference (get_nth_callarg (t, 1));
6814 return cxx_eval_constant_expression (old_call, arg, allow_non_constant,
6815 addr, non_constant_p, overflow_p);
6818 /* If in direct recursive call, optimize definition search. */
6819 if (old_call != NULL && old_call->fundef->decl == fun)
6820 new_call.fundef = old_call->fundef;
6823 new_call.fundef = retrieve_constexpr_fundef (fun);
6824 if (new_call.fundef == NULL || new_call.fundef->body == NULL)
6826 if (!allow_non_constant)
6828 if (DECL_INITIAL (fun))
6830 /* The definition of fun was somehow unsuitable. */
6831 error_at (loc, "%qD called in a constant expression", fun);
6832 explain_invalid_constexpr_fn (fun);
6835 error_at (loc, "%qD used before its definition", fun);
6837 *non_constant_p = true;
6841 cxx_bind_parameters_in_call (old_call, t, &new_call,
6842 allow_non_constant, non_constant_p, overflow_p);
6843 if (*non_constant_p)
6846 depth_ok = push_cx_call_context (t);
6849 = iterative_hash_template_arg (new_call.bindings,
6850 constexpr_fundef_hash (new_call.fundef));
6852 /* If we have seen this call before, we are done. */
6853 maybe_initialize_constexpr_call_table ();
6854 slot = (constexpr_call **)
6855 htab_find_slot (constexpr_call_table, &new_call, INSERT);
6859 /* We need to keep a pointer to the entry, not just the slot, as the
6860 slot can move in the call to cxx_eval_builtin_function_call. */
6861 *slot = entry = ggc_alloc_constexpr_call ();
6864 /* Calls which are in progress have their result set to NULL
6865 so that we can detect circular dependencies. */
6866 else if (entry->result == NULL)
6868 if (!allow_non_constant)
6869 error ("call has circular dependency");
6870 *non_constant_p = true;
6871 entry->result = result = error_mark_node;
6876 if (!allow_non_constant)
6877 error ("constexpr evaluation depth exceeds maximum of %d (use "
6878 "-fconstexpr-depth= to increase the maximum)",
6879 max_constexpr_depth);
6880 *non_constant_p = true;
6881 entry->result = result = error_mark_node;
6885 result = entry->result;
6886 if (!result || result == error_mark_node)
6887 result = (cxx_eval_constant_expression
6888 (&new_call, new_call.fundef->body,
6889 allow_non_constant, addr,
6890 non_constant_p, overflow_p));
6891 if (result == error_mark_node)
6892 *non_constant_p = true;
6893 if (*non_constant_p)
6894 entry->result = result = error_mark_node;
6897 /* If this was a call to initialize an object, set the type of
6898 the CONSTRUCTOR to the type of that object. */
6899 if (DECL_CONSTRUCTOR_P (fun))
6901 tree ob_arg = get_nth_callarg (t, 0);
6902 STRIP_NOPS (ob_arg);
6903 gcc_assert (TYPE_PTR_P (TREE_TYPE (ob_arg))
6904 && CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (ob_arg))));
6905 result = adjust_temp_type (TREE_TYPE (TREE_TYPE (ob_arg)),
6908 entry->result = result;
6912 pop_cx_call_context ();
6913 return unshare_expr (result);
6916 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
6919 reduced_constant_expression_p (tree t)
6921 if (TREE_CODE (t) == PTRMEM_CST)
6922 /* Even if we can't lower this yet, it's constant. */
6924 /* FIXME are we calling this too much? */
6925 return initializer_constant_valid_p (t, TREE_TYPE (t)) != NULL_TREE;
6928 /* Some expressions may have constant operands but are not constant
6929 themselves, such as 1/0. Call this function (or rather, the macro
6930 following it) to check for that condition.
6932 We only call this in places that require an arithmetic constant, not in
6933 places where we might have a non-constant expression that can be a
6934 component of a constant expression, such as the address of a constexpr
6935 variable that might be dereferenced later. */
6938 verify_constant (tree t, bool allow_non_constant, bool *non_constant_p,
6941 if (!*non_constant_p && !reduced_constant_expression_p (t))
6943 if (!allow_non_constant)
6944 error ("%q+E is not a constant expression", t);
6945 *non_constant_p = true;
6947 if (TREE_OVERFLOW_P (t))
6949 if (!allow_non_constant)
6951 permerror (input_location, "overflow in constant expression");
6952 /* If we're being permissive (and are in an enforcing
6953 context), ignore the overflow. */
6954 if (flag_permissive)
6955 return *non_constant_p;
6959 return *non_constant_p;
6962 /* Subroutine of cxx_eval_constant_expression.
6963 Attempt to reduce the unary expression tree T to a compile time value.
6964 If successful, return the value. Otherwise issue a diagnostic
6965 and return error_mark_node. */
6968 cxx_eval_unary_expression (const constexpr_call *call, tree t,
6969 bool allow_non_constant, bool addr,
6970 bool *non_constant_p, bool *overflow_p)
6973 tree orig_arg = TREE_OPERAND (t, 0);
6974 tree arg = cxx_eval_constant_expression (call, orig_arg, allow_non_constant,
6975 addr, non_constant_p, overflow_p);
6976 VERIFY_CONSTANT (arg);
6977 if (arg == orig_arg)
6979 r = fold_build1 (TREE_CODE (t), TREE_TYPE (t), arg);
6980 VERIFY_CONSTANT (r);
6984 /* Subroutine of cxx_eval_constant_expression.
6985 Like cxx_eval_unary_expression, except for binary expressions. */
6988 cxx_eval_binary_expression (const constexpr_call *call, tree t,
6989 bool allow_non_constant, bool addr,
6990 bool *non_constant_p, bool *overflow_p)
6993 tree orig_lhs = TREE_OPERAND (t, 0);
6994 tree orig_rhs = TREE_OPERAND (t, 1);
6996 lhs = cxx_eval_constant_expression (call, orig_lhs,
6997 allow_non_constant, addr,
6998 non_constant_p, overflow_p);
6999 VERIFY_CONSTANT (lhs);
7000 rhs = cxx_eval_constant_expression (call, orig_rhs,
7001 allow_non_constant, addr,
7002 non_constant_p, overflow_p);
7003 VERIFY_CONSTANT (rhs);
7004 if (lhs == orig_lhs && rhs == orig_rhs)
7006 r = fold_build2 (TREE_CODE (t), TREE_TYPE (t), lhs, rhs);
7007 VERIFY_CONSTANT (r);
7011 /* Subroutine of cxx_eval_constant_expression.
7012 Attempt to evaluate condition expressions. Dead branches are not
7016 cxx_eval_conditional_expression (const constexpr_call *call, tree t,
7017 bool allow_non_constant, bool addr,
7018 bool *non_constant_p, bool *overflow_p)
7020 tree val = cxx_eval_constant_expression (call, TREE_OPERAND (t, 0),
7021 allow_non_constant, addr,
7022 non_constant_p, overflow_p);
7023 VERIFY_CONSTANT (val);
7024 /* Don't VERIFY_CONSTANT the other operands. */
7025 if (integer_zerop (val))
7026 return cxx_eval_constant_expression (call, TREE_OPERAND (t, 2),
7027 allow_non_constant, addr,
7028 non_constant_p, overflow_p);
7029 return cxx_eval_constant_expression (call, TREE_OPERAND (t, 1),
7030 allow_non_constant, addr,
7031 non_constant_p, overflow_p);
7034 /* Subroutine of cxx_eval_constant_expression.
7035 Attempt to reduce a reference to an array slot. */
7038 cxx_eval_array_reference (const constexpr_call *call, tree t,
7039 bool allow_non_constant, bool addr,
7040 bool *non_constant_p, bool *overflow_p)
7042 tree oldary = TREE_OPERAND (t, 0);
7043 tree ary = cxx_eval_constant_expression (call, oldary,
7044 allow_non_constant, addr,
7045 non_constant_p, overflow_p);
7049 unsigned len, elem_nchars = 1;
7050 if (*non_constant_p)
7052 oldidx = TREE_OPERAND (t, 1);
7053 index = cxx_eval_constant_expression (call, oldidx,
7054 allow_non_constant, false,
7055 non_constant_p, overflow_p);
7056 VERIFY_CONSTANT (index);
7057 if (addr && ary == oldary && index == oldidx)
7060 return build4 (ARRAY_REF, TREE_TYPE (t), ary, index, NULL, NULL);
7061 elem_type = TREE_TYPE (TREE_TYPE (ary));
7062 if (TREE_CODE (ary) == CONSTRUCTOR)
7063 len = CONSTRUCTOR_NELTS (ary);
7064 else if (TREE_CODE (ary) == STRING_CST)
7066 elem_nchars = (TYPE_PRECISION (elem_type)
7067 / TYPE_PRECISION (char_type_node));
7068 len = (unsigned) TREE_STRING_LENGTH (ary) / elem_nchars;
7072 /* We can't do anything with other tree codes, so use
7073 VERIFY_CONSTANT to complain and fail. */
7074 VERIFY_CONSTANT (ary);
7077 if (compare_tree_int (index, len) >= 0)
7079 if (tree_int_cst_lt (index, array_type_nelts_top (TREE_TYPE (ary))))
7081 /* If it's within the array bounds but doesn't have an explicit
7082 initializer, it's value-initialized. */
7083 tree val = build_value_init (elem_type, tf_warning_or_error);
7084 return cxx_eval_constant_expression (call, val,
7085 allow_non_constant, addr,
7086 non_constant_p, overflow_p);
7089 if (!allow_non_constant)
7090 error ("array subscript out of bound");
7091 *non_constant_p = true;
7094 else if (tree_int_cst_lt (index, integer_zero_node))
7096 if (!allow_non_constant)
7097 error ("negative array subscript");
7098 *non_constant_p = true;
7101 i = tree_low_cst (index, 0);
7102 if (TREE_CODE (ary) == CONSTRUCTOR)
7103 return (*CONSTRUCTOR_ELTS (ary))[i].value;
7104 else if (elem_nchars == 1)
7105 return build_int_cst (cv_unqualified (TREE_TYPE (TREE_TYPE (ary))),
7106 TREE_STRING_POINTER (ary)[i]);
7109 tree type = cv_unqualified (TREE_TYPE (TREE_TYPE (ary)));
7110 return native_interpret_expr (type, (const unsigned char *)
7111 TREE_STRING_POINTER (ary)
7112 + i * elem_nchars, elem_nchars);
7114 /* Don't VERIFY_CONSTANT here. */
7117 /* Subroutine of cxx_eval_constant_expression.
7118 Attempt to reduce a field access of a value of class type. */
7121 cxx_eval_component_reference (const constexpr_call *call, tree t,
7122 bool allow_non_constant, bool addr,
7123 bool *non_constant_p, bool *overflow_p)
7125 unsigned HOST_WIDE_INT i;
7128 tree part = TREE_OPERAND (t, 1);
7129 tree orig_whole = TREE_OPERAND (t, 0);
7130 tree whole = cxx_eval_constant_expression (call, orig_whole,
7131 allow_non_constant, addr,
7132 non_constant_p, overflow_p);
7133 if (whole == orig_whole)
7136 return fold_build3 (COMPONENT_REF, TREE_TYPE (t),
7137 whole, part, NULL_TREE);
7138 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
7140 if (!*non_constant_p && TREE_CODE (whole) != CONSTRUCTOR)
7142 if (!allow_non_constant)
7143 error ("%qE is not a constant expression", orig_whole);
7144 *non_constant_p = true;
7146 if (DECL_MUTABLE_P (part))
7148 if (!allow_non_constant)
7149 error ("mutable %qD is not usable in a constant expression", part);
7150 *non_constant_p = true;
7152 if (*non_constant_p)
7154 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole), i, field, value)
7159 if (TREE_CODE (TREE_TYPE (whole)) == UNION_TYPE
7160 && CONSTRUCTOR_NELTS (whole) > 0)
7162 /* DR 1188 says we don't have to deal with this. */
7163 if (!allow_non_constant)
7164 error ("accessing %qD member instead of initialized %qD member in "
7165 "constant expression", part, CONSTRUCTOR_ELT (whole, 0)->index);
7166 *non_constant_p = true;
7170 /* If there's no explicit init for this field, it's value-initialized. */
7171 value = build_value_init (TREE_TYPE (t), tf_warning_or_error);
7172 return cxx_eval_constant_expression (call, value,
7173 allow_non_constant, addr,
7174 non_constant_p, overflow_p);
7177 /* Subroutine of cxx_eval_constant_expression.
7178 Attempt to reduce a field access of a value of class type that is
7179 expressed as a BIT_FIELD_REF. */
7182 cxx_eval_bit_field_ref (const constexpr_call *call, tree t,
7183 bool allow_non_constant, bool addr,
7184 bool *non_constant_p, bool *overflow_p)
7186 tree orig_whole = TREE_OPERAND (t, 0);
7187 tree retval, fldval, utype, mask;
7188 bool fld_seen = false;
7189 HOST_WIDE_INT istart, isize;
7190 tree whole = cxx_eval_constant_expression (call, orig_whole,
7191 allow_non_constant, addr,
7192 non_constant_p, overflow_p);
7193 tree start, field, value;
7194 unsigned HOST_WIDE_INT i;
7196 if (whole == orig_whole)
7198 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
7200 if (!*non_constant_p
7201 && TREE_CODE (whole) != VECTOR_CST
7202 && TREE_CODE (whole) != CONSTRUCTOR)
7204 if (!allow_non_constant)
7205 error ("%qE is not a constant expression", orig_whole);
7206 *non_constant_p = true;
7208 if (*non_constant_p)
7211 if (TREE_CODE (whole) == VECTOR_CST)
7212 return fold_ternary (BIT_FIELD_REF, TREE_TYPE (t), whole,
7213 TREE_OPERAND (t, 1), TREE_OPERAND (t, 2));
7215 start = TREE_OPERAND (t, 2);
7216 istart = tree_low_cst (start, 0);
7217 isize = tree_low_cst (TREE_OPERAND (t, 1), 0);
7218 utype = TREE_TYPE (t);
7219 if (!TYPE_UNSIGNED (utype))
7220 utype = build_nonstandard_integer_type (TYPE_PRECISION (utype), 1);
7221 retval = build_int_cst (utype, 0);
7222 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole), i, field, value)
7224 tree bitpos = bit_position (field);
7225 if (bitpos == start && DECL_SIZE (field) == TREE_OPERAND (t, 1))
7227 if (TREE_CODE (TREE_TYPE (field)) == INTEGER_TYPE
7228 && TREE_CODE (value) == INTEGER_CST
7229 && host_integerp (bitpos, 0)
7230 && host_integerp (DECL_SIZE (field), 0))
7232 HOST_WIDE_INT bit = tree_low_cst (bitpos, 0);
7233 HOST_WIDE_INT sz = tree_low_cst (DECL_SIZE (field), 0);
7234 HOST_WIDE_INT shift;
7235 if (bit >= istart && bit + sz <= istart + isize)
7237 fldval = fold_convert (utype, value);
7238 mask = build_int_cst_type (utype, -1);
7239 mask = fold_build2 (LSHIFT_EXPR, utype, mask,
7240 size_int (TYPE_PRECISION (utype) - sz));
7241 mask = fold_build2 (RSHIFT_EXPR, utype, mask,
7242 size_int (TYPE_PRECISION (utype) - sz));
7243 fldval = fold_build2 (BIT_AND_EXPR, utype, fldval, mask);
7244 shift = bit - istart;
7245 if (BYTES_BIG_ENDIAN)
7246 shift = TYPE_PRECISION (utype) - shift - sz;
7247 fldval = fold_build2 (LSHIFT_EXPR, utype, fldval,
7249 retval = fold_build2 (BIT_IOR_EXPR, utype, retval, fldval);
7255 return fold_convert (TREE_TYPE (t), retval);
7257 return error_mark_node;
7260 /* Subroutine of cxx_eval_constant_expression.
7261 Evaluate a short-circuited logical expression T in the context
7262 of a given constexpr CALL. BAILOUT_VALUE is the value for
7263 early return. CONTINUE_VALUE is used here purely for
7264 sanity check purposes. */
7267 cxx_eval_logical_expression (const constexpr_call *call, tree t,
7268 tree bailout_value, tree continue_value,
7269 bool allow_non_constant, bool addr,
7270 bool *non_constant_p, bool *overflow_p)
7273 tree lhs = cxx_eval_constant_expression (call, TREE_OPERAND (t, 0),
7274 allow_non_constant, addr,
7275 non_constant_p, overflow_p);
7276 VERIFY_CONSTANT (lhs);
7277 if (tree_int_cst_equal (lhs, bailout_value))
7279 gcc_assert (tree_int_cst_equal (lhs, continue_value));
7280 r = cxx_eval_constant_expression (call, TREE_OPERAND (t, 1),
7281 allow_non_constant, addr, non_constant_p, overflow_p);
7282 VERIFY_CONSTANT (r);
7286 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
7287 CONSTRUCTOR elements to initialize (part of) an object containing that
7288 field. Return a pointer to the constructor_elt corresponding to the
7289 initialization of the field. */
7291 static constructor_elt *
7292 base_field_constructor_elt (vec<constructor_elt, va_gc> *v, tree ref)
7294 tree aggr = TREE_OPERAND (ref, 0);
7295 tree field = TREE_OPERAND (ref, 1);
7297 constructor_elt *ce;
7299 gcc_assert (TREE_CODE (ref) == COMPONENT_REF);
7301 if (TREE_CODE (aggr) == COMPONENT_REF)
7303 constructor_elt *base_ce
7304 = base_field_constructor_elt (v, aggr);
7305 v = CONSTRUCTOR_ELTS (base_ce->value);
7308 for (i = 0; vec_safe_iterate (v, i, &ce); ++i)
7309 if (ce->index == field)
7316 /* Subroutine of cxx_eval_constant_expression.
7317 The expression tree T denotes a C-style array or a C-style
7318 aggregate. Reduce it to a constant expression. */
7321 cxx_eval_bare_aggregate (const constexpr_call *call, tree t,
7322 bool allow_non_constant, bool addr,
7323 bool *non_constant_p, bool *overflow_p)
7325 vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (t);
7326 vec<constructor_elt, va_gc> *n;
7327 vec_alloc (n, vec_safe_length (v));
7328 constructor_elt *ce;
7330 bool changed = false;
7331 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t));
7332 for (i = 0; vec_safe_iterate (v, i, &ce); ++i)
7334 tree elt = cxx_eval_constant_expression (call, ce->value,
7335 allow_non_constant, addr,
7336 non_constant_p, overflow_p);
7337 /* Don't VERIFY_CONSTANT here. */
7338 if (allow_non_constant && *non_constant_p)
7340 if (elt != ce->value)
7342 if (ce->index && TREE_CODE (ce->index) == COMPONENT_REF)
7344 /* This is an initialization of a vfield inside a base
7345 subaggregate that we already initialized; push this
7346 initialization into the previous initialization. */
7347 constructor_elt *inner = base_field_constructor_elt (n, ce->index);
7350 else if (ce->index && TREE_CODE (ce->index) == NOP_EXPR)
7352 /* This is an initializer for an empty base; now that we've
7353 checked that it's constant, we can ignore it. */
7354 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (ce->index))));
7357 CONSTRUCTOR_APPEND_ELT (n, ce->index, elt);
7359 if (*non_constant_p || !changed)
7365 t = build_constructor (TREE_TYPE (t), n);
7366 TREE_CONSTANT (t) = true;
7367 if (TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
7372 /* Subroutine of cxx_eval_constant_expression.
7373 The expression tree T is a VEC_INIT_EXPR which denotes the desired
7374 initialization of a non-static data member of array type. Reduce it to a
7377 Note that apart from value-initialization (when VALUE_INIT is true),
7378 this is only intended to support value-initialization and the
7379 initializations done by defaulted constructors for classes with
7380 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
7381 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
7382 for the copy/move constructor. */
7385 cxx_eval_vec_init_1 (const constexpr_call *call, tree atype, tree init,
7386 bool value_init, bool allow_non_constant, bool addr,
7387 bool *non_constant_p, bool *overflow_p)
7389 tree elttype = TREE_TYPE (atype);
7390 int max = tree_low_cst (array_type_nelts (atype), 0);
7391 vec<constructor_elt, va_gc> *n;
7392 vec_alloc (n, max + 1);
7393 bool pre_init = false;
7396 /* For the default constructor, build up a call to the default
7397 constructor of the element type. We only need to handle class types
7398 here, as for a constructor to be constexpr, all members must be
7399 initialized, which for a defaulted default constructor means they must
7400 be of a class type with a constexpr default constructor. */
7401 if (TREE_CODE (elttype) == ARRAY_TYPE)
7402 /* We only do this at the lowest level. */;
7403 else if (value_init)
7405 init = build_value_init (elttype, tf_warning_or_error);
7406 init = cxx_eval_constant_expression
7407 (call, init, allow_non_constant, addr, non_constant_p, overflow_p);
7412 vec<tree, va_gc> *argvec = make_tree_vector ();
7413 init = build_special_member_call (NULL_TREE, complete_ctor_identifier,
7414 &argvec, elttype, LOOKUP_NORMAL,
7415 tf_warning_or_error);
7416 release_tree_vector (argvec);
7417 init = cxx_eval_constant_expression (call, init, allow_non_constant,
7418 addr, non_constant_p, overflow_p);
7422 if (*non_constant_p && !allow_non_constant)
7425 for (i = 0; i <= max; ++i)
7427 tree idx = build_int_cst (size_type_node, i);
7429 if (TREE_CODE (elttype) == ARRAY_TYPE)
7431 /* A multidimensional array; recurse. */
7432 if (value_init || init == NULL_TREE)
7433 eltinit = NULL_TREE;
7435 eltinit = cp_build_array_ref (input_location, init, idx,
7436 tf_warning_or_error);
7437 eltinit = cxx_eval_vec_init_1 (call, elttype, eltinit, value_init,
7438 allow_non_constant, addr,
7439 non_constant_p, overflow_p);
7443 /* Initializing an element using value or default initialization
7444 we just pre-built above. */
7448 eltinit = unshare_expr (init);
7452 /* Copying an element. */
7453 vec<tree, va_gc> *argvec;
7454 gcc_assert (same_type_ignoring_top_level_qualifiers_p
7455 (atype, TREE_TYPE (init)));
7456 eltinit = cp_build_array_ref (input_location, init, idx,
7457 tf_warning_or_error);
7458 if (!real_lvalue_p (init))
7459 eltinit = move (eltinit);
7460 argvec = make_tree_vector ();
7461 argvec->quick_push (eltinit);
7462 eltinit = (build_special_member_call
7463 (NULL_TREE, complete_ctor_identifier, &argvec,
7464 elttype, LOOKUP_NORMAL, tf_warning_or_error));
7465 release_tree_vector (argvec);
7466 eltinit = cxx_eval_constant_expression
7467 (call, eltinit, allow_non_constant, addr, non_constant_p, overflow_p);
7469 if (*non_constant_p && !allow_non_constant)
7471 CONSTRUCTOR_APPEND_ELT (n, idx, eltinit);
7474 if (!*non_constant_p)
7476 init = build_constructor (atype, n);
7477 TREE_CONSTANT (init) = true;
7487 cxx_eval_vec_init (const constexpr_call *call, tree t,
7488 bool allow_non_constant, bool addr,
7489 bool *non_constant_p, bool *overflow_p)
7491 tree atype = TREE_TYPE (t);
7492 tree init = VEC_INIT_EXPR_INIT (t);
7493 tree r = cxx_eval_vec_init_1 (call, atype, init,
7494 VEC_INIT_EXPR_VALUE_INIT (t),
7495 allow_non_constant, addr, non_constant_p, overflow_p);
7496 if (*non_constant_p)
7502 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
7503 match. We want to be less strict for simple *& folding; if we have a
7504 non-const temporary that we access through a const pointer, that should
7505 work. We handle this here rather than change fold_indirect_ref_1
7506 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
7507 don't really make sense outside of constant expression evaluation. Also
7508 we want to allow folding to COMPONENT_REF, which could cause trouble
7509 with TBAA in fold_indirect_ref_1.
7511 Try to keep this function synced with fold_indirect_ref_1. */
7514 cxx_fold_indirect_ref (location_t loc, tree type, tree op0, bool *empty_base)
7520 subtype = TREE_TYPE (sub);
7521 if (!POINTER_TYPE_P (subtype))
7524 if (TREE_CODE (sub) == ADDR_EXPR)
7526 tree op = TREE_OPERAND (sub, 0);
7527 tree optype = TREE_TYPE (op);
7529 /* *&CONST_DECL -> to the value of the const decl. */
7530 if (TREE_CODE (op) == CONST_DECL)
7531 return DECL_INITIAL (op);
7532 /* *&p => p; make sure to handle *&"str"[cst] here. */
7533 if (same_type_ignoring_top_level_qualifiers_p (optype, type))
7535 tree fop = fold_read_from_constant_string (op);
7541 /* *(foo *)&fooarray => fooarray[0] */
7542 else if (TREE_CODE (optype) == ARRAY_TYPE
7543 && (same_type_ignoring_top_level_qualifiers_p
7544 (type, TREE_TYPE (optype))))
7546 tree type_domain = TYPE_DOMAIN (optype);
7547 tree min_val = size_zero_node;
7548 if (type_domain && TYPE_MIN_VALUE (type_domain))
7549 min_val = TYPE_MIN_VALUE (type_domain);
7550 return build4_loc (loc, ARRAY_REF, type, op, min_val,
7551 NULL_TREE, NULL_TREE);
7553 /* *(foo *)&complexfoo => __real__ complexfoo */
7554 else if (TREE_CODE (optype) == COMPLEX_TYPE
7555 && (same_type_ignoring_top_level_qualifiers_p
7556 (type, TREE_TYPE (optype))))
7557 return fold_build1_loc (loc, REALPART_EXPR, type, op);
7558 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
7559 else if (TREE_CODE (optype) == VECTOR_TYPE
7560 && (same_type_ignoring_top_level_qualifiers_p
7561 (type, TREE_TYPE (optype))))
7563 tree part_width = TYPE_SIZE (type);
7564 tree index = bitsize_int (0);
7565 return fold_build3_loc (loc, BIT_FIELD_REF, type, op, part_width, index);
7567 /* Also handle conversion to an empty base class, which
7568 is represented with a NOP_EXPR. */
7569 else if (is_empty_class (type)
7570 && CLASS_TYPE_P (optype)
7571 && DERIVED_FROM_P (type, optype))
7576 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
7577 else if (RECORD_OR_UNION_TYPE_P (optype))
7579 tree field = TYPE_FIELDS (optype);
7580 for (; field; field = DECL_CHAIN (field))
7581 if (TREE_CODE (field) == FIELD_DECL
7582 && integer_zerop (byte_position (field))
7583 && (same_type_ignoring_top_level_qualifiers_p
7584 (TREE_TYPE (field), type)))
7586 return fold_build3 (COMPONENT_REF, type, op, field, NULL_TREE);
7591 else if (TREE_CODE (sub) == POINTER_PLUS_EXPR
7592 && TREE_CODE (TREE_OPERAND (sub, 1)) == INTEGER_CST)
7594 tree op00 = TREE_OPERAND (sub, 0);
7595 tree op01 = TREE_OPERAND (sub, 1);
7598 if (TREE_CODE (op00) == ADDR_EXPR)
7601 op00 = TREE_OPERAND (op00, 0);
7602 op00type = TREE_TYPE (op00);
7604 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
7605 if (TREE_CODE (op00type) == VECTOR_TYPE
7606 && (same_type_ignoring_top_level_qualifiers_p
7607 (type, TREE_TYPE (op00type))))
7609 HOST_WIDE_INT offset = tree_low_cst (op01, 0);
7610 tree part_width = TYPE_SIZE (type);
7611 unsigned HOST_WIDE_INT part_widthi = tree_low_cst (part_width, 0)/BITS_PER_UNIT;
7612 unsigned HOST_WIDE_INT indexi = offset * BITS_PER_UNIT;
7613 tree index = bitsize_int (indexi);
7615 if (offset/part_widthi <= TYPE_VECTOR_SUBPARTS (op00type))
7616 return fold_build3_loc (loc,
7617 BIT_FIELD_REF, type, op00,
7621 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
7622 else if (TREE_CODE (op00type) == COMPLEX_TYPE
7623 && (same_type_ignoring_top_level_qualifiers_p
7624 (type, TREE_TYPE (op00type))))
7626 tree size = TYPE_SIZE_UNIT (type);
7627 if (tree_int_cst_equal (size, op01))
7628 return fold_build1_loc (loc, IMAGPART_EXPR, type, op00);
7630 /* ((foo *)&fooarray)[1] => fooarray[1] */
7631 else if (TREE_CODE (op00type) == ARRAY_TYPE
7632 && (same_type_ignoring_top_level_qualifiers_p
7633 (type, TREE_TYPE (op00type))))
7635 tree type_domain = TYPE_DOMAIN (op00type);
7636 tree min_val = size_zero_node;
7637 if (type_domain && TYPE_MIN_VALUE (type_domain))
7638 min_val = TYPE_MIN_VALUE (type_domain);
7639 op01 = size_binop_loc (loc, EXACT_DIV_EXPR, op01,
7640 TYPE_SIZE_UNIT (type));
7641 op01 = size_binop_loc (loc, PLUS_EXPR, op01, min_val);
7642 return build4_loc (loc, ARRAY_REF, type, op00, op01,
7643 NULL_TREE, NULL_TREE);
7645 /* Also handle conversion to an empty base class, which
7646 is represented with a NOP_EXPR. */
7647 else if (is_empty_class (type)
7648 && CLASS_TYPE_P (op00type)
7649 && DERIVED_FROM_P (type, op00type))
7654 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
7655 else if (RECORD_OR_UNION_TYPE_P (op00type))
7657 tree field = TYPE_FIELDS (op00type);
7658 for (; field; field = DECL_CHAIN (field))
7659 if (TREE_CODE (field) == FIELD_DECL
7660 && tree_int_cst_equal (byte_position (field), op01)
7661 && (same_type_ignoring_top_level_qualifiers_p
7662 (TREE_TYPE (field), type)))
7664 return fold_build3 (COMPONENT_REF, type, op00,
7671 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
7672 else if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE
7673 && (same_type_ignoring_top_level_qualifiers_p
7674 (type, TREE_TYPE (TREE_TYPE (subtype)))))
7677 tree min_val = size_zero_node;
7678 tree newsub = cxx_fold_indirect_ref (loc, TREE_TYPE (subtype), sub, NULL);
7682 sub = build1_loc (loc, INDIRECT_REF, TREE_TYPE (subtype), sub);
7683 type_domain = TYPE_DOMAIN (TREE_TYPE (sub));
7684 if (type_domain && TYPE_MIN_VALUE (type_domain))
7685 min_val = TYPE_MIN_VALUE (type_domain);
7686 return build4_loc (loc, ARRAY_REF, type, sub, min_val, NULL_TREE,
7694 cxx_eval_indirect_ref (const constexpr_call *call, tree t,
7695 bool allow_non_constant, bool addr,
7696 bool *non_constant_p, bool *overflow_p)
7698 tree orig_op0 = TREE_OPERAND (t, 0);
7699 tree op0 = cxx_eval_constant_expression (call, orig_op0, allow_non_constant,
7700 /*addr*/false, non_constant_p, overflow_p);
7701 bool empty_base = false;
7704 /* Don't VERIFY_CONSTANT here. */
7705 if (*non_constant_p)
7708 r = cxx_fold_indirect_ref (EXPR_LOCATION (t), TREE_TYPE (t), op0,
7712 r = cxx_eval_constant_expression (call, r, allow_non_constant,
7713 addr, non_constant_p, overflow_p);
7718 if (TREE_CODE (sub) == ADDR_EXPR)
7720 /* We couldn't fold to a constant value. Make sure it's not
7721 something we should have been able to fold. */
7722 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
7723 (TREE_TYPE (TREE_TYPE (sub)), TREE_TYPE (t)));
7724 /* DR 1188 says we don't have to deal with this. */
7725 if (!allow_non_constant)
7726 error ("accessing value of %qE through a %qT glvalue in a "
7727 "constant expression", build_fold_indirect_ref (sub),
7729 *non_constant_p = true;
7734 /* If we're pulling out the value of an empty base, make sure
7735 that the whole object is constant and then return an empty
7739 VERIFY_CONSTANT (r);
7740 r = build_constructor (TREE_TYPE (t), NULL);
7741 TREE_CONSTANT (r) = true;
7746 if (addr && op0 != orig_op0)
7747 return build1 (INDIRECT_REF, TREE_TYPE (t), op0);
7749 VERIFY_CONSTANT (t);
7755 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
7756 Shared between potential_constant_expression and
7757 cxx_eval_constant_expression. */
7760 non_const_var_error (tree r)
7762 tree type = TREE_TYPE (r);
7763 error ("the value of %qD is not usable in a constant "
7765 /* Avoid error cascade. */
7766 if (DECL_INITIAL (r) == error_mark_node)
7768 if (DECL_DECLARED_CONSTEXPR_P (r))
7769 inform (DECL_SOURCE_LOCATION (r),
7770 "%qD used in its own initializer", r);
7771 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type))
7773 if (!CP_TYPE_CONST_P (type))
7774 inform (DECL_SOURCE_LOCATION (r),
7775 "%q#D is not const", r);
7776 else if (CP_TYPE_VOLATILE_P (type))
7777 inform (DECL_SOURCE_LOCATION (r),
7778 "%q#D is volatile", r);
7779 else if (!DECL_INITIAL (r)
7780 || !TREE_CONSTANT (DECL_INITIAL (r)))
7781 inform (DECL_SOURCE_LOCATION (r),
7782 "%qD was not initialized with a constant "
7789 if (cxx_dialect >= cxx11 && !DECL_DECLARED_CONSTEXPR_P (r))
7790 inform (DECL_SOURCE_LOCATION (r),
7791 "%qD was not declared %<constexpr%>", r);
7793 inform (DECL_SOURCE_LOCATION (r),
7794 "%qD does not have integral or enumeration type",
7799 /* Subroutine of cxx_eval_constant_expression.
7800 Like cxx_eval_unary_expression, except for trinary expressions. */
7803 cxx_eval_trinary_expression (const constexpr_call *call, tree t,
7804 bool allow_non_constant, bool addr,
7805 bool *non_constant_p, bool *overflow_p)
7811 for (i = 0; i < 3; i++)
7813 args[i] = cxx_eval_constant_expression (call, TREE_OPERAND (t, i),
7814 allow_non_constant, addr,
7815 non_constant_p, overflow_p);
7816 VERIFY_CONSTANT (args[i]);
7819 val = fold_ternary_loc (EXPR_LOCATION (t), TREE_CODE (t), TREE_TYPE (t),
7820 args[0], args[1], args[2]);
7821 if (val == NULL_TREE)
7823 VERIFY_CONSTANT (val);
7827 /* Attempt to reduce the expression T to a constant value.
7828 On failure, issue diagnostic and return error_mark_node. */
7829 /* FIXME unify with c_fully_fold */
7832 cxx_eval_constant_expression (const constexpr_call *call, tree t,
7833 bool allow_non_constant, bool addr,
7834 bool *non_constant_p, bool *overflow_p)
7838 if (t == error_mark_node)
7840 *non_constant_p = true;
7843 if (CONSTANT_CLASS_P (t))
7845 if (TREE_CODE (t) == PTRMEM_CST)
7846 t = cplus_expand_constant (t);
7847 else if (TREE_OVERFLOW (t) && (!flag_permissive || allow_non_constant))
7851 if (TREE_CODE (t) != NOP_EXPR
7852 && reduced_constant_expression_p (t))
7855 switch (TREE_CODE (t))
7860 /* else fall through. */
7862 r = integral_constant_value (t);
7863 if (TREE_CODE (r) == TARGET_EXPR
7864 && TREE_CODE (TARGET_EXPR_INITIAL (r)) == CONSTRUCTOR)
7865 r = TARGET_EXPR_INITIAL (r);
7868 if (!allow_non_constant)
7869 non_const_var_error (r);
7870 *non_constant_p = true;
7880 if (call && DECL_CONTEXT (t) == call->fundef->decl)
7882 if (DECL_ARTIFICIAL (t) && DECL_CONSTRUCTOR_P (DECL_CONTEXT (t)))
7884 if (!allow_non_constant)
7885 sorry ("use of the value of the object being constructed "
7886 "in a constant expression");
7887 *non_constant_p = true;
7890 r = lookup_parameter_binding (call, t);
7893 /* Defer in case this is only used for its type. */;
7896 if (!allow_non_constant)
7897 error ("%qE is not a constant expression", t);
7898 *non_constant_p = true;
7903 case AGGR_INIT_EXPR:
7904 r = cxx_eval_call_expression (call, t, allow_non_constant, addr,
7905 non_constant_p, overflow_p);
7909 if (!literal_type_p (TREE_TYPE (t)))
7911 if (!allow_non_constant)
7913 error ("temporary of non-literal type %qT in a "
7914 "constant expression", TREE_TYPE (t));
7915 explain_non_literal_class (TREE_TYPE (t));
7917 *non_constant_p = true;
7920 /* else fall through. */
7922 /* Pass false for 'addr' because these codes indicate
7923 initialization of a temporary. */
7924 r = cxx_eval_constant_expression (call, TREE_OPERAND (t, 1),
7925 allow_non_constant, false,
7926 non_constant_p, overflow_p);
7927 if (!*non_constant_p)
7928 /* Adjust the type of the result to the type of the temporary. */
7929 r = adjust_temp_type (TREE_TYPE (t), r);
7933 r = cxx_eval_constant_expression (call, TREE_OPERAND (t, 1),
7934 allow_non_constant, addr,
7935 non_constant_p, overflow_p);
7939 case NON_LVALUE_EXPR:
7940 case TRY_CATCH_EXPR:
7941 case CLEANUP_POINT_EXPR:
7942 case MUST_NOT_THROW_EXPR:
7944 r = cxx_eval_constant_expression (call, TREE_OPERAND (t, 0),
7945 allow_non_constant, addr,
7946 non_constant_p, overflow_p);
7949 /* These differ from cxx_eval_unary_expression in that this doesn't
7950 check for a constant operand or result; an address can be
7951 constant without its operand being, and vice versa. */
7953 r = cxx_eval_indirect_ref (call, t, allow_non_constant, addr,
7954 non_constant_p, overflow_p);
7959 tree oldop = TREE_OPERAND (t, 0);
7960 tree op = cxx_eval_constant_expression (call, oldop,
7963 non_constant_p, overflow_p);
7964 /* Don't VERIFY_CONSTANT here. */
7965 if (*non_constant_p)
7967 /* This function does more aggressive folding than fold itself. */
7968 r = build_fold_addr_expr_with_type (op, TREE_TYPE (t));
7969 if (TREE_CODE (r) == ADDR_EXPR && TREE_OPERAND (r, 0) == oldop)
7977 case FIX_TRUNC_EXPR:
7982 case TRUTH_NOT_EXPR:
7983 case FIXED_CONVERT_EXPR:
7984 r = cxx_eval_unary_expression (call, t, allow_non_constant, addr,
7985 non_constant_p, overflow_p);
7989 if (SIZEOF_EXPR_TYPE_P (t))
7990 r = cxx_sizeof_or_alignof_type (TREE_TYPE (TREE_OPERAND (t, 0)),
7991 SIZEOF_EXPR, false);
7992 else if (TYPE_P (TREE_OPERAND (t, 0)))
7993 r = cxx_sizeof_or_alignof_type (TREE_OPERAND (t, 0), SIZEOF_EXPR,
7996 r = cxx_sizeof_or_alignof_expr (TREE_OPERAND (t, 0), SIZEOF_EXPR,
7998 if (r == error_mark_node)
8000 VERIFY_CONSTANT (r);
8005 /* check_return_expr sometimes wraps a TARGET_EXPR in a
8006 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
8007 introduced by build_call_a. */
8008 tree op0 = TREE_OPERAND (t, 0);
8009 tree op1 = TREE_OPERAND (t, 1);
8011 if ((TREE_CODE (op0) == TARGET_EXPR && op1 == TARGET_EXPR_SLOT (op0))
8012 || TREE_CODE (op1) == EMPTY_CLASS_EXPR)
8013 r = cxx_eval_constant_expression (call, op0, allow_non_constant,
8014 addr, non_constant_p, overflow_p);
8017 /* Check that the LHS is constant and then discard it. */
8018 cxx_eval_constant_expression (call, op0, allow_non_constant,
8019 false, non_constant_p, overflow_p);
8020 op1 = TREE_OPERAND (t, 1);
8021 r = cxx_eval_constant_expression (call, op1, allow_non_constant,
8022 addr, non_constant_p, overflow_p);
8027 case POINTER_PLUS_EXPR:
8031 case TRUNC_DIV_EXPR:
8033 case FLOOR_DIV_EXPR:
8034 case ROUND_DIV_EXPR:
8035 case TRUNC_MOD_EXPR:
8037 case ROUND_MOD_EXPR:
8039 case EXACT_DIV_EXPR:
8049 case TRUTH_XOR_EXPR:
8056 case UNORDERED_EXPR:
8066 r = cxx_eval_binary_expression (call, t, allow_non_constant, addr,
8067 non_constant_p, overflow_p);
8070 /* fold can introduce non-IF versions of these; still treat them as
8071 short-circuiting. */
8072 case TRUTH_AND_EXPR:
8073 case TRUTH_ANDIF_EXPR:
8074 r = cxx_eval_logical_expression (call, t, boolean_false_node,
8076 allow_non_constant, addr,
8077 non_constant_p, overflow_p);
8081 case TRUTH_ORIF_EXPR:
8082 r = cxx_eval_logical_expression (call, t, boolean_true_node,
8084 allow_non_constant, addr,
8085 non_constant_p, overflow_p);
8089 r = cxx_eval_array_reference (call, t, allow_non_constant, addr,
8090 non_constant_p, overflow_p);
8094 r = cxx_eval_component_reference (call, t, allow_non_constant, addr,
8095 non_constant_p, overflow_p);
8099 r = cxx_eval_bit_field_ref (call, t, allow_non_constant, addr,
8100 non_constant_p, overflow_p);
8105 r = cxx_eval_conditional_expression (call, t, allow_non_constant, addr,
8106 non_constant_p, overflow_p);
8110 r = cxx_eval_bare_aggregate (call, t, allow_non_constant, addr,
8111 non_constant_p, overflow_p);
8115 /* We can get this in a defaulted constructor for a class with a
8116 non-static data member of array type. Either the initializer will
8117 be NULL, meaning default-initialization, or it will be an lvalue
8118 or xvalue of the same type, meaning direct-initialization from the
8119 corresponding member. */
8120 r = cxx_eval_vec_init (call, t, allow_non_constant, addr,
8121 non_constant_p, overflow_p);
8126 r = cxx_eval_trinary_expression (call, t, allow_non_constant, addr,
8127 non_constant_p, overflow_p);
8131 case VIEW_CONVERT_EXPR:
8134 tree oldop = TREE_OPERAND (t, 0);
8135 tree op = cxx_eval_constant_expression (call, oldop,
8136 allow_non_constant, addr,
8137 non_constant_p, overflow_p);
8138 if (*non_constant_p)
8140 if (POINTER_TYPE_P (TREE_TYPE (t))
8141 && TREE_CODE (op) == INTEGER_CST
8142 && !integer_zerop (op))
8144 if (!allow_non_constant)
8145 error_at (EXPR_LOC_OR_HERE (t),
8146 "reinterpret_cast from integer to pointer");
8147 *non_constant_p = true;
8151 /* We didn't fold at the top so we could check for ptr-int
8154 r = fold_build1 (TREE_CODE (t), TREE_TYPE (t), op);
8155 /* Conversion of an out-of-range value has implementation-defined
8156 behavior; the language considers it different from arithmetic
8157 overflow, which is undefined. */
8158 if (TREE_OVERFLOW_P (r) && !TREE_OVERFLOW_P (op))
8159 TREE_OVERFLOW (r) = false;
8163 case EMPTY_CLASS_EXPR:
8164 /* This is good enough for a function argument that might not get
8165 used, and they can't do anything with it, so just return it. */
8169 case PREINCREMENT_EXPR:
8170 case POSTINCREMENT_EXPR:
8171 case PREDECREMENT_EXPR:
8172 case POSTDECREMENT_EXPR:
8176 case VEC_DELETE_EXPR:
8180 /* GCC internal stuff. */
8183 case WITH_CLEANUP_EXPR:
8184 case STATEMENT_LIST:
8186 case NON_DEPENDENT_EXPR:
8190 if (!allow_non_constant)
8191 error_at (EXPR_LOC_OR_HERE (t),
8192 "expression %qE is not a constant-expression", t);
8193 *non_constant_p = true;
8197 internal_error ("unexpected expression %qE of kind %s", t,
8198 tree_code_name[TREE_CODE (t)]);
8199 *non_constant_p = true;
8203 if (r == error_mark_node)
8204 *non_constant_p = true;
8206 if (*non_constant_p)
8213 cxx_eval_outermost_constant_expr (tree t, bool allow_non_constant)
8215 bool non_constant_p = false;
8216 bool overflow_p = false;
8217 tree r = cxx_eval_constant_expression (NULL, t, allow_non_constant,
8218 false, &non_constant_p, &overflow_p);
8220 verify_constant (r, allow_non_constant, &non_constant_p, &overflow_p);
8222 if (TREE_CODE (t) != CONSTRUCTOR
8223 && cp_has_mutable_p (TREE_TYPE (t)))
8225 /* We allow a mutable type if the original expression was a
8226 CONSTRUCTOR so that we can do aggregate initialization of
8227 constexpr variables. */
8228 if (!allow_non_constant)
8229 error ("%qT cannot be the type of a complete constant expression "
8230 "because it has mutable sub-objects", TREE_TYPE (t));
8231 non_constant_p = true;
8234 /* Technically we should check this for all subexpressions, but that
8235 runs into problems with our internal representation of pointer
8236 subtraction and the 5.19 rules are still in flux. */
8237 if (CONVERT_EXPR_CODE_P (TREE_CODE (r))
8238 && ARITHMETIC_TYPE_P (TREE_TYPE (r))
8239 && TREE_CODE (TREE_OPERAND (r, 0)) == ADDR_EXPR)
8241 if (!allow_non_constant)
8242 error ("conversion from pointer type %qT "
8243 "to arithmetic type %qT in a constant-expression",
8244 TREE_TYPE (TREE_OPERAND (r, 0)), TREE_TYPE (r));
8245 non_constant_p = true;
8248 if (!non_constant_p && overflow_p)
8249 non_constant_p = true;
8251 if (non_constant_p && !allow_non_constant)
8252 return error_mark_node;
8253 else if (non_constant_p && TREE_CONSTANT (r))
8255 /* This isn't actually constant, so unset TREE_CONSTANT. */
8258 else if (TREE_CODE (r) == CONSTRUCTOR)
8259 r = build1 (VIEW_CONVERT_EXPR, TREE_TYPE (r), r);
8261 r = build_nop (TREE_TYPE (r), r);
8262 TREE_CONSTANT (r) = false;
8264 else if (non_constant_p || r == t)
8267 if (TREE_CODE (r) == CONSTRUCTOR && CLASS_TYPE_P (TREE_TYPE (r)))
8269 if (TREE_CODE (t) == TARGET_EXPR
8270 && TARGET_EXPR_INITIAL (t) == r)
8274 r = get_target_expr (r);
8275 TREE_CONSTANT (r) = true;
8283 /* Returns true if T is a valid subexpression of a constant expression,
8284 even if it isn't itself a constant expression. */
8287 is_sub_constant_expr (tree t)
8289 bool non_constant_p = false;
8290 bool overflow_p = false;
8291 cxx_eval_constant_expression (NULL, t, true, false, &non_constant_p,
8293 return !non_constant_p && !overflow_p;
8296 /* If T represents a constant expression returns its reduced value.
8297 Otherwise return error_mark_node. If T is dependent, then
8301 cxx_constant_value (tree t)
8303 return cxx_eval_outermost_constant_expr (t, false);
8306 /* If T is a constant expression, returns its reduced value.
8307 Otherwise, if T does not have TREE_CONSTANT set, returns T.
8308 Otherwise, returns a version of T without TREE_CONSTANT. */
8311 maybe_constant_value (tree t)
8315 if (instantiation_dependent_expression_p (t)
8316 || type_unknown_p (t)
8317 || BRACE_ENCLOSED_INITIALIZER_P (t)
8318 || !potential_constant_expression (t))
8320 if (TREE_OVERFLOW_P (t))
8322 t = build_nop (TREE_TYPE (t), t);
8323 TREE_CONSTANT (t) = false;
8328 r = cxx_eval_outermost_constant_expr (t, true);
8329 #ifdef ENABLE_CHECKING
8330 /* cp_tree_equal looks through NOPs, so allow them. */
8332 || CONVERT_EXPR_P (t)
8333 || (TREE_CONSTANT (t) && !TREE_CONSTANT (r))
8334 || !cp_tree_equal (r, t));
8339 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
8340 than wrapped in a TARGET_EXPR. */
8343 maybe_constant_init (tree t)
8345 t = maybe_constant_value (t);
8346 if (TREE_CODE (t) == TARGET_EXPR)
8348 tree init = TARGET_EXPR_INITIAL (t);
8349 if (TREE_CODE (init) == CONSTRUCTOR)
8356 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
8357 /* Return true if the object referred to by REF has automatic or thread
8360 enum { ck_ok, ck_bad, ck_unknown };
8362 check_automatic_or_tls (tree ref)
8364 enum machine_mode mode;
8365 HOST_WIDE_INT bitsize, bitpos;
8367 int volatilep = 0, unsignedp = 0;
8368 tree decl = get_inner_reference (ref, &bitsize, &bitpos, &offset,
8369 &mode, &unsignedp, &volatilep, false);
8372 /* If there isn't a decl in the middle, we don't know the linkage here,
8373 and this isn't a constant expression anyway. */
8376 dk = decl_storage_duration (decl);
8377 return (dk == dk_auto || dk == dk_thread) ? ck_bad : ck_ok;
8381 /* Return true if T denotes a potentially constant expression. Issue
8382 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
8383 an lvalue-rvalue conversion is implied.
8385 C++0x [expr.const] used to say
8387 6 An expression is a potential constant expression if it is
8388 a constant expression where all occurences of function
8389 parameters are replaced by arbitrary constant expressions
8390 of the appropriate type.
8392 2 A conditional expression is a constant expression unless it
8393 involves one of the following as a potentially evaluated
8394 subexpression (3.2), but subexpressions of logical AND (5.14),
8395 logical OR (5.15), and conditional (5.16) operations that are
8396 not evaluated are not considered. */
8399 potential_constant_expression_1 (tree t, bool want_rval, tsubst_flags_t flags)
8401 enum { any = false, rval = true };
8405 if (t == error_mark_node)
8409 if (TREE_THIS_VOLATILE (t))
8411 if (flags & tf_error)
8412 error ("expression %qE has side-effects", t);
8415 if (CONSTANT_CLASS_P (t))
8418 switch (TREE_CODE (t))
8424 case TEMPLATE_ID_EXPR:
8431 case TEMPLATE_PARM_INDEX:
8433 case IDENTIFIER_NODE:
8434 case USERDEF_LITERAL:
8435 /* We can see a FIELD_DECL in a pointer-to-member expression. */
8441 case AGGR_INIT_EXPR:
8443 /* -- an invocation of a function other than a constexpr function
8444 or a constexpr constructor. */
8446 tree fun = get_function_named_in_call (t);
8447 const int nargs = call_expr_nargs (t);
8450 if (is_overloaded_fn (fun))
8452 if (TREE_CODE (fun) == FUNCTION_DECL)
8454 if (builtin_valid_in_constant_expr_p (fun))
8456 if (!DECL_DECLARED_CONSTEXPR_P (fun)
8457 /* Allow any built-in function; if the expansion
8458 isn't constant, we'll deal with that then. */
8459 && !is_builtin_fn (fun))
8461 if (flags & tf_error)
8463 error_at (EXPR_LOC_OR_HERE (t),
8464 "call to non-constexpr function %qD", fun);
8465 explain_invalid_constexpr_fn (fun);
8469 /* A call to a non-static member function takes the address
8470 of the object as the first argument. But in a constant
8471 expression the address will be folded away, so look
8473 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun)
8474 && !DECL_CONSTRUCTOR_P (fun))
8476 tree x = get_nth_callarg (t, 0);
8477 if (is_this_parameter (x))
8479 if (DECL_CONTEXT (x) == NULL_TREE
8480 || DECL_CONSTRUCTOR_P (DECL_CONTEXT (x)))
8482 if (flags & tf_error)
8483 sorry ("calling a member function of the "
8484 "object being constructed in a constant "
8488 /* Otherwise OK. */;
8490 else if (!potential_constant_expression_1 (x, rval, flags))
8497 if (!potential_constant_expression_1 (fun, true, flags))
8499 fun = get_first_fn (fun);
8501 /* Skip initial arguments to base constructors. */
8502 if (DECL_BASE_CONSTRUCTOR_P (fun))
8503 i = num_artificial_parms_for (fun);
8504 fun = DECL_ORIGIN (fun);
8508 if (potential_constant_expression_1 (fun, rval, flags))
8509 /* Might end up being a constant function pointer. */;
8513 for (; i < nargs; ++i)
8515 tree x = get_nth_callarg (t, i);
8516 if (!potential_constant_expression_1 (x, rval, flags))
8522 case NON_LVALUE_EXPR:
8523 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
8524 -- an lvalue of integral type that refers to a non-volatile
8525 const variable or static data member initialized with
8526 constant expressions, or
8528 -- an lvalue of literal type that refers to non-volatile
8529 object defined with constexpr, or that refers to a
8530 sub-object of such an object; */
8531 return potential_constant_expression_1 (TREE_OPERAND (t, 0), rval, flags);
8534 if (want_rval && !decl_constant_var_p (t)
8535 && !dependent_type_p (TREE_TYPE (t)))
8537 if (flags & tf_error)
8538 non_const_var_error (t);
8545 case VIEW_CONVERT_EXPR:
8546 /* -- a reinterpret_cast. FIXME not implemented, and this rule
8547 may change to something more specific to type-punning (DR 1312). */
8549 tree from = TREE_OPERAND (t, 0);
8550 if (POINTER_TYPE_P (TREE_TYPE (t))
8551 && TREE_CODE (from) == INTEGER_CST
8552 && !integer_zerop (from))
8554 if (flags & tf_error)
8555 error_at (EXPR_LOC_OR_HERE (t),
8556 "reinterpret_cast from integer to pointer");
8559 return (potential_constant_expression_1
8560 (from, TREE_CODE (t) != VIEW_CONVERT_EXPR, flags));
8564 /* -- a unary operator & that is applied to an lvalue that
8565 designates an object with thread or automatic storage
8567 t = TREE_OPERAND (t, 0);
8569 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
8570 any checking here, as we might dereference the pointer later. If
8571 we remove this code, also remove check_automatic_or_tls. */
8572 i = check_automatic_or_tls (t);
8577 if (flags & tf_error)
8578 error ("address-of an object %qE with thread local or "
8579 "automatic storage is not a constant expression", t);
8583 return potential_constant_expression_1 (t, any, flags);
8589 /* -- a class member access unless its postfix-expression is
8590 of literal type or of pointer to literal type. */
8591 /* This test would be redundant, as it follows from the
8592 postfix-expression being a potential constant expression. */
8593 return potential_constant_expression_1 (TREE_OPERAND (t, 0),
8596 case EXPR_PACK_EXPANSION:
8597 return potential_constant_expression_1 (PACK_EXPANSION_PATTERN (t),
8602 tree x = TREE_OPERAND (t, 0);
8604 if (is_this_parameter (x))
8606 if (DECL_CONTEXT (x)
8607 && !DECL_DECLARED_CONSTEXPR_P (DECL_CONTEXT (x)))
8609 if (flags & tf_error)
8610 error ("use of %<this%> in a constant expression");
8613 if (want_rval && DECL_CONTEXT (x)
8614 && DECL_CONSTRUCTOR_P (DECL_CONTEXT (x)))
8616 if (flags & tf_error)
8617 sorry ("use of the value of the object being constructed "
8618 "in a constant expression");
8623 return potential_constant_expression_1 (x, rval, flags);
8627 case DYNAMIC_CAST_EXPR:
8628 case PSEUDO_DTOR_EXPR:
8629 case PREINCREMENT_EXPR:
8630 case POSTINCREMENT_EXPR:
8631 case PREDECREMENT_EXPR:
8632 case POSTDECREMENT_EXPR:
8636 case VEC_DELETE_EXPR:
8641 case OMP_ATOMIC_READ:
8642 case OMP_ATOMIC_CAPTURE_OLD:
8643 case OMP_ATOMIC_CAPTURE_NEW:
8644 /* GCC internal stuff. */
8647 case WITH_CLEANUP_EXPR:
8648 case CLEANUP_POINT_EXPR:
8649 case MUST_NOT_THROW_EXPR:
8650 case TRY_CATCH_EXPR:
8651 case STATEMENT_LIST:
8652 /* Don't bother trying to define a subset of statement-expressions to
8653 be constant-expressions, at least for now. */
8657 case TRANSACTION_EXPR:
8662 if (flags & tf_error)
8663 error ("expression %qE is not a constant-expression", t);
8667 /* -- a typeid expression whose operand is of polymorphic
8670 tree e = TREE_OPERAND (t, 0);
8671 if (!TYPE_P (e) && !type_dependent_expression_p (e)
8672 && TYPE_POLYMORPHIC_P (TREE_TYPE (e)))
8674 if (flags & tf_error)
8675 error ("typeid-expression is not a constant expression "
8676 "because %qE is of polymorphic type", e);
8683 /* -- a subtraction where both operands are pointers. */
8684 if (TYPE_PTR_P (TREE_OPERAND (t, 0))
8685 && TYPE_PTR_P (TREE_OPERAND (t, 1)))
8687 if (flags & tf_error)
8688 error ("difference of two pointer expressions is not "
8689 "a constant expression");
8701 /* -- a relational or equality operator where at least
8702 one of the operands is a pointer. */
8703 if (TYPE_PTR_P (TREE_OPERAND (t, 0))
8704 || TYPE_PTR_P (TREE_OPERAND (t, 1)))
8706 if (flags & tf_error)
8707 error ("pointer comparison expression is not a "
8708 "constant expression");
8716 if (TYPE_P (TREE_OPERAND (t, 0)))
8718 /* else fall through. */
8724 case FIX_TRUNC_EXPR:
8728 case TRUTH_NOT_EXPR:
8729 case FIXED_CONVERT_EXPR:
8730 case UNARY_PLUS_EXPR:
8731 return potential_constant_expression_1 (TREE_OPERAND (t, 0), rval,
8735 case CONST_CAST_EXPR:
8736 case STATIC_CAST_EXPR:
8737 case REINTERPRET_CAST_EXPR:
8738 case IMPLICIT_CONV_EXPR:
8739 if (cxx_dialect < cxx11
8740 && !dependent_type_p (TREE_TYPE (t))
8741 && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t)))
8742 /* In C++98, a conversion to non-integral type can't be part of a
8743 constant expression. */
8745 if (flags & tf_error)
8746 error ("cast to non-integral type %qT in a constant expression",
8751 return (potential_constant_expression_1
8752 (TREE_OPERAND (t, 0),
8753 TREE_CODE (TREE_TYPE (t)) != REFERENCE_TYPE, flags));
8756 case NON_DEPENDENT_EXPR:
8757 /* For convenience. */
8759 return potential_constant_expression_1 (TREE_OPERAND (t, 0),
8763 return potential_constant_expression_1 (TREE_OPERAND (t, 1),
8767 if (!literal_type_p (TREE_TYPE (t)))
8769 if (flags & tf_error)
8771 error ("temporary of non-literal type %qT in a "
8772 "constant expression", TREE_TYPE (t));
8773 explain_non_literal_class (TREE_TYPE (t));
8778 return potential_constant_expression_1 (TREE_OPERAND (t, 1),
8783 vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (t);
8784 constructor_elt *ce;
8785 for (i = 0; vec_safe_iterate (v, i, &ce); ++i)
8786 if (!potential_constant_expression_1 (ce->value, want_rval, flags))
8793 gcc_assert (TREE_PURPOSE (t) == NULL_TREE
8794 || DECL_P (TREE_PURPOSE (t)));
8795 if (!potential_constant_expression_1 (TREE_VALUE (t), want_rval,
8798 if (TREE_CHAIN (t) == NULL_TREE)
8800 return potential_constant_expression_1 (TREE_CHAIN (t), want_rval,
8804 case TRUNC_DIV_EXPR:
8806 case FLOOR_DIV_EXPR:
8807 case ROUND_DIV_EXPR:
8808 case TRUNC_MOD_EXPR:
8810 case ROUND_MOD_EXPR:
8812 tree denom = TREE_OPERAND (t, 1);
8813 if (!potential_constant_expression_1 (denom, rval, flags))
8815 /* We can't call cxx_eval_outermost_constant_expr on an expression
8816 that hasn't been through fold_non_dependent_expr yet. */
8817 if (!processing_template_decl)
8818 denom = cxx_eval_outermost_constant_expr (denom, true);
8819 if (integer_zerop (denom))
8821 if (flags & tf_error)
8822 error ("division by zero is not a constant-expression");
8828 return potential_constant_expression_1 (TREE_OPERAND (t, 0),
8835 /* check_return_expr sometimes wraps a TARGET_EXPR in a
8836 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
8837 introduced by build_call_a. */
8838 tree op0 = TREE_OPERAND (t, 0);
8839 tree op1 = TREE_OPERAND (t, 1);
8841 if ((TREE_CODE (op0) == TARGET_EXPR && op1 == TARGET_EXPR_SLOT (op0))
8842 || TREE_CODE (op1) == EMPTY_CLASS_EXPR)
8843 return potential_constant_expression_1 (op0, want_rval, flags);
8848 /* If the first operand is the non-short-circuit constant, look at
8849 the second operand; otherwise we only care about the first one for
8851 case TRUTH_AND_EXPR:
8852 case TRUTH_ANDIF_EXPR:
8853 tmp = boolean_true_node;
8856 case TRUTH_ORIF_EXPR:
8857 tmp = boolean_false_node;
8860 tree op = TREE_OPERAND (t, 0);
8861 if (!potential_constant_expression_1 (op, rval, flags))
8863 if (!processing_template_decl)
8864 op = cxx_eval_outermost_constant_expr (op, true);
8865 if (tree_int_cst_equal (op, tmp))
8866 return potential_constant_expression_1 (TREE_OPERAND (t, 1), rval, flags);
8873 case POINTER_PLUS_EXPR:
8875 case EXACT_DIV_EXPR:
8885 case TRUTH_XOR_EXPR:
8886 case UNORDERED_EXPR:
8899 case ARRAY_RANGE_REF:
8903 for (i = 0; i < 2; ++i)
8904 if (!potential_constant_expression_1 (TREE_OPERAND (t, i),
8909 case ARRAY_NOTATION_REF:
8914 for (i = 0; i < 3; ++i)
8915 if (!potential_constant_expression_1 (TREE_OPERAND (t, i),
8922 /* If the condition is a known constant, we know which of the legs we
8923 care about; otherwise we only require that the condition and
8924 either of the legs be potentially constant. */
8925 tmp = TREE_OPERAND (t, 0);
8926 if (!potential_constant_expression_1 (tmp, rval, flags))
8928 if (!processing_template_decl)
8929 tmp = cxx_eval_outermost_constant_expr (tmp, true);
8930 if (integer_zerop (tmp))
8931 return potential_constant_expression_1 (TREE_OPERAND (t, 2),
8933 else if (TREE_CODE (tmp) == INTEGER_CST)
8934 return potential_constant_expression_1 (TREE_OPERAND (t, 1),
8936 for (i = 1; i < 3; ++i)
8937 if (potential_constant_expression_1 (TREE_OPERAND (t, i),
8938 want_rval, tf_none))
8940 if (flags & tf_error)
8941 error ("expression %qE is not a constant-expression", t);
8945 if (VEC_INIT_EXPR_IS_CONSTEXPR (t))
8947 if (flags & tf_error)
8949 error ("non-constant array initialization");
8950 diagnose_non_constexpr_vec_init (t);
8955 if (objc_is_property_ref (t))
8958 sorry ("unexpected AST of kind %s", tree_code_name[TREE_CODE (t)]);
8964 /* The main entry point to the above. */
8967 potential_constant_expression (tree t)
8969 return potential_constant_expression_1 (t, false, tf_none);
8972 /* As above, but require a constant rvalue. */
8975 potential_rvalue_constant_expression (tree t)
8977 return potential_constant_expression_1 (t, true, tf_none);
8980 /* Like above, but complain about non-constant expressions. */
8983 require_potential_constant_expression (tree t)
8985 return potential_constant_expression_1 (t, false, tf_warning_or_error);
8988 /* Cross product of the above. */
8991 require_potential_rvalue_constant_expression (tree t)
8993 return potential_constant_expression_1 (t, true, tf_warning_or_error);
8996 /* Constructor for a lambda expression. */
8999 build_lambda_expr (void)
9001 tree lambda = make_node (LAMBDA_EXPR);
9002 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda) = CPLD_NONE;
9003 LAMBDA_EXPR_CAPTURE_LIST (lambda) = NULL_TREE;
9004 LAMBDA_EXPR_THIS_CAPTURE (lambda) = NULL_TREE;
9005 LAMBDA_EXPR_PENDING_PROXIES (lambda) = NULL;
9006 LAMBDA_EXPR_RETURN_TYPE (lambda) = NULL_TREE;
9007 LAMBDA_EXPR_MUTABLE_P (lambda) = false;
9011 /* Create the closure object for a LAMBDA_EXPR. */
9014 build_lambda_object (tree lambda_expr)
9016 /* Build aggregate constructor call.
9017 - cp_parser_braced_list
9018 - cp_parser_functional_cast */
9019 vec<constructor_elt, va_gc> *elts = NULL;
9020 tree node, expr, type;
9021 location_t saved_loc;
9023 if (processing_template_decl)
9026 /* Make sure any error messages refer to the lambda-introducer. */
9027 saved_loc = input_location;
9028 input_location = LAMBDA_EXPR_LOCATION (lambda_expr);
9030 for (node = LAMBDA_EXPR_CAPTURE_LIST (lambda_expr);
9032 node = TREE_CHAIN (node))
9034 tree field = TREE_PURPOSE (node);
9035 tree val = TREE_VALUE (node);
9037 if (field == error_mark_node)
9039 expr = error_mark_node;
9046 /* Mere mortals can't copy arrays with aggregate initialization, so
9047 do some magic to make it work here. */
9048 if (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE)
9049 val = build_array_copy (val);
9050 else if (DECL_NORMAL_CAPTURE_P (field)
9051 && !DECL_VLA_CAPTURE_P (field)
9052 && TREE_CODE (TREE_TYPE (field)) != REFERENCE_TYPE)
9054 /* "the entities that are captured by copy are used to
9055 direct-initialize each corresponding non-static data
9056 member of the resulting closure object."
9058 There's normally no way to express direct-initialization
9059 from an element of a CONSTRUCTOR, so we build up a special
9060 TARGET_EXPR to bypass the usual copy-initialization. */
9061 val = force_rvalue (val, tf_warning_or_error);
9062 if (TREE_CODE (val) == TARGET_EXPR)
9063 TARGET_EXPR_DIRECT_INIT_P (val) = true;
9066 CONSTRUCTOR_APPEND_ELT (elts, DECL_NAME (field), val);
9069 expr = build_constructor (init_list_type_node, elts);
9070 CONSTRUCTOR_IS_DIRECT_INIT (expr) = 1;
9072 /* N2927: "[The closure] class type is not an aggregate."
9073 But we briefly treat it as an aggregate to make this simpler. */
9074 type = LAMBDA_EXPR_CLOSURE (lambda_expr);
9075 CLASSTYPE_NON_AGGREGATE (type) = 0;
9076 expr = finish_compound_literal (type, expr, tf_warning_or_error);
9077 CLASSTYPE_NON_AGGREGATE (type) = 1;
9080 input_location = saved_loc;
9084 /* Return an initialized RECORD_TYPE for LAMBDA.
9085 LAMBDA must have its explicit captures already. */
9088 begin_lambda_type (tree lambda)
9093 /* Unique name. This is just like an unnamed class, but we cannot use
9094 make_anon_name because of certain checks against TYPE_ANONYMOUS_P. */
9096 name = make_lambda_name ();
9098 /* Create the new RECORD_TYPE for this lambda. */
9099 type = xref_tag (/*tag_code=*/record_type,
9101 /*scope=*/ts_lambda,
9102 /*template_header_p=*/false);
9105 /* Designate it as a struct so that we can use aggregate initialization. */
9106 CLASSTYPE_DECLARED_CLASS (type) = false;
9108 /* Cross-reference the expression and the type. */
9109 LAMBDA_EXPR_CLOSURE (lambda) = type;
9110 CLASSTYPE_LAMBDA_EXPR (type) = lambda;
9112 /* Clear base types. */
9113 xref_basetypes (type, /*bases=*/NULL_TREE);
9115 /* Start the class. */
9116 type = begin_class_definition (type);
9117 if (type == error_mark_node)
9118 return error_mark_node;
9123 /* Returns the type to use for the return type of the operator() of a
9127 lambda_return_type (tree expr)
9129 if (expr == NULL_TREE)
9130 return void_type_node;
9131 if (type_unknown_p (expr)
9132 || BRACE_ENCLOSED_INITIALIZER_P (expr))
9134 cxx_incomplete_type_error (expr, TREE_TYPE (expr));
9135 return void_type_node;
9137 gcc_checking_assert (!type_dependent_expression_p (expr));
9138 return cv_unqualified (type_decays_to (unlowered_expr_type (expr)));
9141 /* Given a LAMBDA_EXPR or closure type LAMBDA, return the op() of the
9145 lambda_function (tree lambda)
9148 if (TREE_CODE (lambda) == LAMBDA_EXPR)
9149 type = LAMBDA_EXPR_CLOSURE (lambda);
9152 gcc_assert (LAMBDA_TYPE_P (type));
9153 /* Don't let debug_tree cause instantiation. */
9154 if (CLASSTYPE_TEMPLATE_INSTANTIATION (type)
9155 && !COMPLETE_OR_OPEN_TYPE_P (type))
9157 lambda = lookup_member (type, ansi_opname (CALL_EXPR),
9158 /*protect=*/0, /*want_type=*/false,
9159 tf_warning_or_error);
9161 lambda = BASELINK_FUNCTIONS (lambda);
9165 /* Returns the type to use for the FIELD_DECL corresponding to the
9167 The caller should add REFERENCE_TYPE for capture by reference. */
9170 lambda_capture_field_type (tree expr, bool explicit_init_p)
9173 if (explicit_init_p)
9175 type = make_auto ();
9176 type = do_auto_deduction (type, expr, type);
9179 type = non_reference (unlowered_expr_type (expr));
9180 if (!type || WILDCARD_TYPE_P (type) || type_uses_auto (type))
9182 type = cxx_make_type (DECLTYPE_TYPE);
9183 DECLTYPE_TYPE_EXPR (type) = expr;
9184 DECLTYPE_FOR_LAMBDA_CAPTURE (type) = true;
9185 DECLTYPE_FOR_INIT_CAPTURE (type) = explicit_init_p;
9186 SET_TYPE_STRUCTURAL_EQUALITY (type);
9191 /* Insert the deduced return type for an auto function. */
9194 apply_deduced_return_type (tree fco, tree return_type)
9198 if (return_type == error_mark_node)
9201 if (LAMBDA_FUNCTION_P (fco))
9203 tree lambda = CLASSTYPE_LAMBDA_EXPR (current_class_type);
9204 LAMBDA_EXPR_RETURN_TYPE (lambda) = return_type;
9207 if (DECL_CONV_FN_P (fco))
9208 DECL_NAME (fco) = mangle_conv_op_name_for_type (return_type);
9210 TREE_TYPE (fco) = change_return_type (return_type, TREE_TYPE (fco));
9212 result = DECL_RESULT (fco);
9213 if (result == NULL_TREE)
9215 if (TREE_TYPE (result) == return_type)
9218 /* We already have a DECL_RESULT from start_preparsed_function.
9219 Now we need to redo the work it and allocate_struct_function
9220 did to reflect the new type. */
9221 gcc_assert (current_function_decl == fco);
9222 result = build_decl (input_location, RESULT_DECL, NULL_TREE,
9223 TYPE_MAIN_VARIANT (return_type));
9224 DECL_ARTIFICIAL (result) = 1;
9225 DECL_IGNORED_P (result) = 1;
9226 cp_apply_type_quals_to_decl (cp_type_quals (return_type),
9229 DECL_RESULT (fco) = result;
9231 if (!processing_template_decl)
9233 bool aggr = aggregate_value_p (result, fco);
9234 #ifdef PCC_STATIC_STRUCT_RETURN
9235 cfun->returns_pcc_struct = aggr;
9237 cfun->returns_struct = aggr;
9242 /* DECL is a local variable or parameter from the surrounding scope of a
9243 lambda-expression. Returns the decltype for a use of the capture field
9244 for DECL even if it hasn't been captured yet. */
9247 capture_decltype (tree decl)
9249 tree lam = CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (current_function_decl));
9250 /* FIXME do lookup instead of list walk? */
9251 tree cap = value_member (decl, LAMBDA_EXPR_CAPTURE_LIST (lam));
9255 type = TREE_TYPE (TREE_PURPOSE (cap));
9257 switch (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lam))
9260 error ("%qD is not captured", decl);
9261 return error_mark_node;
9264 type = TREE_TYPE (decl);
9265 if (TREE_CODE (type) == REFERENCE_TYPE
9266 && TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE)
9267 type = TREE_TYPE (type);
9270 case CPLD_REFERENCE:
9271 type = TREE_TYPE (decl);
9272 if (TREE_CODE (type) != REFERENCE_TYPE)
9273 type = build_reference_type (TREE_TYPE (decl));
9280 if (TREE_CODE (type) != REFERENCE_TYPE)
9282 if (!LAMBDA_EXPR_MUTABLE_P (lam))
9283 type = cp_build_qualified_type (type, (cp_type_quals (type)
9285 type = build_reference_type (type);
9290 /* Returns true iff DECL is a lambda capture proxy variable created by
9291 build_capture_proxy. */
9294 is_capture_proxy (tree decl)
9296 return (VAR_P (decl)
9297 && DECL_HAS_VALUE_EXPR_P (decl)
9298 && !DECL_ANON_UNION_VAR_P (decl)
9299 && LAMBDA_FUNCTION_P (DECL_CONTEXT (decl)));
9302 /* Returns true iff DECL is a capture proxy for a normal capture
9303 (i.e. without explicit initializer). */
9306 is_normal_capture_proxy (tree decl)
9308 if (!is_capture_proxy (decl))
9309 /* It's not a capture proxy. */
9312 /* It is a capture proxy, is it a normal capture? */
9313 tree val = DECL_VALUE_EXPR (decl);
9314 if (val == error_mark_node)
9317 gcc_assert (TREE_CODE (val) == COMPONENT_REF);
9318 val = TREE_OPERAND (val, 1);
9319 return DECL_NORMAL_CAPTURE_P (val);
9322 /* VAR is a capture proxy created by build_capture_proxy; add it to the
9323 current function, which is the operator() for the appropriate lambda. */
9326 insert_capture_proxy (tree var)
9328 cp_binding_level *b;
9331 /* Put the capture proxy in the extra body block so that it won't clash
9332 with a later local variable. */
9333 b = current_binding_level;
9336 cp_binding_level *n = b->level_chain;
9337 if (n->kind == sk_function_parms)
9341 pushdecl_with_scope (var, b, false);
9343 /* And put a DECL_EXPR in the STATEMENT_LIST for the same block. */
9344 var = build_stmt (DECL_SOURCE_LOCATION (var), DECL_EXPR, var);
9345 stmt_list = (*stmt_list_stack)[1];
9346 gcc_assert (stmt_list);
9347 append_to_statement_list_force (var, &stmt_list);
9350 /* We've just finished processing a lambda; if the containing scope is also
9351 a lambda, insert any capture proxies that were created while processing
9352 the nested lambda. */
9355 insert_pending_capture_proxies (void)
9358 vec<tree, va_gc> *proxies;
9361 if (!current_function_decl || !LAMBDA_FUNCTION_P (current_function_decl))
9364 lam = CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (current_function_decl));
9365 proxies = LAMBDA_EXPR_PENDING_PROXIES (lam);
9366 for (i = 0; i < vec_safe_length (proxies); ++i)
9368 tree var = (*proxies)[i];
9369 insert_capture_proxy (var);
9371 release_tree_vector (LAMBDA_EXPR_PENDING_PROXIES (lam));
9372 LAMBDA_EXPR_PENDING_PROXIES (lam) = NULL;
9375 /* Given REF, a COMPONENT_REF designating a field in the lambda closure,
9376 return the type we want the proxy to have: the type of the field itself,
9377 with added const-qualification if the lambda isn't mutable and the
9378 capture is by value. */
9381 lambda_proxy_type (tree ref)
9384 if (REFERENCE_REF_P (ref))
9385 ref = TREE_OPERAND (ref, 0);
9386 type = TREE_TYPE (ref);
9387 if (type && !WILDCARD_TYPE_P (non_reference (type)))
9389 type = cxx_make_type (DECLTYPE_TYPE);
9390 DECLTYPE_TYPE_EXPR (type) = ref;
9391 DECLTYPE_FOR_LAMBDA_PROXY (type) = true;
9392 SET_TYPE_STRUCTURAL_EQUALITY (type);
9396 /* MEMBER is a capture field in a lambda closure class. Now that we're
9397 inside the operator(), build a placeholder var for future lookups and
9401 build_capture_proxy (tree member)
9403 tree var, object, fn, closure, name, lam, type;
9405 closure = DECL_CONTEXT (member);
9406 fn = lambda_function (closure);
9407 lam = CLASSTYPE_LAMBDA_EXPR (closure);
9409 /* The proxy variable forwards to the capture field. */
9410 object = build_fold_indirect_ref (DECL_ARGUMENTS (fn));
9411 object = finish_non_static_data_member (member, object, NULL_TREE);
9412 if (REFERENCE_REF_P (object))
9413 object = TREE_OPERAND (object, 0);
9415 /* Remove the __ inserted by add_capture. */
9416 if (DECL_NORMAL_CAPTURE_P (member))
9417 name = get_identifier (IDENTIFIER_POINTER (DECL_NAME (member)) + 2);
9419 name = DECL_NAME (member);
9421 type = lambda_proxy_type (object);
9423 if (DECL_VLA_CAPTURE_P (member))
9425 /* Rebuild the VLA type from the pointer and maxindex. */
9426 tree field = next_initializable_field (TYPE_FIELDS (type));
9427 tree ptr = build_simple_component_ref (object, field);
9428 field = next_initializable_field (DECL_CHAIN (field));
9429 tree max = build_simple_component_ref (object, field);
9430 type = build_array_type (TREE_TYPE (TREE_TYPE (ptr)),
9431 build_index_type (max));
9432 type = build_reference_type (type);
9433 REFERENCE_VLA_OK (type) = true;
9434 object = convert (type, ptr);
9437 var = build_decl (input_location, VAR_DECL, name, type);
9438 SET_DECL_VALUE_EXPR (var, object);
9439 DECL_HAS_VALUE_EXPR_P (var) = 1;
9440 DECL_ARTIFICIAL (var) = 1;
9441 TREE_USED (var) = 1;
9442 DECL_CONTEXT (var) = fn;
9444 if (name == this_identifier)
9446 gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (lam) == member);
9447 LAMBDA_EXPR_THIS_CAPTURE (lam) = var;
9450 if (fn == current_function_decl)
9451 insert_capture_proxy (var);
9453 vec_safe_push (LAMBDA_EXPR_PENDING_PROXIES (lam), var);
9458 /* Return a struct containing a pointer and a length for lambda capture of
9459 an array of runtime length. */
9462 vla_capture_type (tree array_type)
9464 static tree ptr_id, max_id;
9465 tree type = xref_tag (record_type, make_anon_name (), ts_current, false);
9466 xref_basetypes (type, NULL_TREE);
9467 type = begin_class_definition (type);
9470 ptr_id = get_identifier ("ptr");
9471 max_id = get_identifier ("max");
9473 tree ptrtype = build_pointer_type (TREE_TYPE (array_type));
9474 tree field = build_decl (input_location, FIELD_DECL, ptr_id, ptrtype);
9475 finish_member_declaration (field);
9476 field = build_decl (input_location, FIELD_DECL, max_id, sizetype);
9477 finish_member_declaration (field);
9478 return finish_struct (type, NULL_TREE);
9481 /* From an ID and INITIALIZER, create a capture (by reference if
9482 BY_REFERENCE_P is true), add it to the capture-list for LAMBDA,
9486 add_capture (tree lambda, tree id, tree initializer, bool by_reference_p,
9487 bool explicit_init_p)
9490 tree type, member, name;
9493 if (TREE_CODE (initializer) == TREE_LIST)
9494 initializer = build_x_compound_expr_from_list (initializer, ELK_INIT,
9495 tf_warning_or_error);
9496 type = lambda_capture_field_type (initializer, explicit_init_p);
9497 if (array_of_runtime_bound_p (type))
9500 if (!by_reference_p)
9501 error ("array of runtime bound cannot be captured by copy, "
9502 "only by reference");
9504 /* For a VLA, we capture the address of the first element and the
9505 maximum index, and then reconstruct the VLA for the proxy. */
9506 tree elt = cp_build_array_ref (input_location, initializer,
9507 integer_zero_node, tf_warning_or_error);
9508 initializer = build_constructor_va (init_list_type_node, 2,
9509 NULL_TREE, build_address (elt),
9510 NULL_TREE, array_type_nelts (type));
9511 type = vla_capture_type (type);
9513 else if (variably_modified_type_p (type, NULL_TREE))
9515 error ("capture of variable-size type %qT that is not a C++1y array "
9516 "of runtime bound", type);
9517 if (TREE_CODE (type) == ARRAY_TYPE
9518 && variably_modified_type_p (TREE_TYPE (type), NULL_TREE))
9519 inform (input_location, "because the array element type %qT has "
9520 "variable size", TREE_TYPE (type));
9521 type = error_mark_node;
9523 else if (by_reference_p)
9525 type = build_reference_type (type);
9526 if (!real_lvalue_p (initializer))
9527 error ("cannot capture %qE by reference", initializer);
9530 /* Capture by copy requires a complete type. */
9531 type = complete_type (type);
9533 /* Add __ to the beginning of the field name so that user code
9534 won't find the field with name lookup. We can't just leave the name
9535 unset because template instantiation uses the name to find
9536 instantiated fields. */
9537 if (!explicit_init_p)
9539 buf = (char *) alloca (IDENTIFIER_LENGTH (id) + 3);
9540 buf[1] = buf[0] = '_';
9541 memcpy (buf + 2, IDENTIFIER_POINTER (id),
9542 IDENTIFIER_LENGTH (id) + 1);
9543 name = get_identifier (buf);
9546 /* But captures with explicit initializers are named. */
9549 /* If TREE_TYPE isn't set, we're still in the introducer, so check
9551 if (!LAMBDA_EXPR_CLOSURE (lambda))
9553 if (IDENTIFIER_MARKED (name))
9555 pedwarn (input_location, 0,
9556 "already captured %qD in lambda expression", id);
9559 IDENTIFIER_MARKED (name) = true;
9562 /* Make member variable. */
9563 member = build_lang_decl (FIELD_DECL, name, type);
9564 DECL_VLA_CAPTURE_P (member) = vla;
9566 if (!explicit_init_p)
9567 /* Normal captures are invisible to name lookup but uses are replaced
9568 with references to the capture field; we implement this by only
9569 really making them invisible in unevaluated context; see
9570 qualify_lookup. For now, let's make explicitly initialized captures
9572 DECL_NORMAL_CAPTURE_P (member) = true;
9574 if (id == this_identifier)
9575 LAMBDA_EXPR_THIS_CAPTURE (lambda) = member;
9577 /* Add it to the appropriate closure class if we've started it. */
9578 if (current_class_type
9579 && current_class_type == LAMBDA_EXPR_CLOSURE (lambda))
9580 finish_member_declaration (member);
9582 LAMBDA_EXPR_CAPTURE_LIST (lambda)
9583 = tree_cons (member, initializer, LAMBDA_EXPR_CAPTURE_LIST (lambda));
9585 if (LAMBDA_EXPR_CLOSURE (lambda))
9586 return build_capture_proxy (member);
9587 /* For explicit captures we haven't started the function yet, so we wait
9588 and build the proxy from cp_parser_lambda_body. */
9592 /* Register all the capture members on the list CAPTURES, which is the
9593 LAMBDA_EXPR_CAPTURE_LIST for the lambda after the introducer. */
9596 register_capture_members (tree captures)
9598 if (captures == NULL_TREE)
9601 register_capture_members (TREE_CHAIN (captures));
9602 /* We set this in add_capture to avoid duplicates. */
9603 IDENTIFIER_MARKED (DECL_NAME (TREE_PURPOSE (captures))) = false;
9604 finish_member_declaration (TREE_PURPOSE (captures));
9607 /* Similar to add_capture, except this works on a stack of nested lambdas.
9608 BY_REFERENCE_P in this case is derived from the default capture mode.
9609 Returns the capture for the lambda at the bottom of the stack. */
9612 add_default_capture (tree lambda_stack, tree id, tree initializer)
9614 bool this_capture_p = (id == this_identifier);
9616 tree var = NULL_TREE;
9618 tree saved_class_type = current_class_type;
9622 for (node = lambda_stack;
9624 node = TREE_CHAIN (node))
9626 tree lambda = TREE_VALUE (node);
9628 current_class_type = LAMBDA_EXPR_CLOSURE (lambda);
9629 var = add_capture (lambda,
9634 && (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda)
9635 == CPLD_REFERENCE)),
9636 /*explicit_init_p=*/false);
9637 initializer = convert_from_reference (var);
9640 current_class_type = saved_class_type;
9645 /* Return the capture pertaining to a use of 'this' in LAMBDA, in the form of an
9646 INDIRECT_REF, possibly adding it through default capturing. */
9649 lambda_expr_this_capture (tree lambda)
9653 tree this_capture = LAMBDA_EXPR_THIS_CAPTURE (lambda);
9655 /* In unevaluated context this isn't an odr-use, so just return the
9657 if (cp_unevaluated_operand)
9658 return lookup_name (this_identifier);
9660 /* Try to default capture 'this' if we can. */
9662 && LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda) != CPLD_NONE)
9664 tree lambda_stack = NULL_TREE;
9665 tree init = NULL_TREE;
9667 /* If we are in a lambda function, we can move out until we hit:
9668 1. a non-lambda function or NSDMI,
9669 2. a lambda function capturing 'this', or
9670 3. a non-default capturing lambda function. */
9671 for (tree tlambda = lambda; ;)
9673 lambda_stack = tree_cons (NULL_TREE,
9677 if (LAMBDA_EXPR_EXTRA_SCOPE (tlambda)
9678 && TREE_CODE (LAMBDA_EXPR_EXTRA_SCOPE (tlambda)) == FIELD_DECL)
9680 /* In an NSDMI, we don't have a function to look up the decl in,
9681 but the fake 'this' pointer that we're using for parsing is
9683 init = scope_chain->x_current_class_ptr;
9685 (init && (TREE_TYPE (TREE_TYPE (init))
9686 == current_nonlambda_class_type ()));
9690 tree closure_decl = TYPE_NAME (LAMBDA_EXPR_CLOSURE (tlambda));
9691 tree containing_function = decl_function_context (closure_decl);
9693 if (containing_function == NULL_TREE)
9694 /* We ran out of scopes; there's no 'this' to capture. */
9697 if (!LAMBDA_FUNCTION_P (containing_function))
9699 /* We found a non-lambda function. */
9700 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (containing_function))
9701 /* First parameter is 'this'. */
9702 init = DECL_ARGUMENTS (containing_function);
9707 = CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (containing_function));
9709 if (LAMBDA_EXPR_THIS_CAPTURE (tlambda))
9711 /* An outer lambda has already captured 'this'. */
9712 init = LAMBDA_EXPR_THIS_CAPTURE (tlambda);
9716 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (tlambda) == CPLD_NONE)
9717 /* An outer lambda won't let us capture 'this'. */
9722 this_capture = add_default_capture (lambda_stack,
9723 /*id=*/this_identifier,
9729 error ("%<this%> was not captured for this lambda function");
9730 result = error_mark_node;
9734 /* To make sure that current_class_ref is for the lambda. */
9735 gcc_assert (TYPE_MAIN_VARIANT (TREE_TYPE (current_class_ref))
9736 == LAMBDA_EXPR_CLOSURE (lambda));
9738 result = this_capture;
9740 /* If 'this' is captured, each use of 'this' is transformed into an
9741 access to the corresponding unnamed data member of the closure
9742 type cast (_expr.cast_ 5.4) to the type of 'this'. [ The cast
9743 ensures that the transformed expression is an rvalue. ] */
9744 result = rvalue (result);
9750 /* We don't want to capture 'this' until we know we need it, i.e. after
9751 overload resolution has chosen a non-static member function. At that
9752 point we call this function to turn a dummy object into a use of the
9756 maybe_resolve_dummy (tree object)
9758 if (!is_dummy_object (object))
9761 tree type = TYPE_MAIN_VARIANT (TREE_TYPE (object));
9762 gcc_assert (!TYPE_PTR_P (type));
9764 if (type != current_class_type
9765 && current_class_type
9766 && LAMBDA_TYPE_P (current_class_type)
9767 && DERIVED_FROM_P (type, current_nonlambda_class_type ()))
9769 /* In a lambda, need to go through 'this' capture. */
9770 tree lam = CLASSTYPE_LAMBDA_EXPR (current_class_type);
9771 tree cap = lambda_expr_this_capture (lam);
9772 object = build_x_indirect_ref (EXPR_LOCATION (object), cap,
9773 RO_NULL, tf_warning_or_error);
9779 /* Returns the method basetype of the innermost non-lambda function, or
9780 NULL_TREE if none. */
9783 nonlambda_method_basetype (void)
9786 if (!current_class_ref)
9789 type = current_class_type;
9790 if (!LAMBDA_TYPE_P (type))
9793 /* Find the nearest enclosing non-lambda function. */
9794 fn = TYPE_NAME (type);
9796 fn = decl_function_context (fn);
9797 while (fn && LAMBDA_FUNCTION_P (fn));
9799 if (!fn || !DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
9802 return TYPE_METHOD_BASETYPE (TREE_TYPE (fn));
9805 /* If the closure TYPE has a static op(), also add a conversion to function
9809 maybe_add_lambda_conv_op (tree type)
9811 bool nested = (current_function_decl != NULL_TREE);
9812 tree callop = lambda_function (type);
9813 tree rettype, name, fntype, fn, body, compound_stmt;
9814 tree thistype, stattype, statfn, convfn, call, arg;
9815 vec<tree, va_gc> *argvec;
9817 if (LAMBDA_EXPR_CAPTURE_LIST (CLASSTYPE_LAMBDA_EXPR (type)) != NULL_TREE)
9820 if (processing_template_decl)
9823 if (DECL_INITIAL (callop) == NULL_TREE)
9825 /* If the op() wasn't instantiated due to errors, give up. */
9826 gcc_assert (errorcount || sorrycount);
9830 stattype = build_function_type (TREE_TYPE (TREE_TYPE (callop)),
9831 FUNCTION_ARG_CHAIN (callop));
9833 /* First build up the conversion op. */
9835 rettype = build_pointer_type (stattype);
9836 name = mangle_conv_op_name_for_type (rettype);
9837 thistype = cp_build_qualified_type (type, TYPE_QUAL_CONST);
9838 fntype = build_method_type_directly (thistype, rettype, void_list_node);
9839 fn = convfn = build_lang_decl (FUNCTION_DECL, name, fntype);
9840 DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (callop);
9842 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
9843 && DECL_ALIGN (fn) < 2 * BITS_PER_UNIT)
9844 DECL_ALIGN (fn) = 2 * BITS_PER_UNIT;
9846 SET_OVERLOADED_OPERATOR_CODE (fn, TYPE_EXPR);
9847 grokclassfn (type, fn, NO_SPECIAL);
9848 set_linkage_according_to_type (type, fn);
9849 rest_of_decl_compilation (fn, toplevel_bindings_p (), at_eof);
9850 DECL_IN_AGGR_P (fn) = 1;
9851 DECL_ARTIFICIAL (fn) = 1;
9852 DECL_NOT_REALLY_EXTERN (fn) = 1;
9853 DECL_DECLARED_INLINE_P (fn) = 1;
9854 DECL_ARGUMENTS (fn) = build_this_parm (fntype, TYPE_QUAL_CONST);
9856 DECL_INTERFACE_KNOWN (fn) = 1;
9858 add_method (type, fn, NULL_TREE);
9860 /* Generic thunk code fails for varargs; we'll complain in mark_used if
9861 the conversion op is used. */
9862 if (varargs_function_p (callop))
9864 DECL_DELETED_FN (fn) = 1;
9868 /* Now build up the thunk to be returned. */
9870 name = get_identifier ("_FUN");
9871 fn = statfn = build_lang_decl (FUNCTION_DECL, name, stattype);
9872 DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (callop);
9873 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
9874 && DECL_ALIGN (fn) < 2 * BITS_PER_UNIT)
9875 DECL_ALIGN (fn) = 2 * BITS_PER_UNIT;
9876 grokclassfn (type, fn, NO_SPECIAL);
9877 set_linkage_according_to_type (type, fn);
9878 rest_of_decl_compilation (fn, toplevel_bindings_p (), at_eof);
9879 DECL_IN_AGGR_P (fn) = 1;
9880 DECL_ARTIFICIAL (fn) = 1;
9881 DECL_NOT_REALLY_EXTERN (fn) = 1;
9882 DECL_DECLARED_INLINE_P (fn) = 1;
9883 DECL_STATIC_FUNCTION_P (fn) = 1;
9884 DECL_ARGUMENTS (fn) = copy_list (DECL_CHAIN (DECL_ARGUMENTS (callop)));
9885 for (arg = DECL_ARGUMENTS (fn); arg; arg = DECL_CHAIN (arg))
9887 /* Avoid duplicate -Wshadow warnings. */
9888 DECL_NAME (arg) = NULL_TREE;
9889 DECL_CONTEXT (arg) = fn;
9892 DECL_INTERFACE_KNOWN (fn) = 1;
9894 add_method (type, fn, NULL_TREE);
9897 push_function_context ();
9899 /* Still increment function_depth so that we don't GC in the
9900 middle of an expression. */
9903 /* Generate the body of the thunk. */
9905 start_preparsed_function (statfn, NULL_TREE,
9906 SF_PRE_PARSED | SF_INCLASS_INLINE);
9907 if (DECL_ONE_ONLY (statfn))
9909 /* Put the thunk in the same comdat group as the call op. */
9910 symtab_add_to_same_comdat_group
9911 ((symtab_node) cgraph_get_create_node (statfn),
9912 (symtab_node) cgraph_get_create_node (callop));
9914 body = begin_function_body ();
9915 compound_stmt = begin_compound_stmt (0);
9917 arg = build1 (NOP_EXPR, TREE_TYPE (DECL_ARGUMENTS (callop)),
9919 argvec = make_tree_vector ();
9920 argvec->quick_push (arg);
9921 for (arg = DECL_ARGUMENTS (statfn); arg; arg = DECL_CHAIN (arg))
9923 mark_exp_read (arg);
9924 vec_safe_push (argvec, arg);
9926 call = build_call_a (callop, argvec->length (), argvec->address ());
9927 CALL_FROM_THUNK_P (call) = 1;
9928 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (call)))
9929 call = build_cplus_new (TREE_TYPE (call), call, tf_warning_or_error);
9930 call = convert_from_reference (call);
9931 finish_return_stmt (call);
9933 finish_compound_stmt (compound_stmt);
9934 finish_function_body (body);
9936 expand_or_defer_fn (finish_function (2));
9938 /* Generate the body of the conversion op. */
9940 start_preparsed_function (convfn, NULL_TREE,
9941 SF_PRE_PARSED | SF_INCLASS_INLINE);
9942 body = begin_function_body ();
9943 compound_stmt = begin_compound_stmt (0);
9945 /* decl_needed_p needs to see that it's used. */
9946 TREE_USED (statfn) = 1;
9947 finish_return_stmt (decay_conversion (statfn, tf_warning_or_error));
9949 finish_compound_stmt (compound_stmt);
9950 finish_function_body (body);
9952 expand_or_defer_fn (finish_function (2));
9955 pop_function_context ();
9960 /* Returns true iff VAL is a lambda-related declaration which should
9961 be ignored by unqualified lookup. */
9964 is_lambda_ignored_entity (tree val)
9966 /* In unevaluated context, look past normal capture proxies. */
9967 if (cp_unevaluated_operand && is_normal_capture_proxy (val))
9970 /* Always ignore lambda fields, their names are only for debugging. */
9971 if (TREE_CODE (val) == FIELD_DECL
9972 && CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (val)))
9975 /* None of the lookups that use qualify_lookup want the op() from the
9976 lambda; they want the one from the enclosing class. */
9977 if (TREE_CODE (val) == FUNCTION_DECL && LAMBDA_FUNCTION_P (val))
9983 #include "gt-cp-semantics.h"