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);
648 /* Begin an if-statement. Returns a newly created IF_STMT if
655 scope = do_pushlevel (sk_cond);
656 r = build_stmt (input_location, IF_STMT, NULL_TREE,
657 NULL_TREE, NULL_TREE, scope);
658 begin_cond (&IF_COND (r));
662 /* Process the COND of an if-statement, which may be given by
666 finish_if_stmt_cond (tree cond, tree if_stmt)
668 finish_cond (&IF_COND (if_stmt), maybe_convert_cond (cond));
670 THEN_CLAUSE (if_stmt) = push_stmt_list ();
673 /* Finish the then-clause of an if-statement, which may be given by
677 finish_then_clause (tree if_stmt)
679 THEN_CLAUSE (if_stmt) = pop_stmt_list (THEN_CLAUSE (if_stmt));
683 /* Begin the else-clause of an if-statement. */
686 begin_else_clause (tree if_stmt)
688 ELSE_CLAUSE (if_stmt) = push_stmt_list ();
691 /* Finish the else-clause of an if-statement, which may be given by
695 finish_else_clause (tree if_stmt)
697 ELSE_CLAUSE (if_stmt) = pop_stmt_list (ELSE_CLAUSE (if_stmt));
700 /* Finish an if-statement. */
703 finish_if_stmt (tree if_stmt)
705 tree scope = IF_SCOPE (if_stmt);
706 IF_SCOPE (if_stmt) = NULL;
707 add_stmt (do_poplevel (scope));
710 /* Begin a while-statement. Returns a newly created WHILE_STMT if
714 begin_while_stmt (void)
717 r = build_stmt (input_location, WHILE_STMT, NULL_TREE, NULL_TREE);
719 WHILE_BODY (r) = do_pushlevel (sk_block);
720 begin_cond (&WHILE_COND (r));
724 /* Process the COND of a while-statement, which may be given by
728 finish_while_stmt_cond (tree cond, tree while_stmt)
730 finish_cond (&WHILE_COND (while_stmt), maybe_convert_cond (cond));
731 simplify_loop_decl_cond (&WHILE_COND (while_stmt), WHILE_BODY (while_stmt));
734 /* Finish a while-statement, which may be given by WHILE_STMT. */
737 finish_while_stmt (tree while_stmt)
739 WHILE_BODY (while_stmt) = do_poplevel (WHILE_BODY (while_stmt));
742 /* Begin a do-statement. Returns a newly created DO_STMT if
748 tree r = build_stmt (input_location, DO_STMT, NULL_TREE, NULL_TREE);
750 DO_BODY (r) = push_stmt_list ();
754 /* Finish the body of a do-statement, which may be given by DO_STMT. */
757 finish_do_body (tree do_stmt)
759 tree body = DO_BODY (do_stmt) = pop_stmt_list (DO_BODY (do_stmt));
761 if (TREE_CODE (body) == STATEMENT_LIST && STATEMENT_LIST_TAIL (body))
762 body = STATEMENT_LIST_TAIL (body)->stmt;
764 if (IS_EMPTY_STMT (body))
765 warning (OPT_Wempty_body,
766 "suggest explicit braces around empty body in %<do%> statement");
769 /* Finish a do-statement, which may be given by DO_STMT, and whose
770 COND is as indicated. */
773 finish_do_stmt (tree cond, tree do_stmt)
775 cond = maybe_convert_cond (cond);
776 DO_COND (do_stmt) = cond;
779 /* Finish a return-statement. The EXPRESSION returned, if any, is as
783 finish_return_stmt (tree expr)
788 expr = check_return_expr (expr, &no_warning);
790 if (flag_openmp && !check_omp_return ())
791 return error_mark_node;
792 if (!processing_template_decl)
794 if (warn_sequence_point)
795 verify_sequence_points (expr);
797 if (DECL_DESTRUCTOR_P (current_function_decl)
798 || (DECL_CONSTRUCTOR_P (current_function_decl)
799 && targetm.cxx.cdtor_returns_this ()))
801 /* Similarly, all destructors must run destructors for
802 base-classes before returning. So, all returns in a
803 destructor get sent to the DTOR_LABEL; finish_function emits
804 code to return a value there. */
805 return finish_goto_stmt (cdtor_label);
809 r = build_stmt (input_location, RETURN_EXPR, expr);
810 TREE_NO_WARNING (r) |= no_warning;
811 r = maybe_cleanup_point_expr_void (r);
817 /* Begin the scope of a for-statement or a range-for-statement.
818 Both the returned trees are to be used in a call to
819 begin_for_stmt or begin_range_for_stmt. */
822 begin_for_scope (tree *init)
824 tree scope = NULL_TREE;
825 if (flag_new_for_scope > 0)
826 scope = do_pushlevel (sk_for);
828 if (processing_template_decl)
829 *init = push_stmt_list ();
836 /* Begin a for-statement. Returns a new FOR_STMT.
837 SCOPE and INIT should be the return of begin_for_scope,
841 begin_for_stmt (tree scope, tree init)
845 r = build_stmt (input_location, FOR_STMT, NULL_TREE, NULL_TREE,
846 NULL_TREE, NULL_TREE, NULL_TREE);
848 if (scope == NULL_TREE)
850 gcc_assert (!init || !(flag_new_for_scope > 0));
852 scope = begin_for_scope (&init);
854 FOR_INIT_STMT (r) = init;
855 FOR_SCOPE (r) = scope;
860 /* Finish the for-init-statement of a for-statement, which may be
861 given by FOR_STMT. */
864 finish_for_init_stmt (tree for_stmt)
866 if (processing_template_decl)
867 FOR_INIT_STMT (for_stmt) = pop_stmt_list (FOR_INIT_STMT (for_stmt));
869 FOR_BODY (for_stmt) = do_pushlevel (sk_block);
870 begin_cond (&FOR_COND (for_stmt));
873 /* Finish the COND of a for-statement, which may be given by
877 finish_for_cond (tree cond, tree for_stmt)
879 finish_cond (&FOR_COND (for_stmt), maybe_convert_cond (cond));
880 simplify_loop_decl_cond (&FOR_COND (for_stmt), FOR_BODY (for_stmt));
883 /* Finish the increment-EXPRESSION in a for-statement, which may be
884 given by FOR_STMT. */
887 finish_for_expr (tree expr, tree for_stmt)
891 /* If EXPR is an overloaded function, issue an error; there is no
892 context available to use to perform overload resolution. */
893 if (type_unknown_p (expr))
895 cxx_incomplete_type_error (expr, TREE_TYPE (expr));
896 expr = error_mark_node;
898 if (!processing_template_decl)
900 if (warn_sequence_point)
901 verify_sequence_points (expr);
902 expr = convert_to_void (expr, ICV_THIRD_IN_FOR,
903 tf_warning_or_error);
905 else if (!type_dependent_expression_p (expr))
906 convert_to_void (build_non_dependent_expr (expr), ICV_THIRD_IN_FOR,
907 tf_warning_or_error);
908 expr = maybe_cleanup_point_expr_void (expr);
909 if (check_for_bare_parameter_packs (expr))
910 expr = error_mark_node;
911 FOR_EXPR (for_stmt) = expr;
914 /* Finish the body of a for-statement, which may be given by
915 FOR_STMT. The increment-EXPR for the loop must be
917 It can also finish RANGE_FOR_STMT. */
920 finish_for_stmt (tree for_stmt)
922 if (TREE_CODE (for_stmt) == RANGE_FOR_STMT)
923 RANGE_FOR_BODY (for_stmt) = do_poplevel (RANGE_FOR_BODY (for_stmt));
925 FOR_BODY (for_stmt) = do_poplevel (FOR_BODY (for_stmt));
927 /* Pop the scope for the body of the loop. */
928 if (flag_new_for_scope > 0)
931 tree *scope_ptr = (TREE_CODE (for_stmt) == RANGE_FOR_STMT
932 ? &RANGE_FOR_SCOPE (for_stmt)
933 : &FOR_SCOPE (for_stmt));
936 add_stmt (do_poplevel (scope));
940 /* Begin a range-for-statement. Returns a new RANGE_FOR_STMT.
941 SCOPE and INIT should be the return of begin_for_scope,
943 To finish it call finish_for_stmt(). */
946 begin_range_for_stmt (tree scope, tree init)
950 r = build_stmt (input_location, RANGE_FOR_STMT,
951 NULL_TREE, NULL_TREE, NULL_TREE, NULL_TREE);
953 if (scope == NULL_TREE)
955 gcc_assert (!init || !(flag_new_for_scope > 0));
957 scope = begin_for_scope (&init);
960 /* RANGE_FOR_STMTs do not use nor save the init tree, so we
963 pop_stmt_list (init);
964 RANGE_FOR_SCOPE (r) = scope;
969 /* Finish the head of a range-based for statement, which may
970 be given by RANGE_FOR_STMT. DECL must be the declaration
971 and EXPR must be the loop expression. */
974 finish_range_for_decl (tree range_for_stmt, tree decl, tree expr)
976 RANGE_FOR_DECL (range_for_stmt) = decl;
977 RANGE_FOR_EXPR (range_for_stmt) = expr;
978 add_stmt (range_for_stmt);
979 RANGE_FOR_BODY (range_for_stmt) = do_pushlevel (sk_block);
982 /* Finish a break-statement. */
985 finish_break_stmt (void)
987 /* In switch statements break is sometimes stylistically used after
988 a return statement. This can lead to spurious warnings about
989 control reaching the end of a non-void function when it is
990 inlined. Note that we are calling block_may_fallthru with
991 language specific tree nodes; this works because
992 block_may_fallthru returns true when given something it does not
994 if (!block_may_fallthru (cur_stmt_list))
995 return void_zero_node;
996 return add_stmt (build_stmt (input_location, BREAK_STMT));
999 /* Finish a continue-statement. */
1002 finish_continue_stmt (void)
1004 return add_stmt (build_stmt (input_location, CONTINUE_STMT));
1007 /* Begin a switch-statement. Returns a new SWITCH_STMT if
1011 begin_switch_stmt (void)
1015 scope = do_pushlevel (sk_cond);
1016 r = build_stmt (input_location, SWITCH_STMT, NULL_TREE, NULL_TREE, NULL_TREE, scope);
1018 begin_cond (&SWITCH_STMT_COND (r));
1023 /* Finish the cond of a switch-statement. */
1026 finish_switch_cond (tree cond, tree switch_stmt)
1028 tree orig_type = NULL;
1029 if (!processing_template_decl)
1031 /* Convert the condition to an integer or enumeration type. */
1032 cond = build_expr_type_conversion (WANT_INT | WANT_ENUM, cond, true);
1033 if (cond == NULL_TREE)
1035 error ("switch quantity not an integer");
1036 cond = error_mark_node;
1038 orig_type = TREE_TYPE (cond);
1039 if (cond != error_mark_node)
1043 Integral promotions are performed. */
1044 cond = perform_integral_promotions (cond);
1045 cond = maybe_cleanup_point_expr (cond);
1048 if (check_for_bare_parameter_packs (cond))
1049 cond = error_mark_node;
1050 else if (!processing_template_decl && warn_sequence_point)
1051 verify_sequence_points (cond);
1053 finish_cond (&SWITCH_STMT_COND (switch_stmt), cond);
1054 SWITCH_STMT_TYPE (switch_stmt) = orig_type;
1055 add_stmt (switch_stmt);
1056 push_switch (switch_stmt);
1057 SWITCH_STMT_BODY (switch_stmt) = push_stmt_list ();
1060 /* Finish the body of a switch-statement, which may be given by
1061 SWITCH_STMT. The COND to switch on is indicated. */
1064 finish_switch_stmt (tree switch_stmt)
1068 SWITCH_STMT_BODY (switch_stmt) =
1069 pop_stmt_list (SWITCH_STMT_BODY (switch_stmt));
1072 scope = SWITCH_STMT_SCOPE (switch_stmt);
1073 SWITCH_STMT_SCOPE (switch_stmt) = NULL;
1074 add_stmt (do_poplevel (scope));
1077 /* Begin a try-block. Returns a newly-created TRY_BLOCK if
1081 begin_try_block (void)
1083 tree r = build_stmt (input_location, TRY_BLOCK, NULL_TREE, NULL_TREE);
1085 TRY_STMTS (r) = push_stmt_list ();
1089 /* Likewise, for a function-try-block. The block returned in
1090 *COMPOUND_STMT is an artificial outer scope, containing the
1091 function-try-block. */
1094 begin_function_try_block (tree *compound_stmt)
1097 /* This outer scope does not exist in the C++ standard, but we need
1098 a place to put __FUNCTION__ and similar variables. */
1099 *compound_stmt = begin_compound_stmt (0);
1100 r = begin_try_block ();
1101 FN_TRY_BLOCK_P (r) = 1;
1105 /* Finish a try-block, which may be given by TRY_BLOCK. */
1108 finish_try_block (tree try_block)
1110 TRY_STMTS (try_block) = pop_stmt_list (TRY_STMTS (try_block));
1111 TRY_HANDLERS (try_block) = push_stmt_list ();
1114 /* Finish the body of a cleanup try-block, which may be given by
1118 finish_cleanup_try_block (tree try_block)
1120 TRY_STMTS (try_block) = pop_stmt_list (TRY_STMTS (try_block));
1123 /* Finish an implicitly generated try-block, with a cleanup is given
1127 finish_cleanup (tree cleanup, tree try_block)
1129 TRY_HANDLERS (try_block) = cleanup;
1130 CLEANUP_P (try_block) = 1;
1133 /* Likewise, for a function-try-block. */
1136 finish_function_try_block (tree try_block)
1138 finish_try_block (try_block);
1139 /* FIXME : something queer about CTOR_INITIALIZER somehow following
1140 the try block, but moving it inside. */
1141 in_function_try_handler = 1;
1144 /* Finish a handler-sequence for a try-block, which may be given by
1148 finish_handler_sequence (tree try_block)
1150 TRY_HANDLERS (try_block) = pop_stmt_list (TRY_HANDLERS (try_block));
1151 check_handlers (TRY_HANDLERS (try_block));
1154 /* Finish the handler-seq for a function-try-block, given by
1155 TRY_BLOCK. COMPOUND_STMT is the outer block created by
1156 begin_function_try_block. */
1159 finish_function_handler_sequence (tree try_block, tree compound_stmt)
1161 in_function_try_handler = 0;
1162 finish_handler_sequence (try_block);
1163 finish_compound_stmt (compound_stmt);
1166 /* Begin a handler. Returns a HANDLER if appropriate. */
1169 begin_handler (void)
1173 r = build_stmt (input_location, HANDLER, NULL_TREE, NULL_TREE);
1176 /* Create a binding level for the eh_info and the exception object
1178 HANDLER_BODY (r) = do_pushlevel (sk_catch);
1183 /* Finish the handler-parameters for a handler, which may be given by
1184 HANDLER. DECL is the declaration for the catch parameter, or NULL
1185 if this is a `catch (...)' clause. */
1188 finish_handler_parms (tree decl, tree handler)
1190 tree type = NULL_TREE;
1191 if (processing_template_decl)
1195 decl = pushdecl (decl);
1196 decl = push_template_decl (decl);
1197 HANDLER_PARMS (handler) = decl;
1198 type = TREE_TYPE (decl);
1202 type = expand_start_catch_block (decl);
1203 HANDLER_TYPE (handler) = type;
1206 /* Finish a handler, which may be given by HANDLER. The BLOCKs are
1207 the return value from the matching call to finish_handler_parms. */
1210 finish_handler (tree handler)
1212 if (!processing_template_decl)
1213 expand_end_catch_block ();
1214 HANDLER_BODY (handler) = do_poplevel (HANDLER_BODY (handler));
1217 /* Begin a compound statement. FLAGS contains some bits that control the
1218 behavior and context. If BCS_NO_SCOPE is set, the compound statement
1219 does not define a scope. If BCS_FN_BODY is set, this is the outermost
1220 block of a function. If BCS_TRY_BLOCK is set, this is the block
1221 created on behalf of a TRY statement. Returns a token to be passed to
1222 finish_compound_stmt. */
1225 begin_compound_stmt (unsigned int flags)
1229 if (flags & BCS_NO_SCOPE)
1231 r = push_stmt_list ();
1232 STATEMENT_LIST_NO_SCOPE (r) = 1;
1234 /* Normally, we try hard to keep the BLOCK for a statement-expression.
1235 But, if it's a statement-expression with a scopeless block, there's
1236 nothing to keep, and we don't want to accidentally keep a block
1237 *inside* the scopeless block. */
1238 keep_next_level (false);
1241 r = do_pushlevel (flags & BCS_TRY_BLOCK ? sk_try : sk_block);
1243 /* When processing a template, we need to remember where the braces were,
1244 so that we can set up identical scopes when instantiating the template
1245 later. BIND_EXPR is a handy candidate for this.
1246 Note that do_poplevel won't create a BIND_EXPR itself here (and thus
1247 result in nested BIND_EXPRs), since we don't build BLOCK nodes when
1248 processing templates. */
1249 if (processing_template_decl)
1251 r = build3 (BIND_EXPR, NULL, NULL, r, NULL);
1252 BIND_EXPR_TRY_BLOCK (r) = (flags & BCS_TRY_BLOCK) != 0;
1253 BIND_EXPR_BODY_BLOCK (r) = (flags & BCS_FN_BODY) != 0;
1254 TREE_SIDE_EFFECTS (r) = 1;
1260 /* Finish a compound-statement, which is given by STMT. */
1263 finish_compound_stmt (tree stmt)
1265 if (TREE_CODE (stmt) == BIND_EXPR)
1267 tree body = do_poplevel (BIND_EXPR_BODY (stmt));
1268 /* If the STATEMENT_LIST is empty and this BIND_EXPR isn't special,
1269 discard the BIND_EXPR so it can be merged with the containing
1271 if (TREE_CODE (body) == STATEMENT_LIST
1272 && STATEMENT_LIST_HEAD (body) == NULL
1273 && !BIND_EXPR_BODY_BLOCK (stmt)
1274 && !BIND_EXPR_TRY_BLOCK (stmt))
1277 BIND_EXPR_BODY (stmt) = body;
1279 else if (STATEMENT_LIST_NO_SCOPE (stmt))
1280 stmt = pop_stmt_list (stmt);
1283 /* Destroy any ObjC "super" receivers that may have been
1285 objc_clear_super_receiver ();
1287 stmt = do_poplevel (stmt);
1290 /* ??? See c_end_compound_stmt wrt statement expressions. */
1294 /* Finish an asm-statement, whose components are a STRING, some
1295 OUTPUT_OPERANDS, some INPUT_OPERANDS, some CLOBBERS and some
1296 LABELS. Also note whether the asm-statement should be
1297 considered volatile. */
1300 finish_asm_stmt (int volatile_p, tree string, tree output_operands,
1301 tree input_operands, tree clobbers, tree labels)
1305 int ninputs = list_length (input_operands);
1306 int noutputs = list_length (output_operands);
1308 if (!processing_template_decl)
1310 const char *constraint;
1311 const char **oconstraints;
1312 bool allows_mem, allows_reg, is_inout;
1316 oconstraints = XALLOCAVEC (const char *, noutputs);
1318 string = resolve_asm_operand_names (string, output_operands,
1319 input_operands, labels);
1321 for (i = 0, t = output_operands; t; t = TREE_CHAIN (t), ++i)
1323 operand = TREE_VALUE (t);
1325 /* ??? Really, this should not be here. Users should be using a
1326 proper lvalue, dammit. But there's a long history of using
1327 casts in the output operands. In cases like longlong.h, this
1328 becomes a primitive form of typechecking -- if the cast can be
1329 removed, then the output operand had a type of the proper width;
1330 otherwise we'll get an error. Gross, but ... */
1331 STRIP_NOPS (operand);
1333 operand = mark_lvalue_use (operand);
1335 if (!lvalue_or_else (operand, lv_asm, tf_warning_or_error))
1336 operand = error_mark_node;
1338 if (operand != error_mark_node
1339 && (TREE_READONLY (operand)
1340 || CP_TYPE_CONST_P (TREE_TYPE (operand))
1341 /* Functions are not modifiable, even though they are
1343 || TREE_CODE (TREE_TYPE (operand)) == FUNCTION_TYPE
1344 || TREE_CODE (TREE_TYPE (operand)) == METHOD_TYPE
1345 /* If it's an aggregate and any field is const, then it is
1346 effectively const. */
1347 || (CLASS_TYPE_P (TREE_TYPE (operand))
1348 && C_TYPE_FIELDS_READONLY (TREE_TYPE (operand)))))
1349 cxx_readonly_error (operand, lv_asm);
1351 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t)));
1352 oconstraints[i] = constraint;
1354 if (parse_output_constraint (&constraint, i, ninputs, noutputs,
1355 &allows_mem, &allows_reg, &is_inout))
1357 /* If the operand is going to end up in memory,
1358 mark it addressable. */
1359 if (!allows_reg && !cxx_mark_addressable (operand))
1360 operand = error_mark_node;
1363 operand = error_mark_node;
1365 TREE_VALUE (t) = operand;
1368 for (i = 0, t = input_operands; t; ++i, t = TREE_CHAIN (t))
1370 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t)));
1371 bool constraint_parsed
1372 = parse_input_constraint (&constraint, i, ninputs, noutputs, 0,
1373 oconstraints, &allows_mem, &allows_reg);
1374 /* If the operand is going to end up in memory, don't call
1375 decay_conversion. */
1376 if (constraint_parsed && !allows_reg && allows_mem)
1377 operand = mark_lvalue_use (TREE_VALUE (t));
1379 operand = decay_conversion (TREE_VALUE (t), tf_warning_or_error);
1381 /* If the type of the operand hasn't been determined (e.g.,
1382 because it involves an overloaded function), then issue
1383 an error message. There's no context available to
1384 resolve the overloading. */
1385 if (TREE_TYPE (operand) == unknown_type_node)
1387 error ("type of asm operand %qE could not be determined",
1389 operand = error_mark_node;
1392 if (constraint_parsed)
1394 /* If the operand is going to end up in memory,
1395 mark it addressable. */
1396 if (!allows_reg && allows_mem)
1398 /* Strip the nops as we allow this case. FIXME, this really
1399 should be rejected or made deprecated. */
1400 STRIP_NOPS (operand);
1401 if (!cxx_mark_addressable (operand))
1402 operand = error_mark_node;
1404 else if (!allows_reg && !allows_mem)
1406 /* If constraint allows neither register nor memory,
1407 try harder to get a constant. */
1408 tree constop = maybe_constant_value (operand);
1409 if (TREE_CONSTANT (constop))
1414 operand = error_mark_node;
1416 TREE_VALUE (t) = operand;
1420 r = build_stmt (input_location, ASM_EXPR, string,
1421 output_operands, input_operands,
1423 ASM_VOLATILE_P (r) = volatile_p || noutputs == 0;
1424 r = maybe_cleanup_point_expr_void (r);
1425 return add_stmt (r);
1428 /* Finish a label with the indicated NAME. Returns the new label. */
1431 finish_label_stmt (tree name)
1433 tree decl = define_label (input_location, name);
1435 if (decl == error_mark_node)
1436 return error_mark_node;
1438 add_stmt (build_stmt (input_location, LABEL_EXPR, decl));
1443 /* Finish a series of declarations for local labels. G++ allows users
1444 to declare "local" labels, i.e., labels with scope. This extension
1445 is useful when writing code involving statement-expressions. */
1448 finish_label_decl (tree name)
1450 if (!at_function_scope_p ())
1452 error ("__label__ declarations are only allowed in function scopes");
1456 add_decl_expr (declare_local_label (name));
1459 /* When DECL goes out of scope, make sure that CLEANUP is executed. */
1462 finish_decl_cleanup (tree decl, tree cleanup)
1464 push_cleanup (decl, cleanup, false);
1467 /* If the current scope exits with an exception, run CLEANUP. */
1470 finish_eh_cleanup (tree cleanup)
1472 push_cleanup (NULL, cleanup, true);
1475 /* The MEM_INITS is a list of mem-initializers, in reverse of the
1476 order they were written by the user. Each node is as for
1477 emit_mem_initializers. */
1480 finish_mem_initializers (tree mem_inits)
1482 /* Reorder the MEM_INITS so that they are in the order they appeared
1483 in the source program. */
1484 mem_inits = nreverse (mem_inits);
1486 if (processing_template_decl)
1490 for (mem = mem_inits; mem; mem = TREE_CHAIN (mem))
1492 /* If the TREE_PURPOSE is a TYPE_PACK_EXPANSION, skip the
1493 check for bare parameter packs in the TREE_VALUE, because
1494 any parameter packs in the TREE_VALUE have already been
1495 bound as part of the TREE_PURPOSE. See
1496 make_pack_expansion for more information. */
1497 if (TREE_CODE (TREE_PURPOSE (mem)) != TYPE_PACK_EXPANSION
1498 && check_for_bare_parameter_packs (TREE_VALUE (mem)))
1499 TREE_VALUE (mem) = error_mark_node;
1502 add_stmt (build_min_nt_loc (UNKNOWN_LOCATION,
1503 CTOR_INITIALIZER, mem_inits));
1506 emit_mem_initializers (mem_inits);
1509 /* Obfuscate EXPR if it looks like an id-expression or member access so
1510 that the call to finish_decltype in do_auto_deduction will give the
1514 force_paren_expr (tree expr)
1516 /* This is only needed for decltype(auto) in C++14. */
1517 if (cxx_dialect < cxx1y)
1520 if (!DECL_P (expr) && TREE_CODE (expr) != COMPONENT_REF
1521 && TREE_CODE (expr) != SCOPE_REF)
1524 if (processing_template_decl)
1525 expr = build1 (PAREN_EXPR, TREE_TYPE (expr), expr);
1528 cp_lvalue_kind kind = lvalue_kind (expr);
1529 if ((kind & ~clk_class) != clk_none)
1531 tree type = unlowered_expr_type (expr);
1532 bool rval = !!(kind & clk_rvalueref);
1533 type = cp_build_reference_type (type, rval);
1534 expr = build_static_cast (type, expr, tf_warning_or_error);
1541 /* Finish a parenthesized expression EXPR. */
1544 finish_parenthesized_expr (tree expr)
1547 /* This inhibits warnings in c_common_truthvalue_conversion. */
1548 TREE_NO_WARNING (expr) = 1;
1550 if (TREE_CODE (expr) == OFFSET_REF
1551 || TREE_CODE (expr) == SCOPE_REF)
1552 /* [expr.unary.op]/3 The qualified id of a pointer-to-member must not be
1553 enclosed in parentheses. */
1554 PTRMEM_OK_P (expr) = 0;
1556 if (TREE_CODE (expr) == STRING_CST)
1557 PAREN_STRING_LITERAL_P (expr) = 1;
1559 expr = force_paren_expr (expr);
1564 /* Finish a reference to a non-static data member (DECL) that is not
1565 preceded by `.' or `->'. */
1568 finish_non_static_data_member (tree decl, tree object, tree qualifying_scope)
1570 gcc_assert (TREE_CODE (decl) == FIELD_DECL);
1574 tree scope = qualifying_scope;
1575 if (scope == NULL_TREE)
1576 scope = context_for_name_lookup (decl);
1577 object = maybe_dummy_object (scope, NULL);
1580 object = maybe_resolve_dummy (object);
1581 if (object == error_mark_node)
1582 return error_mark_node;
1584 /* DR 613: Can use non-static data members without an associated
1585 object in sizeof/decltype/alignof. */
1586 if (is_dummy_object (object) && cp_unevaluated_operand == 0
1587 && (!processing_template_decl || !current_class_ref))
1589 if (current_function_decl
1590 && DECL_STATIC_FUNCTION_P (current_function_decl))
1591 error ("invalid use of member %q+D in static member function", decl);
1593 error ("invalid use of non-static data member %q+D", decl);
1594 error ("from this location");
1596 return error_mark_node;
1599 if (current_class_ptr)
1600 TREE_USED (current_class_ptr) = 1;
1601 if (processing_template_decl && !qualifying_scope)
1603 tree type = TREE_TYPE (decl);
1605 if (TREE_CODE (type) == REFERENCE_TYPE)
1606 /* Quals on the object don't matter. */;
1607 else if (PACK_EXPANSION_P (type))
1608 /* Don't bother trying to represent this. */
1612 /* Set the cv qualifiers. */
1613 int quals = cp_type_quals (TREE_TYPE (object));
1615 if (DECL_MUTABLE_P (decl))
1616 quals &= ~TYPE_QUAL_CONST;
1618 quals |= cp_type_quals (TREE_TYPE (decl));
1619 type = cp_build_qualified_type (type, quals);
1622 return (convert_from_reference
1623 (build_min (COMPONENT_REF, type, object, decl, NULL_TREE)));
1625 /* If PROCESSING_TEMPLATE_DECL is nonzero here, then
1626 QUALIFYING_SCOPE is also non-null. Wrap this in a SCOPE_REF
1628 else if (processing_template_decl)
1629 return build_qualified_name (TREE_TYPE (decl),
1632 /*template_p=*/false);
1635 tree access_type = TREE_TYPE (object);
1637 perform_or_defer_access_check (TYPE_BINFO (access_type), decl,
1638 decl, tf_warning_or_error);
1640 /* If the data member was named `C::M', convert `*this' to `C'
1642 if (qualifying_scope)
1644 tree binfo = NULL_TREE;
1645 object = build_scoped_ref (object, qualifying_scope,
1649 return build_class_member_access_expr (object, decl,
1650 /*access_path=*/NULL_TREE,
1651 /*preserve_reference=*/false,
1652 tf_warning_or_error);
1656 /* If we are currently parsing a template and we encountered a typedef
1657 TYPEDEF_DECL that is being accessed though CONTEXT, this function
1658 adds the typedef to a list tied to the current template.
1659 At template instantiation time, that list is walked and access check
1660 performed for each typedef.
1661 LOCATION is the location of the usage point of TYPEDEF_DECL. */
1664 add_typedef_to_current_template_for_access_check (tree typedef_decl,
1666 location_t location)
1668 tree template_info = NULL;
1669 tree cs = current_scope ();
1671 if (!is_typedef_decl (typedef_decl)
1673 || !CLASS_TYPE_P (context)
1677 if (CLASS_TYPE_P (cs) || TREE_CODE (cs) == FUNCTION_DECL)
1678 template_info = get_template_info (cs);
1681 && TI_TEMPLATE (template_info)
1682 && !currently_open_class (context))
1683 append_type_to_template_for_access_check (cs, typedef_decl,
1687 /* DECL was the declaration to which a qualified-id resolved. Issue
1688 an error message if it is not accessible. If OBJECT_TYPE is
1689 non-NULL, we have just seen `x->' or `x.' and OBJECT_TYPE is the
1690 type of `*x', or `x', respectively. If the DECL was named as
1691 `A::B' then NESTED_NAME_SPECIFIER is `A'. */
1694 check_accessibility_of_qualified_id (tree decl,
1696 tree nested_name_specifier)
1699 tree qualifying_type = NULL_TREE;
1701 /* If we are parsing a template declaration and if decl is a typedef,
1702 add it to a list tied to the template.
1703 At template instantiation time, that list will be walked and
1704 access check performed. */
1705 add_typedef_to_current_template_for_access_check (decl,
1706 nested_name_specifier
1707 ? nested_name_specifier
1708 : DECL_CONTEXT (decl),
1711 /* If we're not checking, return immediately. */
1712 if (deferred_access_no_check)
1715 /* Determine the SCOPE of DECL. */
1716 scope = context_for_name_lookup (decl);
1717 /* If the SCOPE is not a type, then DECL is not a member. */
1718 if (!TYPE_P (scope))
1720 /* Compute the scope through which DECL is being accessed. */
1722 /* OBJECT_TYPE might not be a class type; consider:
1724 class A { typedef int I; };
1728 In this case, we will have "A::I" as the DECL, but "I" as the
1730 && CLASS_TYPE_P (object_type)
1731 && DERIVED_FROM_P (scope, object_type))
1732 /* If we are processing a `->' or `.' expression, use the type of the
1734 qualifying_type = object_type;
1735 else if (nested_name_specifier)
1737 /* If the reference is to a non-static member of the
1738 current class, treat it as if it were referenced through
1740 if (DECL_NONSTATIC_MEMBER_P (decl)
1741 && current_class_ptr
1742 && DERIVED_FROM_P (scope, current_class_type))
1743 qualifying_type = current_class_type;
1744 /* Otherwise, use the type indicated by the
1745 nested-name-specifier. */
1747 qualifying_type = nested_name_specifier;
1750 /* Otherwise, the name must be from the current class or one of
1752 qualifying_type = currently_open_derived_class (scope);
1755 /* It is possible for qualifying type to be a TEMPLATE_TYPE_PARM
1756 or similar in a default argument value. */
1757 && CLASS_TYPE_P (qualifying_type)
1758 && !dependent_type_p (qualifying_type))
1759 perform_or_defer_access_check (TYPE_BINFO (qualifying_type), decl,
1760 decl, tf_warning_or_error);
1763 /* EXPR is the result of a qualified-id. The QUALIFYING_CLASS was the
1764 class named to the left of the "::" operator. DONE is true if this
1765 expression is a complete postfix-expression; it is false if this
1766 expression is followed by '->', '[', '(', etc. ADDRESS_P is true
1767 iff this expression is the operand of '&'. TEMPLATE_P is true iff
1768 the qualified-id was of the form "A::template B". TEMPLATE_ARG_P
1769 is true iff this qualified name appears as a template argument. */
1772 finish_qualified_id_expr (tree qualifying_class,
1777 bool template_arg_p,
1778 tsubst_flags_t complain)
1780 gcc_assert (TYPE_P (qualifying_class));
1782 if (error_operand_p (expr))
1783 return error_mark_node;
1785 if ((DECL_P (expr) || BASELINK_P (expr))
1786 && !mark_used (expr, complain))
1787 return error_mark_node;
1790 check_template_keyword (expr);
1792 /* If EXPR occurs as the operand of '&', use special handling that
1793 permits a pointer-to-member. */
1794 if (address_p && done)
1796 if (TREE_CODE (expr) == SCOPE_REF)
1797 expr = TREE_OPERAND (expr, 1);
1798 expr = build_offset_ref (qualifying_class, expr,
1799 /*address_p=*/true, complain);
1803 /* No need to check access within an enum. */
1804 if (TREE_CODE (qualifying_class) == ENUMERAL_TYPE)
1807 /* Within the scope of a class, turn references to non-static
1808 members into expression of the form "this->...". */
1810 /* But, within a template argument, we do not want make the
1811 transformation, as there is no "this" pointer. */
1813 else if (TREE_CODE (expr) == FIELD_DECL)
1815 push_deferring_access_checks (dk_no_check);
1816 expr = finish_non_static_data_member (expr, NULL_TREE,
1818 pop_deferring_access_checks ();
1820 else if (BASELINK_P (expr) && !processing_template_decl)
1822 /* See if any of the functions are non-static members. */
1823 /* If so, the expression may be relative to 'this'. */
1824 if (!shared_member_p (expr)
1825 && current_class_ptr
1826 && DERIVED_FROM_P (qualifying_class,
1827 current_nonlambda_class_type ()))
1828 expr = (build_class_member_access_expr
1829 (maybe_dummy_object (qualifying_class, NULL),
1831 BASELINK_ACCESS_BINFO (expr),
1832 /*preserve_reference=*/false,
1835 /* The expression is a qualified name whose address is not
1837 expr = build_offset_ref (qualifying_class, expr, /*address_p=*/false,
1840 else if (BASELINK_P (expr))
1844 /* In a template, return a SCOPE_REF for most qualified-ids
1845 so that we can check access at instantiation time. But if
1846 we're looking at a member of the current instantiation, we
1847 know we have access and building up the SCOPE_REF confuses
1848 non-type template argument handling. */
1849 if (processing_template_decl
1850 && !currently_open_class (qualifying_class))
1851 expr = build_qualified_name (TREE_TYPE (expr),
1852 qualifying_class, expr,
1855 expr = convert_from_reference (expr);
1861 /* Begin a statement-expression. The value returned must be passed to
1862 finish_stmt_expr. */
1865 begin_stmt_expr (void)
1867 return push_stmt_list ();
1870 /* Process the final expression of a statement expression. EXPR can be
1871 NULL, if the final expression is empty. Return a STATEMENT_LIST
1872 containing all the statements in the statement-expression, or
1873 ERROR_MARK_NODE if there was an error. */
1876 finish_stmt_expr_expr (tree expr, tree stmt_expr)
1878 if (error_operand_p (expr))
1880 /* The type of the statement-expression is the type of the last
1882 TREE_TYPE (stmt_expr) = error_mark_node;
1883 return error_mark_node;
1886 /* If the last statement does not have "void" type, then the value
1887 of the last statement is the value of the entire expression. */
1890 tree type = TREE_TYPE (expr);
1892 if (processing_template_decl)
1894 expr = build_stmt (input_location, EXPR_STMT, expr);
1895 expr = add_stmt (expr);
1896 /* Mark the last statement so that we can recognize it as such at
1897 template-instantiation time. */
1898 EXPR_STMT_STMT_EXPR_RESULT (expr) = 1;
1900 else if (VOID_TYPE_P (type))
1902 /* Just treat this like an ordinary statement. */
1903 expr = finish_expr_stmt (expr);
1907 /* It actually has a value we need to deal with. First, force it
1908 to be an rvalue so that we won't need to build up a copy
1909 constructor call later when we try to assign it to something. */
1910 expr = force_rvalue (expr, tf_warning_or_error);
1911 if (error_operand_p (expr))
1912 return error_mark_node;
1914 /* Update for array-to-pointer decay. */
1915 type = TREE_TYPE (expr);
1917 /* Wrap it in a CLEANUP_POINT_EXPR and add it to the list like a
1918 normal statement, but don't convert to void or actually add
1920 if (TREE_CODE (expr) != CLEANUP_POINT_EXPR)
1921 expr = maybe_cleanup_point_expr (expr);
1925 /* The type of the statement-expression is the type of the last
1927 TREE_TYPE (stmt_expr) = type;
1933 /* Finish a statement-expression. EXPR should be the value returned
1934 by the previous begin_stmt_expr. Returns an expression
1935 representing the statement-expression. */
1938 finish_stmt_expr (tree stmt_expr, bool has_no_scope)
1943 if (error_operand_p (stmt_expr))
1945 pop_stmt_list (stmt_expr);
1946 return error_mark_node;
1949 gcc_assert (TREE_CODE (stmt_expr) == STATEMENT_LIST);
1951 type = TREE_TYPE (stmt_expr);
1952 result = pop_stmt_list (stmt_expr);
1953 TREE_TYPE (result) = type;
1955 if (processing_template_decl)
1957 result = build_min (STMT_EXPR, type, result);
1958 TREE_SIDE_EFFECTS (result) = 1;
1959 STMT_EXPR_NO_SCOPE (result) = has_no_scope;
1961 else if (CLASS_TYPE_P (type))
1963 /* Wrap the statement-expression in a TARGET_EXPR so that the
1964 temporary object created by the final expression is destroyed at
1965 the end of the full-expression containing the
1966 statement-expression. */
1967 result = force_target_expr (type, result, tf_warning_or_error);
1973 /* Returns the expression which provides the value of STMT_EXPR. */
1976 stmt_expr_value_expr (tree stmt_expr)
1978 tree t = STMT_EXPR_STMT (stmt_expr);
1980 if (TREE_CODE (t) == BIND_EXPR)
1981 t = BIND_EXPR_BODY (t);
1983 if (TREE_CODE (t) == STATEMENT_LIST && STATEMENT_LIST_TAIL (t))
1984 t = STATEMENT_LIST_TAIL (t)->stmt;
1986 if (TREE_CODE (t) == EXPR_STMT)
1987 t = EXPR_STMT_EXPR (t);
1992 /* Return TRUE iff EXPR_STMT is an empty list of
1993 expression statements. */
1996 empty_expr_stmt_p (tree expr_stmt)
1998 tree body = NULL_TREE;
2000 if (expr_stmt == void_zero_node)
2005 if (TREE_CODE (expr_stmt) == EXPR_STMT)
2006 body = EXPR_STMT_EXPR (expr_stmt);
2007 else if (TREE_CODE (expr_stmt) == STATEMENT_LIST)
2013 if (TREE_CODE (body) == STATEMENT_LIST)
2014 return tsi_end_p (tsi_start (body));
2016 return empty_expr_stmt_p (body);
2021 /* Perform Koenig lookup. FN is the postfix-expression representing
2022 the function (or functions) to call; ARGS are the arguments to the
2023 call; if INCLUDE_STD then the `std' namespace is automatically
2024 considered an associated namespace (used in range-based for loops).
2025 Returns the functions to be considered by overload resolution. */
2028 perform_koenig_lookup (tree fn, vec<tree, va_gc> *args, bool include_std,
2029 tsubst_flags_t complain)
2031 tree identifier = NULL_TREE;
2032 tree functions = NULL_TREE;
2033 tree tmpl_args = NULL_TREE;
2034 bool template_id = false;
2036 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2038 /* Use a separate flag to handle null args. */
2040 tmpl_args = TREE_OPERAND (fn, 1);
2041 fn = TREE_OPERAND (fn, 0);
2044 /* Find the name of the overloaded function. */
2045 if (identifier_p (fn))
2047 else if (is_overloaded_fn (fn))
2050 identifier = DECL_NAME (get_first_fn (functions));
2052 else if (DECL_P (fn))
2055 identifier = DECL_NAME (fn);
2058 /* A call to a namespace-scope function using an unqualified name.
2060 Do Koenig lookup -- unless any of the arguments are
2062 if (!any_type_dependent_arguments_p (args)
2063 && !any_dependent_template_arguments_p (tmpl_args))
2065 fn = lookup_arg_dependent (identifier, functions, args, include_std);
2068 /* The unqualified name could not be resolved. */
2070 fn = unqualified_fn_lookup_error (identifier);
2076 if (fn && template_id)
2077 fn = build2 (TEMPLATE_ID_EXPR, unknown_type_node, fn, tmpl_args);
2082 /* Generate an expression for `FN (ARGS)'. This may change the
2085 If DISALLOW_VIRTUAL is true, the call to FN will be not generated
2086 as a virtual call, even if FN is virtual. (This flag is set when
2087 encountering an expression where the function name is explicitly
2088 qualified. For example a call to `X::f' never generates a virtual
2091 Returns code for the call. */
2094 finish_call_expr (tree fn, vec<tree, va_gc> **args, bool disallow_virtual,
2095 bool koenig_p, tsubst_flags_t complain)
2099 vec<tree, va_gc> *orig_args = NULL;
2101 if (fn == error_mark_node)
2102 return error_mark_node;
2104 gcc_assert (!TYPE_P (fn));
2108 if (processing_template_decl)
2110 /* If the call expression is dependent, build a CALL_EXPR node
2111 with no type; type_dependent_expression_p recognizes
2112 expressions with no type as being dependent. */
2113 if (type_dependent_expression_p (fn)
2114 || any_type_dependent_arguments_p (*args)
2115 /* For a non-static member function that doesn't have an
2116 explicit object argument, we need to specifically
2117 test the type dependency of the "this" pointer because it
2118 is not included in *ARGS even though it is considered to
2119 be part of the list of arguments. Note that this is
2120 related to CWG issues 515 and 1005. */
2121 || (TREE_CODE (fn) != COMPONENT_REF
2122 && non_static_member_function_p (fn)
2123 && current_class_ref
2124 && type_dependent_expression_p (current_class_ref)))
2126 result = build_nt_call_vec (fn, *args);
2127 SET_EXPR_LOCATION (result, EXPR_LOC_OR_HERE (fn));
2128 KOENIG_LOOKUP_P (result) = koenig_p;
2133 tree fndecl = OVL_CURRENT (fn);
2134 if (TREE_CODE (fndecl) != FUNCTION_DECL
2135 || !TREE_THIS_VOLATILE (fndecl))
2141 current_function_returns_abnormally = 1;
2145 orig_args = make_tree_vector_copy (*args);
2146 if (!BASELINK_P (fn)
2147 && TREE_CODE (fn) != PSEUDO_DTOR_EXPR
2148 && TREE_TYPE (fn) != unknown_type_node)
2149 fn = build_non_dependent_expr (fn);
2150 make_args_non_dependent (*args);
2153 if (TREE_CODE (fn) == COMPONENT_REF)
2155 tree member = TREE_OPERAND (fn, 1);
2156 if (BASELINK_P (member))
2158 tree object = TREE_OPERAND (fn, 0);
2159 return build_new_method_call (object, member,
2162 ? LOOKUP_NORMAL | LOOKUP_NONVIRTUAL
2169 if (is_overloaded_fn (fn))
2170 fn = baselink_for_fns (fn);
2173 if (BASELINK_P (fn))
2177 /* A call to a member function. From [over.call.func]:
2179 If the keyword this is in scope and refers to the class of
2180 that member function, or a derived class thereof, then the
2181 function call is transformed into a qualified function call
2182 using (*this) as the postfix-expression to the left of the
2183 . operator.... [Otherwise] a contrived object of type T
2184 becomes the implied object argument.
2188 struct A { void f(); };
2189 struct B : public A {};
2190 struct C : public A { void g() { B::f(); }};
2192 "the class of that member function" refers to `A'. But 11.2
2193 [class.access.base] says that we need to convert 'this' to B* as
2194 part of the access, so we pass 'B' to maybe_dummy_object. */
2196 object = maybe_dummy_object (BINFO_TYPE (BASELINK_ACCESS_BINFO (fn)),
2199 if (processing_template_decl)
2201 if (type_dependent_expression_p (object))
2203 tree ret = build_nt_call_vec (orig_fn, orig_args);
2204 release_tree_vector (orig_args);
2207 object = build_non_dependent_expr (object);
2210 result = build_new_method_call (object, fn, args, NULL_TREE,
2212 ? LOOKUP_NORMAL|LOOKUP_NONVIRTUAL
2217 else if (is_overloaded_fn (fn))
2219 /* If the function is an overloaded builtin, resolve it. */
2220 if (TREE_CODE (fn) == FUNCTION_DECL
2221 && (DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL
2222 || DECL_BUILT_IN_CLASS (fn) == BUILT_IN_MD))
2223 result = resolve_overloaded_builtin (input_location, fn, *args);
2227 if (warn_sizeof_pointer_memaccess
2228 && !vec_safe_is_empty (*args)
2229 && !processing_template_decl)
2231 location_t sizeof_arg_loc[3];
2234 for (i = 0; i < 3; i++)
2238 sizeof_arg_loc[i] = UNKNOWN_LOCATION;
2239 sizeof_arg[i] = NULL_TREE;
2240 if (i >= (*args)->length ())
2243 if (TREE_CODE (t) != SIZEOF_EXPR)
2245 if (SIZEOF_EXPR_TYPE_P (t))
2246 sizeof_arg[i] = TREE_TYPE (TREE_OPERAND (t, 0));
2248 sizeof_arg[i] = TREE_OPERAND (t, 0);
2249 sizeof_arg_loc[i] = EXPR_LOCATION (t);
2251 sizeof_pointer_memaccess_warning
2252 (sizeof_arg_loc, fn, *args,
2253 sizeof_arg, same_type_ignoring_top_level_qualifiers_p);
2256 /* A call to a namespace-scope function. */
2257 result = build_new_function_call (fn, args, koenig_p, complain);
2260 else if (TREE_CODE (fn) == PSEUDO_DTOR_EXPR)
2262 if (!vec_safe_is_empty (*args))
2263 error ("arguments to destructor are not allowed");
2264 /* Mark the pseudo-destructor call as having side-effects so
2265 that we do not issue warnings about its use. */
2266 result = build1 (NOP_EXPR,
2268 TREE_OPERAND (fn, 0));
2269 TREE_SIDE_EFFECTS (result) = 1;
2271 else if (CLASS_TYPE_P (TREE_TYPE (fn)))
2272 /* If the "function" is really an object of class type, it might
2273 have an overloaded `operator ()'. */
2274 result = build_op_call (fn, args, complain);
2277 /* A call where the function is unknown. */
2278 result = cp_build_function_call_vec (fn, args, complain);
2280 if (processing_template_decl && result != error_mark_node)
2282 if (INDIRECT_REF_P (result))
2283 result = TREE_OPERAND (result, 0);
2284 result = build_call_vec (TREE_TYPE (result), orig_fn, orig_args);
2285 SET_EXPR_LOCATION (result, input_location);
2286 KOENIG_LOOKUP_P (result) = koenig_p;
2287 release_tree_vector (orig_args);
2288 result = convert_from_reference (result);
2293 /* Free garbage OVERLOADs from arg-dependent lookup. */
2294 tree next = NULL_TREE;
2296 fn && TREE_CODE (fn) == OVERLOAD && OVL_ARG_DEPENDENT (fn);
2299 if (processing_template_decl)
2300 /* In a template, we'll re-use them at instantiation time. */
2301 OVL_ARG_DEPENDENT (fn) = false;
2304 next = OVL_CHAIN (fn);
2313 /* Finish a call to a postfix increment or decrement or EXPR. (Which
2314 is indicated by CODE, which should be POSTINCREMENT_EXPR or
2315 POSTDECREMENT_EXPR.) */
2318 finish_increment_expr (tree expr, enum tree_code code)
2320 return build_x_unary_op (input_location, code, expr, tf_warning_or_error);
2323 /* Finish a use of `this'. Returns an expression for `this'. */
2326 finish_this_expr (void)
2330 if (current_class_ptr)
2332 tree type = TREE_TYPE (current_class_ref);
2334 /* In a lambda expression, 'this' refers to the captured 'this'. */
2335 if (LAMBDA_TYPE_P (type))
2336 result = lambda_expr_this_capture (CLASSTYPE_LAMBDA_EXPR (type));
2338 result = current_class_ptr;
2340 else if (current_function_decl
2341 && DECL_STATIC_FUNCTION_P (current_function_decl))
2343 error ("%<this%> is unavailable for static member functions");
2344 result = error_mark_node;
2348 if (current_function_decl)
2349 error ("invalid use of %<this%> in non-member function");
2351 error ("invalid use of %<this%> at top level");
2352 result = error_mark_node;
2355 /* The keyword 'this' is a prvalue expression. */
2356 result = rvalue (result);
2361 /* Finish a pseudo-destructor expression. If SCOPE is NULL, the
2362 expression was of the form `OBJECT.~DESTRUCTOR' where DESTRUCTOR is
2363 the TYPE for the type given. If SCOPE is non-NULL, the expression
2364 was of the form `OBJECT.SCOPE::~DESTRUCTOR'. */
2367 finish_pseudo_destructor_expr (tree object, tree scope, tree destructor,
2370 if (object == error_mark_node || destructor == error_mark_node)
2371 return error_mark_node;
2373 gcc_assert (TYPE_P (destructor));
2375 if (!processing_template_decl)
2377 if (scope == error_mark_node)
2379 error_at (loc, "invalid qualifying scope in pseudo-destructor name");
2380 return error_mark_node;
2382 if (is_auto (destructor))
2383 destructor = TREE_TYPE (object);
2384 if (scope && TYPE_P (scope) && !check_dtor_name (scope, destructor))
2387 "qualified type %qT does not match destructor name ~%qT",
2389 return error_mark_node;
2393 /* [expr.pseudo] says both:
2395 The type designated by the pseudo-destructor-name shall be
2396 the same as the object type.
2400 The cv-unqualified versions of the object type and of the
2401 type designated by the pseudo-destructor-name shall be the
2404 We implement the more generous second sentence, since that is
2405 what most other compilers do. */
2406 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (object),
2409 error_at (loc, "%qE is not of type %qT", object, destructor);
2410 return error_mark_node;
2414 return build3_loc (loc, PSEUDO_DTOR_EXPR, void_type_node, object,
2418 /* Finish an expression of the form CODE EXPR. */
2421 finish_unary_op_expr (location_t loc, enum tree_code code, tree expr,
2422 tsubst_flags_t complain)
2424 tree result = build_x_unary_op (loc, code, expr, complain);
2425 if ((complain & tf_warning)
2426 && TREE_OVERFLOW_P (result) && !TREE_OVERFLOW_P (expr))
2427 overflow_warning (input_location, result);
2432 /* Finish a compound-literal expression. TYPE is the type to which
2433 the CONSTRUCTOR in COMPOUND_LITERAL is being cast. */
2436 finish_compound_literal (tree type, tree compound_literal,
2437 tsubst_flags_t complain)
2439 if (type == error_mark_node)
2440 return error_mark_node;
2442 if (TREE_CODE (type) == REFERENCE_TYPE)
2445 = finish_compound_literal (TREE_TYPE (type), compound_literal,
2447 return cp_build_c_cast (type, compound_literal, complain);
2450 if (!TYPE_OBJ_P (type))
2452 if (complain & tf_error)
2453 error ("compound literal of non-object type %qT", type);
2454 return error_mark_node;
2457 if (processing_template_decl)
2459 TREE_TYPE (compound_literal) = type;
2460 /* Mark the expression as a compound literal. */
2461 TREE_HAS_CONSTRUCTOR (compound_literal) = 1;
2462 return compound_literal;
2465 type = complete_type (type);
2467 if (TYPE_NON_AGGREGATE_CLASS (type))
2469 /* Trying to deal with a CONSTRUCTOR instead of a TREE_LIST
2470 everywhere that deals with function arguments would be a pain, so
2471 just wrap it in a TREE_LIST. The parser set a flag so we know
2472 that it came from T{} rather than T({}). */
2473 CONSTRUCTOR_IS_DIRECT_INIT (compound_literal) = 1;
2474 compound_literal = build_tree_list (NULL_TREE, compound_literal);
2475 return build_functional_cast (type, compound_literal, complain);
2478 if (TREE_CODE (type) == ARRAY_TYPE
2479 && check_array_initializer (NULL_TREE, type, compound_literal))
2480 return error_mark_node;
2481 compound_literal = reshape_init (type, compound_literal, complain);
2482 if (SCALAR_TYPE_P (type)
2483 && !BRACE_ENCLOSED_INITIALIZER_P (compound_literal)
2484 && (complain & tf_warning_or_error))
2485 check_narrowing (type, compound_literal);
2486 if (TREE_CODE (type) == ARRAY_TYPE
2487 && TYPE_DOMAIN (type) == NULL_TREE)
2489 cp_complete_array_type_or_error (&type, compound_literal,
2491 if (type == error_mark_node)
2492 return error_mark_node;
2494 compound_literal = digest_init (type, compound_literal, complain);
2495 if (TREE_CODE (compound_literal) == CONSTRUCTOR)
2496 TREE_HAS_CONSTRUCTOR (compound_literal) = true;
2497 /* Put static/constant array temporaries in static variables, but always
2498 represent class temporaries with TARGET_EXPR so we elide copies. */
2499 if ((!at_function_scope_p () || CP_TYPE_CONST_P (type))
2500 && TREE_CODE (type) == ARRAY_TYPE
2501 && !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
2502 && initializer_constant_valid_p (compound_literal, type))
2504 tree decl = create_temporary_var (type);
2505 DECL_INITIAL (decl) = compound_literal;
2506 TREE_STATIC (decl) = 1;
2507 if (literal_type_p (type) && CP_TYPE_CONST_NON_VOLATILE_P (type))
2509 /* 5.19 says that a constant expression can include an
2510 lvalue-rvalue conversion applied to "a glvalue of literal type
2511 that refers to a non-volatile temporary object initialized
2512 with a constant expression". Rather than try to communicate
2513 that this VAR_DECL is a temporary, just mark it constexpr. */
2514 DECL_DECLARED_CONSTEXPR_P (decl) = true;
2515 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = true;
2516 TREE_CONSTANT (decl) = true;
2518 cp_apply_type_quals_to_decl (cp_type_quals (type), decl);
2519 decl = pushdecl_top_level (decl);
2520 DECL_NAME (decl) = make_anon_name ();
2521 SET_DECL_ASSEMBLER_NAME (decl, DECL_NAME (decl));
2525 return get_target_expr_sfinae (compound_literal, complain);
2528 /* Return the declaration for the function-name variable indicated by
2532 finish_fname (tree id)
2536 decl = fname_decl (input_location, C_RID_CODE (id), id);
2537 if (processing_template_decl && current_function_decl)
2538 decl = DECL_NAME (decl);
2542 /* Finish a translation unit. */
2545 finish_translation_unit (void)
2547 /* In case there were missing closebraces,
2548 get us back to the global binding level. */
2550 while (current_namespace != global_namespace)
2553 /* Do file scope __FUNCTION__ et al. */
2554 finish_fname_decls ();
2557 /* Finish a template type parameter, specified as AGGR IDENTIFIER.
2558 Returns the parameter. */
2561 finish_template_type_parm (tree aggr, tree identifier)
2563 if (aggr != class_type_node)
2565 permerror (input_location, "template type parameters must use the keyword %<class%> or %<typename%>");
2566 aggr = class_type_node;
2569 return build_tree_list (aggr, identifier);
2572 /* Finish a template template parameter, specified as AGGR IDENTIFIER.
2573 Returns the parameter. */
2576 finish_template_template_parm (tree aggr, tree identifier)
2578 tree decl = build_decl (input_location,
2579 TYPE_DECL, identifier, NULL_TREE);
2580 tree tmpl = build_lang_decl (TEMPLATE_DECL, identifier, NULL_TREE);
2581 DECL_TEMPLATE_PARMS (tmpl) = current_template_parms;
2582 DECL_TEMPLATE_RESULT (tmpl) = decl;
2583 DECL_ARTIFICIAL (decl) = 1;
2584 end_template_decl ();
2586 gcc_assert (DECL_TEMPLATE_PARMS (tmpl));
2588 check_default_tmpl_args (decl, DECL_TEMPLATE_PARMS (tmpl),
2589 /*is_primary=*/true, /*is_partial=*/false,
2592 return finish_template_type_parm (aggr, tmpl);
2595 /* ARGUMENT is the default-argument value for a template template
2596 parameter. If ARGUMENT is invalid, issue error messages and return
2597 the ERROR_MARK_NODE. Otherwise, ARGUMENT itself is returned. */
2600 check_template_template_default_arg (tree argument)
2602 if (TREE_CODE (argument) != TEMPLATE_DECL
2603 && TREE_CODE (argument) != TEMPLATE_TEMPLATE_PARM
2604 && TREE_CODE (argument) != UNBOUND_CLASS_TEMPLATE)
2606 if (TREE_CODE (argument) == TYPE_DECL)
2607 error ("invalid use of type %qT as a default value for a template "
2608 "template-parameter", TREE_TYPE (argument));
2610 error ("invalid default argument for a template template parameter");
2611 return error_mark_node;
2617 /* Begin a class definition, as indicated by T. */
2620 begin_class_definition (tree t)
2622 if (error_operand_p (t) || error_operand_p (TYPE_MAIN_DECL (t)))
2623 return error_mark_node;
2625 if (processing_template_parmlist)
2627 error ("definition of %q#T inside template parameter list", t);
2628 return error_mark_node;
2631 /* According to the C++ ABI, decimal classes defined in ISO/IEC TR 24733
2632 are passed the same as decimal scalar types. */
2633 if (TREE_CODE (t) == RECORD_TYPE
2634 && !processing_template_decl)
2636 tree ns = TYPE_CONTEXT (t);
2637 if (ns && TREE_CODE (ns) == NAMESPACE_DECL
2638 && DECL_CONTEXT (ns) == std_node
2640 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (ns)), "decimal"))
2642 const char *n = TYPE_NAME_STRING (t);
2643 if ((strcmp (n, "decimal32") == 0)
2644 || (strcmp (n, "decimal64") == 0)
2645 || (strcmp (n, "decimal128") == 0))
2646 TYPE_TRANSPARENT_AGGR (t) = 1;
2650 /* A non-implicit typename comes from code like:
2652 template <typename T> struct A {
2653 template <typename U> struct A<T>::B ...
2655 This is erroneous. */
2656 else if (TREE_CODE (t) == TYPENAME_TYPE)
2658 error ("invalid definition of qualified type %qT", t);
2659 t = error_mark_node;
2662 if (t == error_mark_node || ! MAYBE_CLASS_TYPE_P (t))
2664 t = make_class_type (RECORD_TYPE);
2665 pushtag (make_anon_name (), t, /*tag_scope=*/ts_current);
2668 if (TYPE_BEING_DEFINED (t))
2670 t = make_class_type (TREE_CODE (t));
2671 pushtag (TYPE_IDENTIFIER (t), t, /*tag_scope=*/ts_current);
2673 maybe_process_partial_specialization (t);
2675 TYPE_BEING_DEFINED (t) = 1;
2677 if (flag_pack_struct)
2680 TYPE_PACKED (t) = 1;
2681 /* Even though the type is being defined for the first time
2682 here, there might have been a forward declaration, so there
2683 might be cv-qualified variants of T. */
2684 for (v = TYPE_NEXT_VARIANT (t); v; v = TYPE_NEXT_VARIANT (v))
2685 TYPE_PACKED (v) = 1;
2687 /* Reset the interface data, at the earliest possible
2688 moment, as it might have been set via a class foo;
2690 if (! TYPE_ANONYMOUS_P (t))
2692 struct c_fileinfo *finfo = get_fileinfo (input_filename);
2693 CLASSTYPE_INTERFACE_ONLY (t) = finfo->interface_only;
2694 SET_CLASSTYPE_INTERFACE_UNKNOWN_X
2695 (t, finfo->interface_unknown);
2697 reset_specialization();
2699 /* Make a declaration for this class in its own scope. */
2700 build_self_reference ();
2705 /* Finish the member declaration given by DECL. */
2708 finish_member_declaration (tree decl)
2710 if (decl == error_mark_node || decl == NULL_TREE)
2713 if (decl == void_type_node)
2714 /* The COMPONENT was a friend, not a member, and so there's
2715 nothing for us to do. */
2718 /* We should see only one DECL at a time. */
2719 gcc_assert (DECL_CHAIN (decl) == NULL_TREE);
2721 /* Set up access control for DECL. */
2723 = (current_access_specifier == access_private_node);
2724 TREE_PROTECTED (decl)
2725 = (current_access_specifier == access_protected_node);
2726 if (TREE_CODE (decl) == TEMPLATE_DECL)
2728 TREE_PRIVATE (DECL_TEMPLATE_RESULT (decl)) = TREE_PRIVATE (decl);
2729 TREE_PROTECTED (DECL_TEMPLATE_RESULT (decl)) = TREE_PROTECTED (decl);
2732 /* Mark the DECL as a member of the current class, unless it's
2733 a member of an enumeration. */
2734 if (TREE_CODE (decl) != CONST_DECL)
2735 DECL_CONTEXT (decl) = current_class_type;
2737 /* Check for bare parameter packs in the member variable declaration. */
2738 if (TREE_CODE (decl) == FIELD_DECL)
2740 if (check_for_bare_parameter_packs (TREE_TYPE (decl)))
2741 TREE_TYPE (decl) = error_mark_node;
2742 if (check_for_bare_parameter_packs (DECL_ATTRIBUTES (decl)))
2743 DECL_ATTRIBUTES (decl) = NULL_TREE;
2748 A C language linkage is ignored for the names of class members
2749 and the member function type of class member functions. */
2750 if (DECL_LANG_SPECIFIC (decl) && DECL_LANGUAGE (decl) == lang_c)
2751 SET_DECL_LANGUAGE (decl, lang_cplusplus);
2753 /* Put functions on the TYPE_METHODS list and everything else on the
2754 TYPE_FIELDS list. Note that these are built up in reverse order.
2755 We reverse them (to obtain declaration order) in finish_struct. */
2756 if (DECL_DECLARES_FUNCTION_P (decl))
2758 /* We also need to add this function to the
2759 CLASSTYPE_METHOD_VEC. */
2760 if (add_method (current_class_type, decl, NULL_TREE))
2762 DECL_CHAIN (decl) = TYPE_METHODS (current_class_type);
2763 TYPE_METHODS (current_class_type) = decl;
2765 maybe_add_class_template_decl_list (current_class_type, decl,
2769 /* Enter the DECL into the scope of the class, if the class
2770 isn't a closure (whose fields are supposed to be unnamed). */
2771 else if (CLASSTYPE_LAMBDA_EXPR (current_class_type)
2772 || pushdecl_class_level (decl))
2774 if (TREE_CODE (decl) == USING_DECL)
2776 /* For now, ignore class-scope USING_DECLS, so that
2777 debugging backends do not see them. */
2778 DECL_IGNORED_P (decl) = 1;
2781 /* All TYPE_DECLs go at the end of TYPE_FIELDS. Ordinary fields
2782 go at the beginning. The reason is that lookup_field_1
2783 searches the list in order, and we want a field name to
2784 override a type name so that the "struct stat hack" will
2785 work. In particular:
2787 struct S { enum E { }; int E } s;
2790 is valid. In addition, the FIELD_DECLs must be maintained in
2791 declaration order so that class layout works as expected.
2792 However, we don't need that order until class layout, so we
2793 save a little time by putting FIELD_DECLs on in reverse order
2794 here, and then reversing them in finish_struct_1. (We could
2795 also keep a pointer to the correct insertion points in the
2798 if (TREE_CODE (decl) == TYPE_DECL)
2799 TYPE_FIELDS (current_class_type)
2800 = chainon (TYPE_FIELDS (current_class_type), decl);
2803 DECL_CHAIN (decl) = TYPE_FIELDS (current_class_type);
2804 TYPE_FIELDS (current_class_type) = decl;
2807 maybe_add_class_template_decl_list (current_class_type, decl,
2812 note_decl_for_pch (decl);
2815 /* DECL has been declared while we are building a PCH file. Perform
2816 actions that we might normally undertake lazily, but which can be
2817 performed now so that they do not have to be performed in
2818 translation units which include the PCH file. */
2821 note_decl_for_pch (tree decl)
2823 gcc_assert (pch_file);
2825 /* There's a good chance that we'll have to mangle names at some
2826 point, even if only for emission in debugging information. */
2827 if (VAR_OR_FUNCTION_DECL_P (decl)
2828 && !processing_template_decl)
2832 /* Finish processing a complete template declaration. The PARMS are
2833 the template parameters. */
2836 finish_template_decl (tree parms)
2839 end_template_decl ();
2841 end_specialization ();
2844 /* Finish processing a template-id (which names a type) of the form
2845 NAME < ARGS >. Return the TYPE_DECL for the type named by the
2846 template-id. If ENTERING_SCOPE is nonzero we are about to enter
2847 the scope of template-id indicated. */
2850 finish_template_type (tree name, tree args, int entering_scope)
2854 type = lookup_template_class (name, args,
2855 NULL_TREE, NULL_TREE, entering_scope,
2856 tf_warning_or_error | tf_user);
2857 if (type == error_mark_node)
2859 else if (CLASS_TYPE_P (type) && !alias_type_or_template_p (type))
2860 return TYPE_STUB_DECL (type);
2862 return TYPE_NAME (type);
2865 /* Finish processing a BASE_CLASS with the indicated ACCESS_SPECIFIER.
2866 Return a TREE_LIST containing the ACCESS_SPECIFIER and the
2867 BASE_CLASS, or NULL_TREE if an error occurred. The
2868 ACCESS_SPECIFIER is one of
2869 access_{default,public,protected_private}_node. For a virtual base
2870 we set TREE_TYPE. */
2873 finish_base_specifier (tree base, tree access, bool virtual_p)
2877 if (base == error_mark_node)
2879 error ("invalid base-class specification");
2882 else if (! MAYBE_CLASS_TYPE_P (base))
2884 error ("%qT is not a class type", base);
2889 if (cp_type_quals (base) != 0)
2891 /* DR 484: Can a base-specifier name a cv-qualified
2893 base = TYPE_MAIN_VARIANT (base);
2895 result = build_tree_list (access, base);
2897 TREE_TYPE (result) = integer_type_node;
2903 /* If FNS is a member function, a set of member functions, or a
2904 template-id referring to one or more member functions, return a
2905 BASELINK for FNS, incorporating the current access context.
2906 Otherwise, return FNS unchanged. */
2909 baselink_for_fns (tree fns)
2914 if (BASELINK_P (fns)
2915 || error_operand_p (fns))
2918 scope = ovl_scope (fns);
2919 if (!CLASS_TYPE_P (scope))
2922 cl = currently_open_derived_class (scope);
2925 cl = TYPE_BINFO (cl);
2926 return build_baselink (cl, cl, fns, /*optype=*/NULL_TREE);
2929 /* Returns true iff DECL is a variable from a function outside
2933 outer_var_p (tree decl)
2935 return ((VAR_P (decl) || TREE_CODE (decl) == PARM_DECL)
2936 && DECL_FUNCTION_SCOPE_P (decl)
2937 && (DECL_CONTEXT (decl) != current_function_decl
2938 || parsing_nsdmi ()));
2941 /* As above, but also checks that DECL is automatic. */
2944 outer_automatic_var_p (tree decl)
2946 return (outer_var_p (decl)
2947 && !TREE_STATIC (decl));
2950 /* ID_EXPRESSION is a representation of parsed, but unprocessed,
2951 id-expression. (See cp_parser_id_expression for details.) SCOPE,
2952 if non-NULL, is the type or namespace used to explicitly qualify
2953 ID_EXPRESSION. DECL is the entity to which that name has been
2956 *CONSTANT_EXPRESSION_P is true if we are presently parsing a
2957 constant-expression. In that case, *NON_CONSTANT_EXPRESSION_P will
2958 be set to true if this expression isn't permitted in a
2959 constant-expression, but it is otherwise not set by this function.
2960 *ALLOW_NON_CONSTANT_EXPRESSION_P is true if we are parsing a
2961 constant-expression, but a non-constant expression is also
2964 DONE is true if this expression is a complete postfix-expression;
2965 it is false if this expression is followed by '->', '[', '(', etc.
2966 ADDRESS_P is true iff this expression is the operand of '&'.
2967 TEMPLATE_P is true iff the qualified-id was of the form
2968 "A::template B". TEMPLATE_ARG_P is true iff this qualified name
2969 appears as a template argument.
2971 If an error occurs, and it is the kind of error that might cause
2972 the parser to abort a tentative parse, *ERROR_MSG is filled in. It
2973 is the caller's responsibility to issue the message. *ERROR_MSG
2974 will be a string with static storage duration, so the caller need
2977 Return an expression for the entity, after issuing appropriate
2978 diagnostics. This function is also responsible for transforming a
2979 reference to a non-static member into a COMPONENT_REF that makes
2980 the use of "this" explicit.
2982 Upon return, *IDK will be filled in appropriately. */
2984 finish_id_expression (tree id_expression,
2988 bool integral_constant_expression_p,
2989 bool allow_non_integral_constant_expression_p,
2990 bool *non_integral_constant_expression_p,
2994 bool template_arg_p,
2995 const char **error_msg,
2996 location_t location)
2998 decl = strip_using_decl (decl);
3000 /* Initialize the output parameters. */
3001 *idk = CP_ID_KIND_NONE;
3004 if (id_expression == error_mark_node)
3005 return error_mark_node;
3006 /* If we have a template-id, then no further lookup is
3007 required. If the template-id was for a template-class, we
3008 will sometimes have a TYPE_DECL at this point. */
3009 else if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
3010 || TREE_CODE (decl) == TYPE_DECL)
3012 /* Look up the name. */
3015 if (decl == error_mark_node)
3017 /* Name lookup failed. */
3020 || (!dependent_type_p (scope)
3021 && !(identifier_p (id_expression)
3022 && IDENTIFIER_TYPENAME_P (id_expression)
3023 && dependent_type_p (TREE_TYPE (id_expression))))))
3025 /* If the qualifying type is non-dependent (and the name
3026 does not name a conversion operator to a dependent
3027 type), issue an error. */
3028 qualified_name_lookup_error (scope, id_expression, decl, location);
3029 return error_mark_node;
3033 /* It may be resolved via Koenig lookup. */
3034 *idk = CP_ID_KIND_UNQUALIFIED;
3035 return id_expression;
3038 decl = id_expression;
3040 /* If DECL is a variable that would be out of scope under
3041 ANSI/ISO rules, but in scope in the ARM, name lookup
3042 will succeed. Issue a diagnostic here. */
3044 decl = check_for_out_of_scope_variable (decl);
3046 /* Remember that the name was used in the definition of
3047 the current class so that we can check later to see if
3048 the meaning would have been different after the class
3049 was entirely defined. */
3050 if (!scope && decl != error_mark_node && identifier_p (id_expression))
3051 maybe_note_name_used_in_class (id_expression, decl);
3053 /* Disallow uses of local variables from containing functions, except
3054 within lambda-expressions. */
3055 if (!outer_var_p (decl))
3057 else if (TREE_STATIC (decl)
3058 /* It's not a use (3.2) if we're in an unevaluated context. */
3059 || cp_unevaluated_operand)
3061 if (processing_template_decl)
3062 /* For a use of an outer static/unevaluated var, return the id
3063 so that we'll look it up again in the instantiation. */
3064 return id_expression;
3068 tree context = DECL_CONTEXT (decl);
3069 tree containing_function = current_function_decl;
3070 tree lambda_stack = NULL_TREE;
3071 tree lambda_expr = NULL_TREE;
3072 tree initializer = convert_from_reference (decl);
3074 /* Mark it as used now even if the use is ill-formed. */
3077 /* Core issue 696: "[At the July 2009 meeting] the CWG expressed
3078 support for an approach in which a reference to a local
3079 [constant] automatic variable in a nested class or lambda body
3080 would enter the expression as an rvalue, which would reduce
3081 the complexity of the problem"
3083 FIXME update for final resolution of core issue 696. */
3084 if (decl_constant_var_p (decl))
3086 if (processing_template_decl)
3087 /* In a template, the constant value may not be in a usable
3088 form, so look it up again at instantiation time. */
3089 return id_expression;
3091 return integral_constant_value (decl);
3094 if (parsing_nsdmi ())
3095 containing_function = NULL_TREE;
3096 /* If we are in a lambda function, we can move out until we hit
3098 2. a non-lambda function, or
3099 3. a non-default capturing lambda function. */
3100 else while (context != containing_function
3101 && LAMBDA_FUNCTION_P (containing_function))
3103 lambda_expr = CLASSTYPE_LAMBDA_EXPR
3104 (DECL_CONTEXT (containing_function));
3106 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr)
3110 lambda_stack = tree_cons (NULL_TREE,
3115 = decl_function_context (containing_function);
3118 if (lambda_expr && TREE_CODE (decl) == VAR_DECL
3119 && DECL_ANON_UNION_VAR_P (decl))
3121 error ("cannot capture member %qD of anonymous union", decl);
3122 return error_mark_node;
3124 if (context == containing_function)
3126 decl = add_default_capture (lambda_stack,
3127 /*id=*/DECL_NAME (decl),
3130 else if (lambda_expr)
3132 error ("%qD is not captured", decl);
3133 return error_mark_node;
3138 ? G_("use of local variable with automatic storage from containing function")
3139 : G_("use of parameter from containing function"));
3140 inform (input_location, "%q+#D declared here", decl);
3141 return error_mark_node;
3145 /* Also disallow uses of function parameters outside the function
3146 body, except inside an unevaluated context (i.e. decltype). */
3147 if (TREE_CODE (decl) == PARM_DECL
3148 && DECL_CONTEXT (decl) == NULL_TREE
3149 && !cp_unevaluated_operand)
3151 error ("use of parameter %qD outside function body", decl);
3152 return error_mark_node;
3156 /* If we didn't find anything, or what we found was a type,
3157 then this wasn't really an id-expression. */
3158 if (TREE_CODE (decl) == TEMPLATE_DECL
3159 && !DECL_FUNCTION_TEMPLATE_P (decl))
3161 *error_msg = "missing template arguments";
3162 return error_mark_node;
3164 else if (TREE_CODE (decl) == TYPE_DECL
3165 || TREE_CODE (decl) == NAMESPACE_DECL)
3167 *error_msg = "expected primary-expression";
3168 return error_mark_node;
3171 /* If the name resolved to a template parameter, there is no
3172 need to look it up again later. */
3173 if ((TREE_CODE (decl) == CONST_DECL && DECL_TEMPLATE_PARM_P (decl))
3174 || TREE_CODE (decl) == TEMPLATE_PARM_INDEX)
3178 *idk = CP_ID_KIND_NONE;
3179 if (TREE_CODE (decl) == TEMPLATE_PARM_INDEX)
3180 decl = TEMPLATE_PARM_DECL (decl);
3181 r = convert_from_reference (DECL_INITIAL (decl));
3183 if (integral_constant_expression_p
3184 && !dependent_type_p (TREE_TYPE (decl))
3185 && !(INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (r))))
3187 if (!allow_non_integral_constant_expression_p)
3188 error ("template parameter %qD of type %qT is not allowed in "
3189 "an integral constant expression because it is not of "
3190 "integral or enumeration type", decl, TREE_TYPE (decl));
3191 *non_integral_constant_expression_p = true;
3199 /* If the declaration was explicitly qualified indicate
3200 that. The semantics of `A::f(3)' are different than
3201 `f(3)' if `f' is virtual. */
3203 ? CP_ID_KIND_QUALIFIED
3204 : (TREE_CODE (decl) == TEMPLATE_ID_EXPR
3205 ? CP_ID_KIND_TEMPLATE_ID
3206 : CP_ID_KIND_UNQUALIFIED));
3211 An id-expression is type-dependent if it contains an
3212 identifier that was declared with a dependent type.
3214 The standard is not very specific about an id-expression that
3215 names a set of overloaded functions. What if some of them
3216 have dependent types and some of them do not? Presumably,
3217 such a name should be treated as a dependent name. */
3218 /* Assume the name is not dependent. */
3219 dependent_p = false;
3220 if (!processing_template_decl)
3221 /* No names are dependent outside a template. */
3223 else if (TREE_CODE (decl) == CONST_DECL)
3224 /* We don't want to treat enumerators as dependent. */
3226 /* A template-id where the name of the template was not resolved
3227 is definitely dependent. */
3228 else if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
3229 && (identifier_p (TREE_OPERAND (decl, 0))))
3231 /* For anything except an overloaded function, just check its
3233 else if (!is_overloaded_fn (decl))
3235 = dependent_type_p (TREE_TYPE (decl));
3236 /* For a set of overloaded functions, check each of the
3242 if (BASELINK_P (fns))
3243 fns = BASELINK_FUNCTIONS (fns);
3245 /* For a template-id, check to see if the template
3246 arguments are dependent. */
3247 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
3249 tree args = TREE_OPERAND (fns, 1);
3250 dependent_p = any_dependent_template_arguments_p (args);
3251 /* The functions are those referred to by the
3253 fns = TREE_OPERAND (fns, 0);
3256 /* If there are no dependent template arguments, go through
3257 the overloaded functions. */
3258 while (fns && !dependent_p)
3260 tree fn = OVL_CURRENT (fns);
3262 /* Member functions of dependent classes are
3264 if (TREE_CODE (fn) == FUNCTION_DECL
3265 && type_dependent_expression_p (fn))
3267 else if (TREE_CODE (fn) == TEMPLATE_DECL
3268 && dependent_template_p (fn))
3271 fns = OVL_NEXT (fns);
3275 /* If the name was dependent on a template parameter, we will
3276 resolve the name at instantiation time. */
3279 /* Create a SCOPE_REF for qualified names, if the scope is
3285 if (address_p && done)
3286 decl = finish_qualified_id_expr (scope, decl,
3290 tf_warning_or_error);
3293 tree type = NULL_TREE;
3294 if (DECL_P (decl) && !dependent_scope_p (scope))
3295 type = TREE_TYPE (decl);
3296 decl = build_qualified_name (type,
3302 if (TREE_TYPE (decl))
3303 decl = convert_from_reference (decl);
3306 /* A TEMPLATE_ID already contains all the information we
3308 if (TREE_CODE (id_expression) == TEMPLATE_ID_EXPR)
3309 return id_expression;
3310 *idk = CP_ID_KIND_UNQUALIFIED_DEPENDENT;
3311 /* If we found a variable, then name lookup during the
3312 instantiation will always resolve to the same VAR_DECL
3313 (or an instantiation thereof). */
3315 || TREE_CODE (decl) == PARM_DECL)
3318 return convert_from_reference (decl);
3320 /* The same is true for FIELD_DECL, but we also need to
3321 make sure that the syntax is correct. */
3322 else if (TREE_CODE (decl) == FIELD_DECL)
3324 /* Since SCOPE is NULL here, this is an unqualified name.
3325 Access checking has been performed during name lookup
3326 already. Turn off checking to avoid duplicate errors. */
3327 push_deferring_access_checks (dk_no_check);
3328 decl = finish_non_static_data_member
3330 /*qualifying_scope=*/NULL_TREE);
3331 pop_deferring_access_checks ();
3334 return id_expression;
3337 if (TREE_CODE (decl) == NAMESPACE_DECL)
3339 error ("use of namespace %qD as expression", decl);
3340 return error_mark_node;
3342 else if (DECL_CLASS_TEMPLATE_P (decl))
3344 error ("use of class template %qT as expression", decl);
3345 return error_mark_node;
3347 else if (TREE_CODE (decl) == TREE_LIST)
3349 /* Ambiguous reference to base members. */
3350 error ("request for member %qD is ambiguous in "
3351 "multiple inheritance lattice", id_expression);
3352 print_candidates (decl);
3353 return error_mark_node;
3356 /* Mark variable-like entities as used. Functions are similarly
3357 marked either below or after overload resolution. */
3359 || TREE_CODE (decl) == PARM_DECL
3360 || TREE_CODE (decl) == CONST_DECL
3361 || TREE_CODE (decl) == RESULT_DECL)
3362 && !mark_used (decl))
3363 return error_mark_node;
3365 /* Only certain kinds of names are allowed in constant
3366 expression. Template parameters have already
3367 been handled above. */
3368 if (! error_operand_p (decl)
3369 && integral_constant_expression_p
3370 && ! decl_constant_var_p (decl)
3371 && TREE_CODE (decl) != CONST_DECL
3372 && ! builtin_valid_in_constant_expr_p (decl))
3374 if (!allow_non_integral_constant_expression_p)
3376 error ("%qD cannot appear in a constant-expression", decl);
3377 return error_mark_node;
3379 *non_integral_constant_expression_p = true;
3384 && !cp_unevaluated_operand
3385 && DECL_THREAD_LOCAL_P (decl)
3386 && (wrap = get_tls_wrapper_fn (decl)))
3388 /* Replace an evaluated use of the thread_local variable with
3389 a call to its wrapper. */
3390 decl = build_cxx_call (wrap, 0, NULL, tf_warning_or_error);
3394 decl = (adjust_result_of_qualified_name_lookup
3395 (decl, scope, current_nonlambda_class_type()));
3397 if (TREE_CODE (decl) == FUNCTION_DECL)
3401 decl = finish_qualified_id_expr (scope,
3407 tf_warning_or_error);
3409 decl = convert_from_reference (decl);
3411 else if (TREE_CODE (decl) == FIELD_DECL)
3413 /* Since SCOPE is NULL here, this is an unqualified name.
3414 Access checking has been performed during name lookup
3415 already. Turn off checking to avoid duplicate errors. */
3416 push_deferring_access_checks (dk_no_check);
3417 decl = finish_non_static_data_member (decl, NULL_TREE,
3418 /*qualifying_scope=*/NULL_TREE);
3419 pop_deferring_access_checks ();
3421 else if (is_overloaded_fn (decl))
3425 first_fn = get_first_fn (decl);
3426 if (TREE_CODE (first_fn) == TEMPLATE_DECL)
3427 first_fn = DECL_TEMPLATE_RESULT (first_fn);
3429 if (!really_overloaded_fn (decl)
3430 && !mark_used (first_fn))
3431 return error_mark_node;
3434 && TREE_CODE (first_fn) == FUNCTION_DECL
3435 && DECL_FUNCTION_MEMBER_P (first_fn)
3436 && !shared_member_p (decl))
3438 /* A set of member functions. */
3439 decl = maybe_dummy_object (DECL_CONTEXT (first_fn), 0);
3440 return finish_class_member_access_expr (decl, id_expression,
3441 /*template_p=*/false,
3442 tf_warning_or_error);
3445 decl = baselink_for_fns (decl);
3449 if (DECL_P (decl) && DECL_NONLOCAL (decl)
3450 && DECL_CLASS_SCOPE_P (decl))
3452 tree context = context_for_name_lookup (decl);
3453 if (context != current_class_type)
3455 tree path = currently_open_derived_class (context);
3456 perform_or_defer_access_check (TYPE_BINFO (path),
3458 tf_warning_or_error);
3462 decl = convert_from_reference (decl);
3466 /* Handle references (c++/56130). */
3467 tree t = REFERENCE_REF_P (decl) ? TREE_OPERAND (decl, 0) : decl;
3468 if (TREE_DEPRECATED (t))
3469 warn_deprecated_use (t, NULL_TREE);
3474 /* Implement the __typeof keyword: Return the type of EXPR, suitable for
3475 use as a type-specifier. */
3478 finish_typeof (tree expr)
3482 if (type_dependent_expression_p (expr))
3484 type = cxx_make_type (TYPEOF_TYPE);
3485 TYPEOF_TYPE_EXPR (type) = expr;
3486 SET_TYPE_STRUCTURAL_EQUALITY (type);
3491 expr = mark_type_use (expr);
3493 type = unlowered_expr_type (expr);
3495 if (!type || type == unknown_type_node)
3497 error ("type of %qE is unknown", expr);
3498 return error_mark_node;
3504 /* Implement the __underlying_type keyword: Return the underlying
3505 type of TYPE, suitable for use as a type-specifier. */
3508 finish_underlying_type (tree type)
3510 tree underlying_type;
3512 if (processing_template_decl)
3514 underlying_type = cxx_make_type (UNDERLYING_TYPE);
3515 UNDERLYING_TYPE_TYPE (underlying_type) = type;
3516 SET_TYPE_STRUCTURAL_EQUALITY (underlying_type);
3518 return underlying_type;
3521 complete_type (type);
3523 if (TREE_CODE (type) != ENUMERAL_TYPE)
3525 error ("%qT is not an enumeration type", type);
3526 return error_mark_node;
3529 underlying_type = ENUM_UNDERLYING_TYPE (type);
3531 /* Fixup necessary in this case because ENUM_UNDERLYING_TYPE
3532 includes TYPE_MIN_VALUE and TYPE_MAX_VALUE information.
3533 See finish_enum_value_list for details. */
3534 if (!ENUM_FIXED_UNDERLYING_TYPE_P (type))
3536 = c_common_type_for_mode (TYPE_MODE (underlying_type),
3537 TYPE_UNSIGNED (underlying_type));
3539 return underlying_type;
3542 /* Implement the __direct_bases keyword: Return the direct base classes
3546 calculate_direct_bases (tree type)
3548 vec<tree, va_gc> *vector = make_tree_vector();
3549 tree bases_vec = NULL_TREE;
3550 vec<tree, va_gc> *base_binfos;
3554 complete_type (type);
3556 if (!NON_UNION_CLASS_TYPE_P (type))
3557 return make_tree_vec (0);
3559 base_binfos = BINFO_BASE_BINFOS (TYPE_BINFO (type));
3561 /* Virtual bases are initialized first */
3562 for (i = 0; base_binfos->iterate (i, &binfo); i++)
3564 if (BINFO_VIRTUAL_P (binfo))
3566 vec_safe_push (vector, binfo);
3570 /* Now non-virtuals */
3571 for (i = 0; base_binfos->iterate (i, &binfo); i++)
3573 if (!BINFO_VIRTUAL_P (binfo))
3575 vec_safe_push (vector, binfo);
3580 bases_vec = make_tree_vec (vector->length ());
3582 for (i = 0; i < vector->length (); ++i)
3584 TREE_VEC_ELT (bases_vec, i) = BINFO_TYPE ((*vector)[i]);
3589 /* Implement the __bases keyword: Return the base classes
3592 /* Find morally non-virtual base classes by walking binfo hierarchy */
3593 /* Virtual base classes are handled separately in finish_bases */
3596 dfs_calculate_bases_pre (tree binfo, void * /*data_*/)
3598 /* Don't walk bases of virtual bases */
3599 return BINFO_VIRTUAL_P (binfo) ? dfs_skip_bases : NULL_TREE;
3603 dfs_calculate_bases_post (tree binfo, void *data_)
3605 vec<tree, va_gc> **data = ((vec<tree, va_gc> **) data_);
3606 if (!BINFO_VIRTUAL_P (binfo))
3608 vec_safe_push (*data, BINFO_TYPE (binfo));
3613 /* Calculates the morally non-virtual base classes of a class */
3614 static vec<tree, va_gc> *
3615 calculate_bases_helper (tree type)
3617 vec<tree, va_gc> *vector = make_tree_vector();
3619 /* Now add non-virtual base classes in order of construction */
3620 dfs_walk_all (TYPE_BINFO (type),
3621 dfs_calculate_bases_pre, dfs_calculate_bases_post, &vector);
3626 calculate_bases (tree type)
3628 vec<tree, va_gc> *vector = make_tree_vector();
3629 tree bases_vec = NULL_TREE;
3631 vec<tree, va_gc> *vbases;
3632 vec<tree, va_gc> *nonvbases;
3635 complete_type (type);
3637 if (!NON_UNION_CLASS_TYPE_P (type))
3638 return make_tree_vec (0);
3640 /* First go through virtual base classes */
3641 for (vbases = CLASSTYPE_VBASECLASSES (type), i = 0;
3642 vec_safe_iterate (vbases, i, &binfo); i++)
3644 vec<tree, va_gc> *vbase_bases;
3645 vbase_bases = calculate_bases_helper (BINFO_TYPE (binfo));
3646 vec_safe_splice (vector, vbase_bases);
3647 release_tree_vector (vbase_bases);
3650 /* Now for the non-virtual bases */
3651 nonvbases = calculate_bases_helper (type);
3652 vec_safe_splice (vector, nonvbases);
3653 release_tree_vector (nonvbases);
3655 /* Last element is entire class, so don't copy */
3656 bases_vec = make_tree_vec (vector->length () - 1);
3658 for (i = 0; i < vector->length () - 1; ++i)
3660 TREE_VEC_ELT (bases_vec, i) = (*vector)[i];
3662 release_tree_vector (vector);
3667 finish_bases (tree type, bool direct)
3669 tree bases = NULL_TREE;
3671 if (!processing_template_decl)
3673 /* Parameter packs can only be used in templates */
3674 error ("Parameter pack __bases only valid in template declaration");
3675 return error_mark_node;
3678 bases = cxx_make_type (BASES);
3679 BASES_TYPE (bases) = type;
3680 BASES_DIRECT (bases) = direct;
3681 SET_TYPE_STRUCTURAL_EQUALITY (bases);
3686 /* Perform C++-specific checks for __builtin_offsetof before calling
3690 finish_offsetof (tree expr)
3692 if (TREE_CODE (expr) == PSEUDO_DTOR_EXPR)
3694 error ("cannot apply %<offsetof%> to destructor %<~%T%>",
3695 TREE_OPERAND (expr, 2));
3696 return error_mark_node;
3698 if (TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE
3699 || TREE_CODE (TREE_TYPE (expr)) == METHOD_TYPE
3700 || TREE_TYPE (expr) == unknown_type_node)
3702 if (INDIRECT_REF_P (expr))
3703 error ("second operand of %<offsetof%> is neither a single "
3704 "identifier nor a sequence of member accesses and "
3705 "array references");
3708 if (TREE_CODE (expr) == COMPONENT_REF
3709 || TREE_CODE (expr) == COMPOUND_EXPR)
3710 expr = TREE_OPERAND (expr, 1);
3711 error ("cannot apply %<offsetof%> to member function %qD", expr);
3713 return error_mark_node;
3715 if (REFERENCE_REF_P (expr))
3716 expr = TREE_OPERAND (expr, 0);
3717 if (TREE_CODE (expr) == COMPONENT_REF)
3719 tree object = TREE_OPERAND (expr, 0);
3720 if (!complete_type_or_else (TREE_TYPE (object), object))
3721 return error_mark_node;
3723 return fold_offsetof (expr);
3726 /* Replace the AGGR_INIT_EXPR at *TP with an equivalent CALL_EXPR. This
3727 function is broken out from the above for the benefit of the tree-ssa
3731 simplify_aggr_init_expr (tree *tp)
3733 tree aggr_init_expr = *tp;
3735 /* Form an appropriate CALL_EXPR. */
3736 tree fn = AGGR_INIT_EXPR_FN (aggr_init_expr);
3737 tree slot = AGGR_INIT_EXPR_SLOT (aggr_init_expr);
3738 tree type = TREE_TYPE (slot);
3741 enum style_t { ctor, arg, pcc } style;
3743 if (AGGR_INIT_VIA_CTOR_P (aggr_init_expr))
3745 #ifdef PCC_STATIC_STRUCT_RETURN
3751 gcc_assert (TREE_ADDRESSABLE (type));
3755 call_expr = build_call_array_loc (input_location,
3756 TREE_TYPE (TREE_TYPE (TREE_TYPE (fn))),
3758 aggr_init_expr_nargs (aggr_init_expr),
3759 AGGR_INIT_EXPR_ARGP (aggr_init_expr));
3760 TREE_NOTHROW (call_expr) = TREE_NOTHROW (aggr_init_expr);
3764 /* Replace the first argument to the ctor with the address of the
3766 cxx_mark_addressable (slot);
3767 CALL_EXPR_ARG (call_expr, 0) =
3768 build1 (ADDR_EXPR, build_pointer_type (type), slot);
3770 else if (style == arg)
3772 /* Just mark it addressable here, and leave the rest to
3773 expand_call{,_inline}. */
3774 cxx_mark_addressable (slot);
3775 CALL_EXPR_RETURN_SLOT_OPT (call_expr) = true;
3776 call_expr = build2 (INIT_EXPR, TREE_TYPE (call_expr), slot, call_expr);
3778 else if (style == pcc)
3780 /* If we're using the non-reentrant PCC calling convention, then we
3781 need to copy the returned value out of the static buffer into the
3783 push_deferring_access_checks (dk_no_check);
3784 call_expr = build_aggr_init (slot, call_expr,
3785 DIRECT_BIND | LOOKUP_ONLYCONVERTING,
3786 tf_warning_or_error);
3787 pop_deferring_access_checks ();
3788 call_expr = build2 (COMPOUND_EXPR, TREE_TYPE (slot), call_expr, slot);
3791 if (AGGR_INIT_ZERO_FIRST (aggr_init_expr))
3793 tree init = build_zero_init (type, NULL_TREE,
3794 /*static_storage_p=*/false);
3795 init = build2 (INIT_EXPR, void_type_node, slot, init);
3796 call_expr = build2 (COMPOUND_EXPR, TREE_TYPE (call_expr),
3803 /* Emit all thunks to FN that should be emitted when FN is emitted. */
3806 emit_associated_thunks (tree fn)
3808 /* When we use vcall offsets, we emit thunks with the virtual
3809 functions to which they thunk. The whole point of vcall offsets
3810 is so that you can know statically the entire set of thunks that
3811 will ever be needed for a given virtual function, thereby
3812 enabling you to output all the thunks with the function itself. */
3813 if (DECL_VIRTUAL_P (fn)
3814 /* Do not emit thunks for extern template instantiations. */
3815 && ! DECL_REALLY_EXTERN (fn))
3819 for (thunk = DECL_THUNKS (fn); thunk; thunk = DECL_CHAIN (thunk))
3821 if (!THUNK_ALIAS (thunk))
3823 use_thunk (thunk, /*emit_p=*/1);
3824 if (DECL_RESULT_THUNK_P (thunk))
3828 for (probe = DECL_THUNKS (thunk);
3829 probe; probe = DECL_CHAIN (probe))
3830 use_thunk (probe, /*emit_p=*/1);
3834 gcc_assert (!DECL_THUNKS (thunk));
3839 /* Returns true iff FUN is an instantiation of a constexpr function
3843 is_instantiation_of_constexpr (tree fun)
3845 return (DECL_TEMPLOID_INSTANTIATION (fun)
3846 && DECL_DECLARED_CONSTEXPR_P (DECL_TEMPLATE_RESULT
3847 (DECL_TI_TEMPLATE (fun))));
3850 /* Generate RTL for FN. */
3853 expand_or_defer_fn_1 (tree fn)
3855 /* When the parser calls us after finishing the body of a template
3856 function, we don't really want to expand the body. */
3857 if (processing_template_decl)
3859 /* Normally, collection only occurs in rest_of_compilation. So,
3860 if we don't collect here, we never collect junk generated
3861 during the processing of templates until we hit a
3862 non-template function. It's not safe to do this inside a
3863 nested class, though, as the parser may have local state that
3864 is not a GC root. */
3865 if (!function_depth)
3870 gcc_assert (DECL_SAVED_TREE (fn));
3872 /* If this is a constructor or destructor body, we have to clone
3874 if (maybe_clone_body (fn))
3876 /* We don't want to process FN again, so pretend we've written
3877 it out, even though we haven't. */
3878 TREE_ASM_WRITTEN (fn) = 1;
3879 /* If this is an instantiation of a constexpr function, keep
3880 DECL_SAVED_TREE for explain_invalid_constexpr_fn. */
3881 if (!is_instantiation_of_constexpr (fn))
3882 DECL_SAVED_TREE (fn) = NULL_TREE;
3886 /* We make a decision about linkage for these functions at the end
3887 of the compilation. Until that point, we do not want the back
3888 end to output them -- but we do want it to see the bodies of
3889 these functions so that it can inline them as appropriate. */
3890 if (DECL_DECLARED_INLINE_P (fn) || DECL_IMPLICIT_INSTANTIATION (fn))
3892 if (DECL_INTERFACE_KNOWN (fn))
3893 /* We've already made a decision as to how this function will
3897 DECL_EXTERNAL (fn) = 1;
3898 DECL_NOT_REALLY_EXTERN (fn) = 1;
3899 note_vague_linkage_fn (fn);
3900 /* A non-template inline function with external linkage will
3901 always be COMDAT. As we must eventually determine the
3902 linkage of all functions, and as that causes writes to
3903 the data mapped in from the PCH file, it's advantageous
3904 to mark the functions at this point. */
3905 if (!DECL_IMPLICIT_INSTANTIATION (fn))
3907 /* This function must have external linkage, as
3908 otherwise DECL_INTERFACE_KNOWN would have been
3910 gcc_assert (TREE_PUBLIC (fn));
3911 comdat_linkage (fn);
3912 DECL_INTERFACE_KNOWN (fn) = 1;
3916 import_export_decl (fn);
3918 /* If the user wants us to keep all inline functions, then mark
3919 this function as needed so that finish_file will make sure to
3920 output it later. Similarly, all dllexport'd functions must
3921 be emitted; there may be callers in other DLLs. */
3922 if ((flag_keep_inline_functions
3923 && DECL_DECLARED_INLINE_P (fn)
3924 && !DECL_REALLY_EXTERN (fn))
3925 || (flag_keep_inline_dllexport
3926 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (fn))))
3929 DECL_EXTERNAL (fn) = 0;
3933 /* There's no reason to do any of the work here if we're only doing
3934 semantic analysis; this code just generates RTL. */
3935 if (flag_syntax_only)
3942 expand_or_defer_fn (tree fn)
3944 if (expand_or_defer_fn_1 (fn))
3948 /* Expand or defer, at the whim of the compilation unit manager. */
3949 cgraph_finalize_function (fn, function_depth > 1);
3950 emit_associated_thunks (fn);
3960 hash_table <pointer_hash <tree_node> > visited;
3963 /* Helper function for walk_tree, used by finalize_nrv below. */
3966 finalize_nrv_r (tree* tp, int* walk_subtrees, void* data)
3968 struct nrv_data *dp = (struct nrv_data *)data;
3971 /* No need to walk into types. There wouldn't be any need to walk into
3972 non-statements, except that we have to consider STMT_EXPRs. */
3975 /* Change all returns to just refer to the RESULT_DECL; this is a nop,
3976 but differs from using NULL_TREE in that it indicates that we care
3977 about the value of the RESULT_DECL. */
3978 else if (TREE_CODE (*tp) == RETURN_EXPR)
3979 TREE_OPERAND (*tp, 0) = dp->result;
3980 /* Change all cleanups for the NRV to only run when an exception is
3982 else if (TREE_CODE (*tp) == CLEANUP_STMT
3983 && CLEANUP_DECL (*tp) == dp->var)
3984 CLEANUP_EH_ONLY (*tp) = 1;
3985 /* Replace the DECL_EXPR for the NRV with an initialization of the
3986 RESULT_DECL, if needed. */
3987 else if (TREE_CODE (*tp) == DECL_EXPR
3988 && DECL_EXPR_DECL (*tp) == dp->var)
3991 if (DECL_INITIAL (dp->var)
3992 && DECL_INITIAL (dp->var) != error_mark_node)
3993 init = build2 (INIT_EXPR, void_type_node, dp->result,
3994 DECL_INITIAL (dp->var));
3996 init = build_empty_stmt (EXPR_LOCATION (*tp));
3997 DECL_INITIAL (dp->var) = NULL_TREE;
3998 SET_EXPR_LOCATION (init, EXPR_LOCATION (*tp));
4001 /* And replace all uses of the NRV with the RESULT_DECL. */
4002 else if (*tp == dp->var)
4005 /* Avoid walking into the same tree more than once. Unfortunately, we
4006 can't just use walk_tree_without duplicates because it would only call
4007 us for the first occurrence of dp->var in the function body. */
4008 slot = dp->visited.find_slot (*tp, INSERT);
4014 /* Keep iterating. */
4018 /* Called from finish_function to implement the named return value
4019 optimization by overriding all the RETURN_EXPRs and pertinent
4020 CLEANUP_STMTs and replacing all occurrences of VAR with RESULT, the
4021 RESULT_DECL for the function. */
4024 finalize_nrv (tree *tp, tree var, tree result)
4026 struct nrv_data data;
4028 /* Copy name from VAR to RESULT. */
4029 DECL_NAME (result) = DECL_NAME (var);
4030 /* Don't forget that we take its address. */
4031 TREE_ADDRESSABLE (result) = TREE_ADDRESSABLE (var);
4032 /* Finally set DECL_VALUE_EXPR to avoid assigning
4033 a stack slot at -O0 for the original var and debug info
4034 uses RESULT location for VAR. */
4035 SET_DECL_VALUE_EXPR (var, result);
4036 DECL_HAS_VALUE_EXPR_P (var) = 1;
4039 data.result = result;
4040 data.visited.create (37);
4041 cp_walk_tree (tp, finalize_nrv_r, &data, 0);
4042 data.visited.dispose ();
4045 /* Create CP_OMP_CLAUSE_INFO for clause C. Returns true if it is invalid. */
4048 cxx_omp_create_clause_info (tree c, tree type, bool need_default_ctor,
4049 bool need_copy_ctor, bool need_copy_assignment)
4051 int save_errorcount = errorcount;
4054 /* Always allocate 3 elements for simplicity. These are the
4055 function decls for the ctor, dtor, and assignment op.
4056 This layout is known to the three lang hooks,
4057 cxx_omp_clause_default_init, cxx_omp_clause_copy_init,
4058 and cxx_omp_clause_assign_op. */
4059 info = make_tree_vec (3);
4060 CP_OMP_CLAUSE_INFO (c) = info;
4062 if (need_default_ctor || need_copy_ctor)
4064 if (need_default_ctor)
4065 t = get_default_ctor (type);
4067 t = get_copy_ctor (type, tf_warning_or_error);
4069 if (t && !trivial_fn_p (t))
4070 TREE_VEC_ELT (info, 0) = t;
4073 if ((need_default_ctor || need_copy_ctor)
4074 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
4075 TREE_VEC_ELT (info, 1) = get_dtor (type, tf_warning_or_error);
4077 if (need_copy_assignment)
4079 t = get_copy_assign (type);
4081 if (t && !trivial_fn_p (t))
4082 TREE_VEC_ELT (info, 2) = t;
4085 return errorcount != save_errorcount;
4088 /* For all elements of CLAUSES, validate them vs OpenMP constraints.
4089 Remove any elements from the list that are invalid. */
4092 finish_omp_clauses (tree clauses)
4094 bitmap_head generic_head, firstprivate_head, lastprivate_head;
4095 tree c, t, *pc = &clauses;
4098 bitmap_obstack_initialize (NULL);
4099 bitmap_initialize (&generic_head, &bitmap_default_obstack);
4100 bitmap_initialize (&firstprivate_head, &bitmap_default_obstack);
4101 bitmap_initialize (&lastprivate_head, &bitmap_default_obstack);
4103 for (pc = &clauses, c = clauses; c ; c = *pc)
4105 bool remove = false;
4107 switch (OMP_CLAUSE_CODE (c))
4109 case OMP_CLAUSE_SHARED:
4111 goto check_dup_generic;
4112 case OMP_CLAUSE_PRIVATE:
4114 goto check_dup_generic;
4115 case OMP_CLAUSE_REDUCTION:
4117 goto check_dup_generic;
4118 case OMP_CLAUSE_COPYPRIVATE:
4119 name = "copyprivate";
4120 goto check_dup_generic;
4121 case OMP_CLAUSE_COPYIN:
4123 goto check_dup_generic;
4125 t = OMP_CLAUSE_DECL (c);
4126 if (!VAR_P (t) && TREE_CODE (t) != PARM_DECL)
4128 if (processing_template_decl)
4131 error ("%qD is not a variable in clause %qs", t, name);
4133 error ("%qE is not a variable in clause %qs", t, name);
4136 else if (bitmap_bit_p (&generic_head, DECL_UID (t))
4137 || bitmap_bit_p (&firstprivate_head, DECL_UID (t))
4138 || bitmap_bit_p (&lastprivate_head, DECL_UID (t)))
4140 error ("%qD appears more than once in data clauses", t);
4144 bitmap_set_bit (&generic_head, DECL_UID (t));
4147 case OMP_CLAUSE_FIRSTPRIVATE:
4148 t = OMP_CLAUSE_DECL (c);
4149 if (!VAR_P (t) && TREE_CODE (t) != PARM_DECL)
4151 if (processing_template_decl)
4154 error ("%qD is not a variable in clause %<firstprivate%>", t);
4156 error ("%qE is not a variable in clause %<firstprivate%>", t);
4159 else if (bitmap_bit_p (&generic_head, DECL_UID (t))
4160 || bitmap_bit_p (&firstprivate_head, DECL_UID (t)))
4162 error ("%qD appears more than once in data clauses", t);
4166 bitmap_set_bit (&firstprivate_head, DECL_UID (t));
4169 case OMP_CLAUSE_LASTPRIVATE:
4170 t = OMP_CLAUSE_DECL (c);
4171 if (!VAR_P (t) && TREE_CODE (t) != PARM_DECL)
4173 if (processing_template_decl)
4176 error ("%qD is not a variable in clause %<lastprivate%>", t);
4178 error ("%qE is not a variable in clause %<lastprivate%>", t);
4181 else if (bitmap_bit_p (&generic_head, DECL_UID (t))
4182 || bitmap_bit_p (&lastprivate_head, DECL_UID (t)))
4184 error ("%qD appears more than once in data clauses", t);
4188 bitmap_set_bit (&lastprivate_head, DECL_UID (t));
4192 t = OMP_CLAUSE_IF_EXPR (c);
4193 t = maybe_convert_cond (t);
4194 if (t == error_mark_node)
4196 else if (!processing_template_decl)
4197 t = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
4198 OMP_CLAUSE_IF_EXPR (c) = t;
4201 case OMP_CLAUSE_FINAL:
4202 t = OMP_CLAUSE_FINAL_EXPR (c);
4203 t = maybe_convert_cond (t);
4204 if (t == error_mark_node)
4206 else if (!processing_template_decl)
4207 t = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
4208 OMP_CLAUSE_FINAL_EXPR (c) = t;
4211 case OMP_CLAUSE_NUM_THREADS:
4212 t = OMP_CLAUSE_NUM_THREADS_EXPR (c);
4213 if (t == error_mark_node)
4215 else if (!type_dependent_expression_p (t)
4216 && !INTEGRAL_TYPE_P (TREE_TYPE (t)))
4218 error ("num_threads expression must be integral");
4223 t = mark_rvalue_use (t);
4224 if (!processing_template_decl)
4225 t = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
4226 OMP_CLAUSE_NUM_THREADS_EXPR (c) = t;
4230 case OMP_CLAUSE_SCHEDULE:
4231 t = OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c);
4234 else if (t == error_mark_node)
4236 else if (!type_dependent_expression_p (t)
4237 && !INTEGRAL_TYPE_P (TREE_TYPE (t)))
4239 error ("schedule chunk size expression must be integral");
4244 t = mark_rvalue_use (t);
4245 if (!processing_template_decl)
4246 t = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
4247 OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c) = t;
4251 case OMP_CLAUSE_NOWAIT:
4252 case OMP_CLAUSE_ORDERED:
4253 case OMP_CLAUSE_DEFAULT:
4254 case OMP_CLAUSE_UNTIED:
4255 case OMP_CLAUSE_COLLAPSE:
4256 case OMP_CLAUSE_MERGEABLE:
4264 *pc = OMP_CLAUSE_CHAIN (c);
4266 pc = &OMP_CLAUSE_CHAIN (c);
4269 for (pc = &clauses, c = clauses; c ; c = *pc)
4271 enum omp_clause_code c_kind = OMP_CLAUSE_CODE (c);
4272 bool remove = false;
4273 bool need_complete_non_reference = false;
4274 bool need_default_ctor = false;
4275 bool need_copy_ctor = false;
4276 bool need_copy_assignment = false;
4277 bool need_implicitly_determined = false;
4278 tree type, inner_type;
4282 case OMP_CLAUSE_SHARED:
4284 need_implicitly_determined = true;
4286 case OMP_CLAUSE_PRIVATE:
4288 need_complete_non_reference = true;
4289 need_default_ctor = true;
4290 need_implicitly_determined = true;
4292 case OMP_CLAUSE_FIRSTPRIVATE:
4293 name = "firstprivate";
4294 need_complete_non_reference = true;
4295 need_copy_ctor = true;
4296 need_implicitly_determined = true;
4298 case OMP_CLAUSE_LASTPRIVATE:
4299 name = "lastprivate";
4300 need_complete_non_reference = true;
4301 need_copy_assignment = true;
4302 need_implicitly_determined = true;
4304 case OMP_CLAUSE_REDUCTION:
4306 need_implicitly_determined = true;
4308 case OMP_CLAUSE_COPYPRIVATE:
4309 name = "copyprivate";
4310 need_copy_assignment = true;
4312 case OMP_CLAUSE_COPYIN:
4314 need_copy_assignment = true;
4317 pc = &OMP_CLAUSE_CHAIN (c);
4321 t = OMP_CLAUSE_DECL (c);
4322 if (processing_template_decl
4323 && !VAR_P (t) && TREE_CODE (t) != PARM_DECL)
4325 pc = &OMP_CLAUSE_CHAIN (c);
4331 case OMP_CLAUSE_LASTPRIVATE:
4332 if (!bitmap_bit_p (&firstprivate_head, DECL_UID (t)))
4333 need_default_ctor = true;
4336 case OMP_CLAUSE_REDUCTION:
4337 if (AGGREGATE_TYPE_P (TREE_TYPE (t))
4338 || POINTER_TYPE_P (TREE_TYPE (t)))
4340 error ("%qE has invalid type for %<reduction%>", t);
4343 else if (FLOAT_TYPE_P (TREE_TYPE (t)))
4345 enum tree_code r_code = OMP_CLAUSE_REDUCTION_CODE (c);
4355 error ("%qE has invalid type for %<reduction(%s)%>",
4356 t, operator_name_info[r_code].name);
4362 case OMP_CLAUSE_COPYIN:
4363 if (!VAR_P (t) || !DECL_THREAD_LOCAL_P (t))
4365 error ("%qE must be %<threadprivate%> for %<copyin%>", t);
4374 if (need_complete_non_reference || need_copy_assignment)
4376 t = require_complete_type (t);
4377 if (t == error_mark_node)
4379 else if (TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE
4380 && need_complete_non_reference)
4382 error ("%qE has reference type for %qs", t, name);
4386 if (need_implicitly_determined)
4388 const char *share_name = NULL;
4390 if (VAR_P (t) && DECL_THREAD_LOCAL_P (t))
4391 share_name = "threadprivate";
4392 else switch (cxx_omp_predetermined_sharing (t))
4394 case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
4396 case OMP_CLAUSE_DEFAULT_SHARED:
4397 /* const vars may be specified in firstprivate clause. */
4398 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_FIRSTPRIVATE
4399 && cxx_omp_const_qual_no_mutable (t))
4401 share_name = "shared";
4403 case OMP_CLAUSE_DEFAULT_PRIVATE:
4404 share_name = "private";
4411 error ("%qE is predetermined %qs for %qs",
4412 t, share_name, name);
4417 /* We're interested in the base element, not arrays. */
4418 inner_type = type = TREE_TYPE (t);
4419 while (TREE_CODE (inner_type) == ARRAY_TYPE)
4420 inner_type = TREE_TYPE (inner_type);
4422 /* Check for special function availability by building a call to one.
4423 Save the results, because later we won't be in the right context
4424 for making these queries. */
4425 if (CLASS_TYPE_P (inner_type)
4426 && COMPLETE_TYPE_P (inner_type)
4427 && (need_default_ctor || need_copy_ctor || need_copy_assignment)
4428 && !type_dependent_expression_p (t)
4429 && cxx_omp_create_clause_info (c, inner_type, need_default_ctor,
4430 need_copy_ctor, need_copy_assignment))
4434 *pc = OMP_CLAUSE_CHAIN (c);
4436 pc = &OMP_CLAUSE_CHAIN (c);
4439 bitmap_obstack_release (NULL);
4443 /* For all variables in the tree_list VARS, mark them as thread local. */
4446 finish_omp_threadprivate (tree vars)
4450 /* Mark every variable in VARS to be assigned thread local storage. */
4451 for (t = vars; t; t = TREE_CHAIN (t))
4453 tree v = TREE_PURPOSE (t);
4455 if (error_operand_p (v))
4457 else if (!VAR_P (v))
4458 error ("%<threadprivate%> %qD is not file, namespace "
4459 "or block scope variable", v);
4460 /* If V had already been marked threadprivate, it doesn't matter
4461 whether it had been used prior to this point. */
4462 else if (TREE_USED (v)
4463 && (DECL_LANG_SPECIFIC (v) == NULL
4464 || !CP_DECL_THREADPRIVATE_P (v)))
4465 error ("%qE declared %<threadprivate%> after first use", v);
4466 else if (! TREE_STATIC (v) && ! DECL_EXTERNAL (v))
4467 error ("automatic variable %qE cannot be %<threadprivate%>", v);
4468 else if (! COMPLETE_TYPE_P (complete_type (TREE_TYPE (v))))
4469 error ("%<threadprivate%> %qE has incomplete type", v);
4470 else if (TREE_STATIC (v) && TYPE_P (CP_DECL_CONTEXT (v))
4471 && CP_DECL_CONTEXT (v) != current_class_type)
4472 error ("%<threadprivate%> %qE directive not "
4473 "in %qT definition", v, CP_DECL_CONTEXT (v));
4476 /* Allocate a LANG_SPECIFIC structure for V, if needed. */
4477 if (DECL_LANG_SPECIFIC (v) == NULL)
4479 retrofit_lang_decl (v);
4481 /* Make sure that DECL_DISCRIMINATOR_P continues to be true
4482 after the allocation of the lang_decl structure. */
4483 if (DECL_DISCRIMINATOR_P (v))
4484 DECL_LANG_SPECIFIC (v)->u.base.u2sel = 1;
4487 if (! DECL_THREAD_LOCAL_P (v))
4489 DECL_TLS_MODEL (v) = decl_default_tls_model (v);
4490 /* If rtl has been already set for this var, call
4491 make_decl_rtl once again, so that encode_section_info
4492 has a chance to look at the new decl flags. */
4493 if (DECL_RTL_SET_P (v))
4496 CP_DECL_THREADPRIVATE_P (v) = 1;
4501 /* Build an OpenMP structured block. */
4504 begin_omp_structured_block (void)
4506 return do_pushlevel (sk_omp);
4510 finish_omp_structured_block (tree block)
4512 return do_poplevel (block);
4515 /* Similarly, except force the retention of the BLOCK. */
4518 begin_omp_parallel (void)
4520 keep_next_level (true);
4521 return begin_omp_structured_block ();
4525 finish_omp_parallel (tree clauses, tree body)
4529 body = finish_omp_structured_block (body);
4531 stmt = make_node (OMP_PARALLEL);
4532 TREE_TYPE (stmt) = void_type_node;
4533 OMP_PARALLEL_CLAUSES (stmt) = clauses;
4534 OMP_PARALLEL_BODY (stmt) = body;
4536 return add_stmt (stmt);
4540 begin_omp_task (void)
4542 keep_next_level (true);
4543 return begin_omp_structured_block ();
4547 finish_omp_task (tree clauses, tree body)
4551 body = finish_omp_structured_block (body);
4553 stmt = make_node (OMP_TASK);
4554 TREE_TYPE (stmt) = void_type_node;
4555 OMP_TASK_CLAUSES (stmt) = clauses;
4556 OMP_TASK_BODY (stmt) = body;
4558 return add_stmt (stmt);
4561 /* Helper function for finish_omp_for. Convert Ith random access iterator
4562 into integral iterator. Return FALSE if successful. */
4565 handle_omp_for_class_iterator (int i, location_t locus, tree declv, tree initv,
4566 tree condv, tree incrv, tree *body,
4567 tree *pre_body, tree clauses)
4569 tree diff, iter_init, iter_incr = NULL, last;
4570 tree incr_var = NULL, orig_pre_body, orig_body, c;
4571 tree decl = TREE_VEC_ELT (declv, i);
4572 tree init = TREE_VEC_ELT (initv, i);
4573 tree cond = TREE_VEC_ELT (condv, i);
4574 tree incr = TREE_VEC_ELT (incrv, i);
4576 location_t elocus = locus;
4578 if (init && EXPR_HAS_LOCATION (init))
4579 elocus = EXPR_LOCATION (init);
4581 switch (TREE_CODE (cond))
4587 if (TREE_OPERAND (cond, 1) == iter)
4588 cond = build2 (swap_tree_comparison (TREE_CODE (cond)),
4589 TREE_TYPE (cond), iter, TREE_OPERAND (cond, 0));
4590 if (TREE_OPERAND (cond, 0) != iter)
4591 cond = error_mark_node;
4594 tree tem = build_x_binary_op (EXPR_LOCATION (cond),
4597 TREE_OPERAND (cond, 1), ERROR_MARK,
4598 NULL, tf_warning_or_error);
4599 if (error_operand_p (tem))
4604 cond = error_mark_node;
4607 if (cond == error_mark_node)
4609 error_at (elocus, "invalid controlling predicate");
4612 diff = build_x_binary_op (elocus, MINUS_EXPR, TREE_OPERAND (cond, 1),
4613 ERROR_MARK, iter, ERROR_MARK, NULL,
4614 tf_warning_or_error);
4615 if (error_operand_p (diff))
4617 if (TREE_CODE (TREE_TYPE (diff)) != INTEGER_TYPE)
4619 error_at (elocus, "difference between %qE and %qD does not have integer type",
4620 TREE_OPERAND (cond, 1), iter);
4624 switch (TREE_CODE (incr))
4626 case PREINCREMENT_EXPR:
4627 case PREDECREMENT_EXPR:
4628 case POSTINCREMENT_EXPR:
4629 case POSTDECREMENT_EXPR:
4630 if (TREE_OPERAND (incr, 0) != iter)
4632 incr = error_mark_node;
4635 iter_incr = build_x_unary_op (EXPR_LOCATION (incr),
4636 TREE_CODE (incr), iter,
4637 tf_warning_or_error);
4638 if (error_operand_p (iter_incr))
4640 else if (TREE_CODE (incr) == PREINCREMENT_EXPR
4641 || TREE_CODE (incr) == POSTINCREMENT_EXPR)
4642 incr = integer_one_node;
4644 incr = integer_minus_one_node;
4647 if (TREE_OPERAND (incr, 0) != iter)
4648 incr = error_mark_node;
4649 else if (TREE_CODE (TREE_OPERAND (incr, 1)) == PLUS_EXPR
4650 || TREE_CODE (TREE_OPERAND (incr, 1)) == MINUS_EXPR)
4652 tree rhs = TREE_OPERAND (incr, 1);
4653 if (TREE_OPERAND (rhs, 0) == iter)
4655 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs, 1)))
4657 incr = error_mark_node;
4660 iter_incr = build_x_modify_expr (EXPR_LOCATION (rhs),
4661 iter, TREE_CODE (rhs),
4662 TREE_OPERAND (rhs, 1),
4663 tf_warning_or_error);
4664 if (error_operand_p (iter_incr))
4666 incr = TREE_OPERAND (rhs, 1);
4667 incr = cp_convert (TREE_TYPE (diff), incr,
4668 tf_warning_or_error);
4669 if (TREE_CODE (rhs) == MINUS_EXPR)
4671 incr = build1 (NEGATE_EXPR, TREE_TYPE (diff), incr);
4672 incr = fold_if_not_in_template (incr);
4674 if (TREE_CODE (incr) != INTEGER_CST
4675 && (TREE_CODE (incr) != NOP_EXPR
4676 || (TREE_CODE (TREE_OPERAND (incr, 0))
4681 else if (TREE_OPERAND (rhs, 1) == iter)
4683 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs, 0))) != INTEGER_TYPE
4684 || TREE_CODE (rhs) != PLUS_EXPR)
4685 incr = error_mark_node;
4688 iter_incr = build_x_binary_op (EXPR_LOCATION (rhs),
4690 TREE_OPERAND (rhs, 0),
4693 tf_warning_or_error);
4694 if (error_operand_p (iter_incr))
4696 iter_incr = build_x_modify_expr (EXPR_LOCATION (rhs),
4699 tf_warning_or_error);
4700 if (error_operand_p (iter_incr))
4702 incr = TREE_OPERAND (rhs, 0);
4707 incr = error_mark_node;
4710 incr = error_mark_node;
4713 incr = error_mark_node;
4717 if (incr == error_mark_node)
4719 error_at (elocus, "invalid increment expression");
4723 incr = cp_convert (TREE_TYPE (diff), incr, tf_warning_or_error);
4724 for (c = clauses; c ; c = OMP_CLAUSE_CHAIN (c))
4725 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LASTPRIVATE
4726 && OMP_CLAUSE_DECL (c) == iter)
4729 decl = create_temporary_var (TREE_TYPE (diff));
4731 add_decl_expr (decl);
4732 last = create_temporary_var (TREE_TYPE (diff));
4734 add_decl_expr (last);
4735 if (c && iter_incr == NULL)
4737 incr_var = create_temporary_var (TREE_TYPE (diff));
4738 pushdecl (incr_var);
4739 add_decl_expr (incr_var);
4741 gcc_assert (stmts_are_full_exprs_p ());
4743 orig_pre_body = *pre_body;
4744 *pre_body = push_stmt_list ();
4746 add_stmt (orig_pre_body);
4748 finish_expr_stmt (build_x_modify_expr (elocus,
4749 iter, NOP_EXPR, init,
4750 tf_warning_or_error));
4751 init = build_int_cst (TREE_TYPE (diff), 0);
4752 if (c && iter_incr == NULL)
4754 finish_expr_stmt (build_x_modify_expr (elocus,
4756 incr, tf_warning_or_error));
4758 iter_incr = build_x_modify_expr (elocus,
4759 iter, PLUS_EXPR, incr,
4760 tf_warning_or_error);
4762 finish_expr_stmt (build_x_modify_expr (elocus,
4763 last, NOP_EXPR, init,
4764 tf_warning_or_error));
4765 *pre_body = pop_stmt_list (*pre_body);
4767 cond = cp_build_binary_op (elocus,
4768 TREE_CODE (cond), decl, diff,
4769 tf_warning_or_error);
4770 incr = build_modify_expr (elocus, decl, NULL_TREE, PLUS_EXPR,
4771 elocus, incr, NULL_TREE);
4774 *body = push_stmt_list ();
4775 iter_init = build2 (MINUS_EXPR, TREE_TYPE (diff), decl, last);
4776 iter_init = build_x_modify_expr (elocus,
4777 iter, PLUS_EXPR, iter_init,
4778 tf_warning_or_error);
4779 iter_init = build1 (NOP_EXPR, void_type_node, iter_init);
4780 finish_expr_stmt (iter_init);
4781 finish_expr_stmt (build_x_modify_expr (elocus,
4782 last, NOP_EXPR, decl,
4783 tf_warning_or_error));
4784 add_stmt (orig_body);
4785 *body = pop_stmt_list (*body);
4789 OMP_CLAUSE_LASTPRIVATE_STMT (c) = push_stmt_list ();
4790 finish_expr_stmt (iter_incr);
4791 OMP_CLAUSE_LASTPRIVATE_STMT (c)
4792 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (c));
4795 TREE_VEC_ELT (declv, i) = decl;
4796 TREE_VEC_ELT (initv, i) = init;
4797 TREE_VEC_ELT (condv, i) = cond;
4798 TREE_VEC_ELT (incrv, i) = incr;
4803 /* Build and validate an OMP_FOR statement. CLAUSES, BODY, COND, INCR
4804 are directly for their associated operands in the statement. DECL
4805 and INIT are a combo; if DECL is NULL then INIT ought to be a
4806 MODIFY_EXPR, and the DECL should be extracted. PRE_BODY are
4807 optional statements that need to go before the loop into its
4811 finish_omp_for (location_t locus, tree declv, tree initv, tree condv,
4812 tree incrv, tree body, tree pre_body, tree clauses)
4814 tree omp_for = NULL, orig_incr = NULL;
4815 tree decl, init, cond, incr;
4819 gcc_assert (TREE_VEC_LENGTH (declv) == TREE_VEC_LENGTH (initv));
4820 gcc_assert (TREE_VEC_LENGTH (declv) == TREE_VEC_LENGTH (condv));
4821 gcc_assert (TREE_VEC_LENGTH (declv) == TREE_VEC_LENGTH (incrv));
4822 for (i = 0; i < TREE_VEC_LENGTH (declv); i++)
4824 decl = TREE_VEC_ELT (declv, i);
4825 init = TREE_VEC_ELT (initv, i);
4826 cond = TREE_VEC_ELT (condv, i);
4827 incr = TREE_VEC_ELT (incrv, i);
4833 switch (TREE_CODE (init))
4836 decl = TREE_OPERAND (init, 0);
4837 init = TREE_OPERAND (init, 1);
4840 if (TREE_CODE (TREE_OPERAND (init, 1)) == NOP_EXPR)
4842 decl = TREE_OPERAND (init, 0);
4843 init = TREE_OPERAND (init, 2);
4853 "expected iteration declaration or initialization");
4858 if (init && EXPR_HAS_LOCATION (init))
4859 elocus = EXPR_LOCATION (init);
4863 error_at (elocus, "missing controlling predicate");
4869 error_at (elocus, "missing increment expression");
4873 TREE_VEC_ELT (declv, i) = decl;
4874 TREE_VEC_ELT (initv, i) = init;
4877 if (dependent_omp_for_p (declv, initv, condv, incrv))
4881 stmt = make_node (OMP_FOR);
4883 for (i = 0; i < TREE_VEC_LENGTH (declv); i++)
4885 /* This is really just a place-holder. We'll be decomposing this
4886 again and going through the cp_build_modify_expr path below when
4887 we instantiate the thing. */
4888 TREE_VEC_ELT (initv, i)
4889 = build2 (MODIFY_EXPR, void_type_node, TREE_VEC_ELT (declv, i),
4890 TREE_VEC_ELT (initv, i));
4893 TREE_TYPE (stmt) = void_type_node;
4894 OMP_FOR_INIT (stmt) = initv;
4895 OMP_FOR_COND (stmt) = condv;
4896 OMP_FOR_INCR (stmt) = incrv;
4897 OMP_FOR_BODY (stmt) = body;
4898 OMP_FOR_PRE_BODY (stmt) = pre_body;
4899 OMP_FOR_CLAUSES (stmt) = clauses;
4901 SET_EXPR_LOCATION (stmt, locus);
4902 return add_stmt (stmt);
4905 if (processing_template_decl)
4906 orig_incr = make_tree_vec (TREE_VEC_LENGTH (incrv));
4908 for (i = 0; i < TREE_VEC_LENGTH (declv); )
4910 decl = TREE_VEC_ELT (declv, i);
4911 init = TREE_VEC_ELT (initv, i);
4912 cond = TREE_VEC_ELT (condv, i);
4913 incr = TREE_VEC_ELT (incrv, i);
4915 TREE_VEC_ELT (orig_incr, i) = incr;
4918 if (init && EXPR_HAS_LOCATION (init))
4919 elocus = EXPR_LOCATION (init);
4923 error_at (elocus, "expected iteration declaration or initialization");
4927 if (incr && TREE_CODE (incr) == MODOP_EXPR)
4930 TREE_VEC_ELT (orig_incr, i) = incr;
4931 incr = cp_build_modify_expr (TREE_OPERAND (incr, 0),
4932 TREE_CODE (TREE_OPERAND (incr, 1)),
4933 TREE_OPERAND (incr, 2),
4934 tf_warning_or_error);
4937 if (CLASS_TYPE_P (TREE_TYPE (decl)))
4939 if (handle_omp_for_class_iterator (i, locus, declv, initv, condv,
4940 incrv, &body, &pre_body, clauses))
4945 if (!INTEGRAL_TYPE_P (TREE_TYPE (decl))
4946 && !TYPE_PTR_P (TREE_TYPE (decl)))
4948 error_at (elocus, "invalid type for iteration variable %qE", decl);
4952 if (!processing_template_decl)
4954 init = fold_build_cleanup_point_expr (TREE_TYPE (init), init);
4955 init = cp_build_modify_expr (decl, NOP_EXPR, init, tf_warning_or_error);
4958 init = build2 (MODIFY_EXPR, void_type_node, decl, init);
4960 && TREE_SIDE_EFFECTS (cond)
4961 && COMPARISON_CLASS_P (cond)
4962 && !processing_template_decl)
4964 tree t = TREE_OPERAND (cond, 0);
4965 if (TREE_SIDE_EFFECTS (t)
4967 && (TREE_CODE (t) != NOP_EXPR
4968 || TREE_OPERAND (t, 0) != decl))
4969 TREE_OPERAND (cond, 0)
4970 = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
4972 t = TREE_OPERAND (cond, 1);
4973 if (TREE_SIDE_EFFECTS (t)
4975 && (TREE_CODE (t) != NOP_EXPR
4976 || TREE_OPERAND (t, 0) != decl))
4977 TREE_OPERAND (cond, 1)
4978 = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
4980 if (decl == error_mark_node || init == error_mark_node)
4983 TREE_VEC_ELT (declv, i) = decl;
4984 TREE_VEC_ELT (initv, i) = init;
4985 TREE_VEC_ELT (condv, i) = cond;
4986 TREE_VEC_ELT (incrv, i) = incr;
4990 if (IS_EMPTY_STMT (pre_body))
4993 omp_for = c_finish_omp_for (locus, declv, initv, condv, incrv,
4996 if (omp_for == NULL)
4999 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INCR (omp_for)); i++)
5001 decl = TREE_OPERAND (TREE_VEC_ELT (OMP_FOR_INIT (omp_for), i), 0);
5002 incr = TREE_VEC_ELT (OMP_FOR_INCR (omp_for), i);
5004 if (TREE_CODE (incr) != MODIFY_EXPR)
5007 if (TREE_SIDE_EFFECTS (TREE_OPERAND (incr, 1))
5008 && BINARY_CLASS_P (TREE_OPERAND (incr, 1))
5009 && !processing_template_decl)
5011 tree t = TREE_OPERAND (TREE_OPERAND (incr, 1), 0);
5012 if (TREE_SIDE_EFFECTS (t)
5014 && (TREE_CODE (t) != NOP_EXPR
5015 || TREE_OPERAND (t, 0) != decl))
5016 TREE_OPERAND (TREE_OPERAND (incr, 1), 0)
5017 = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
5019 t = TREE_OPERAND (TREE_OPERAND (incr, 1), 1);
5020 if (TREE_SIDE_EFFECTS (t)
5022 && (TREE_CODE (t) != NOP_EXPR
5023 || TREE_OPERAND (t, 0) != decl))
5024 TREE_OPERAND (TREE_OPERAND (incr, 1), 1)
5025 = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
5029 TREE_VEC_ELT (OMP_FOR_INCR (omp_for), i) = TREE_VEC_ELT (orig_incr, i);
5031 if (omp_for != NULL)
5032 OMP_FOR_CLAUSES (omp_for) = clauses;
5037 finish_omp_atomic (enum tree_code code, enum tree_code opcode, tree lhs,
5038 tree rhs, tree v, tree lhs1, tree rhs1)
5053 dependent_p = false;
5056 /* Even in a template, we can detect invalid uses of the atomic
5057 pragma if neither LHS nor RHS is type-dependent. */
5058 if (processing_template_decl)
5060 dependent_p = (type_dependent_expression_p (lhs)
5061 || (rhs && type_dependent_expression_p (rhs))
5062 || (v && type_dependent_expression_p (v))
5063 || (lhs1 && type_dependent_expression_p (lhs1))
5064 || (rhs1 && type_dependent_expression_p (rhs1)));
5067 lhs = build_non_dependent_expr (lhs);
5069 rhs = build_non_dependent_expr (rhs);
5071 v = build_non_dependent_expr (v);
5073 lhs1 = build_non_dependent_expr (lhs1);
5075 rhs1 = build_non_dependent_expr (rhs1);
5080 stmt = c_finish_omp_atomic (input_location, code, opcode, lhs, rhs,
5082 if (stmt == error_mark_node)
5085 if (processing_template_decl)
5087 if (code == OMP_ATOMIC_READ)
5089 stmt = build_min_nt_loc (EXPR_LOCATION (orig_lhs),
5090 OMP_ATOMIC_READ, orig_lhs);
5091 stmt = build2 (MODIFY_EXPR, void_type_node, orig_v, stmt);
5095 if (opcode == NOP_EXPR)
5096 stmt = build2 (MODIFY_EXPR, void_type_node, orig_lhs, orig_rhs);
5098 stmt = build2 (opcode, void_type_node, orig_lhs, orig_rhs);
5100 stmt = build_min_nt_loc (EXPR_LOCATION (orig_rhs1),
5101 COMPOUND_EXPR, orig_rhs1, stmt);
5102 if (code != OMP_ATOMIC)
5104 stmt = build_min_nt_loc (EXPR_LOCATION (orig_lhs1),
5105 code, orig_lhs1, stmt);
5106 stmt = build2 (MODIFY_EXPR, void_type_node, orig_v, stmt);
5109 stmt = build2 (OMP_ATOMIC, void_type_node, integer_zero_node, stmt);
5115 finish_omp_barrier (void)
5117 tree fn = builtin_decl_explicit (BUILT_IN_GOMP_BARRIER);
5118 vec<tree, va_gc> *vec = make_tree_vector ();
5119 tree stmt = finish_call_expr (fn, &vec, false, false, tf_warning_or_error);
5120 release_tree_vector (vec);
5121 finish_expr_stmt (stmt);
5125 finish_omp_flush (void)
5127 tree fn = builtin_decl_explicit (BUILT_IN_SYNC_SYNCHRONIZE);
5128 vec<tree, va_gc> *vec = make_tree_vector ();
5129 tree stmt = finish_call_expr (fn, &vec, false, false, tf_warning_or_error);
5130 release_tree_vector (vec);
5131 finish_expr_stmt (stmt);
5135 finish_omp_taskwait (void)
5137 tree fn = builtin_decl_explicit (BUILT_IN_GOMP_TASKWAIT);
5138 vec<tree, va_gc> *vec = make_tree_vector ();
5139 tree stmt = finish_call_expr (fn, &vec, false, false, tf_warning_or_error);
5140 release_tree_vector (vec);
5141 finish_expr_stmt (stmt);
5145 finish_omp_taskyield (void)
5147 tree fn = builtin_decl_explicit (BUILT_IN_GOMP_TASKYIELD);
5148 vec<tree, va_gc> *vec = make_tree_vector ();
5149 tree stmt = finish_call_expr (fn, &vec, false, false, tf_warning_or_error);
5150 release_tree_vector (vec);
5151 finish_expr_stmt (stmt);
5154 /* Begin a __transaction_atomic or __transaction_relaxed statement.
5155 If PCOMPOUND is non-null, this is for a function-transaction-block, and we
5156 should create an extra compound stmt. */
5159 begin_transaction_stmt (location_t loc, tree *pcompound, int flags)
5164 *pcompound = begin_compound_stmt (0);
5166 r = build_stmt (loc, TRANSACTION_EXPR, NULL_TREE);
5168 /* Only add the statement to the function if support enabled. */
5172 error_at (loc, ((flags & TM_STMT_ATTR_RELAXED) != 0
5173 ? G_("%<__transaction_relaxed%> without "
5174 "transactional memory support enabled")
5175 : G_("%<__transaction_atomic%> without "
5176 "transactional memory support enabled")));
5178 TRANSACTION_EXPR_BODY (r) = push_stmt_list ();
5179 TREE_SIDE_EFFECTS (r) = 1;
5183 /* End a __transaction_atomic or __transaction_relaxed statement.
5184 If COMPOUND_STMT is non-null, this is for a function-transaction-block,
5185 and we should end the compound. If NOEX is non-NULL, we wrap the body in
5186 a MUST_NOT_THROW_EXPR with NOEX as condition. */
5189 finish_transaction_stmt (tree stmt, tree compound_stmt, int flags, tree noex)
5191 TRANSACTION_EXPR_BODY (stmt) = pop_stmt_list (TRANSACTION_EXPR_BODY (stmt));
5192 TRANSACTION_EXPR_OUTER (stmt) = (flags & TM_STMT_ATTR_OUTER) != 0;
5193 TRANSACTION_EXPR_RELAXED (stmt) = (flags & TM_STMT_ATTR_RELAXED) != 0;
5194 TRANSACTION_EXPR_IS_STMT (stmt) = 1;
5196 /* noexcept specifications are not allowed for function transactions. */
5197 gcc_assert (!(noex && compound_stmt));
5200 tree body = build_must_not_throw_expr (TRANSACTION_EXPR_BODY (stmt),
5202 /* This may not be true when the STATEMENT_LIST is empty. */
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);
5213 /* Build a __transaction_atomic or __transaction_relaxed expression. If
5214 NOEX is non-NULL, we wrap the body in a MUST_NOT_THROW_EXPR with NOEX as
5218 build_transaction_expr (location_t loc, tree expr, int flags, tree noex)
5223 expr = build_must_not_throw_expr (expr, noex);
5224 SET_EXPR_LOCATION (expr, loc);
5225 TREE_SIDE_EFFECTS (expr) = 1;
5227 ret = build1 (TRANSACTION_EXPR, TREE_TYPE (expr), expr);
5228 if (flags & TM_STMT_ATTR_RELAXED)
5229 TRANSACTION_EXPR_RELAXED (ret) = 1;
5230 TREE_SIDE_EFFECTS (ret) = 1;
5231 SET_EXPR_LOCATION (ret, loc);
5236 init_cp_semantics (void)
5240 /* Build a STATIC_ASSERT for a static assertion with the condition
5241 CONDITION and the message text MESSAGE. LOCATION is the location
5242 of the static assertion in the source code. When MEMBER_P, this
5243 static assertion is a member of a class. */
5245 finish_static_assert (tree condition, tree message, location_t location,
5248 if (message == NULL_TREE
5249 || message == error_mark_node
5250 || condition == NULL_TREE
5251 || condition == error_mark_node)
5254 if (check_for_bare_parameter_packs (condition))
5255 condition = error_mark_node;
5257 if (type_dependent_expression_p (condition)
5258 || value_dependent_expression_p (condition))
5260 /* We're in a template; build a STATIC_ASSERT and put it in
5264 assertion = make_node (STATIC_ASSERT);
5265 STATIC_ASSERT_CONDITION (assertion) = condition;
5266 STATIC_ASSERT_MESSAGE (assertion) = message;
5267 STATIC_ASSERT_SOURCE_LOCATION (assertion) = location;
5270 maybe_add_class_template_decl_list (current_class_type,
5274 add_stmt (assertion);
5279 /* Fold the expression and convert it to a boolean value. */
5280 condition = fold_non_dependent_expr (condition);
5281 condition = cp_convert (boolean_type_node, condition, tf_warning_or_error);
5282 condition = maybe_constant_value (condition);
5284 if (TREE_CODE (condition) == INTEGER_CST && !integer_zerop (condition))
5285 /* Do nothing; the condition is satisfied. */
5289 location_t saved_loc = input_location;
5291 input_location = location;
5292 if (TREE_CODE (condition) == INTEGER_CST
5293 && integer_zerop (condition))
5294 /* Report the error. */
5295 error ("static assertion failed: %s", TREE_STRING_POINTER (message));
5296 else if (condition && condition != error_mark_node)
5298 error ("non-constant condition for static assertion");
5299 cxx_constant_value (condition);
5301 input_location = saved_loc;
5305 /* Implements the C++0x decltype keyword. Returns the type of EXPR,
5306 suitable for use as a type-specifier.
5308 ID_EXPRESSION_OR_MEMBER_ACCESS_P is true when EXPR was parsed as an
5309 id-expression or a class member access, FALSE when it was parsed as
5310 a full expression. */
5313 finish_decltype_type (tree expr, bool id_expression_or_member_access_p,
5314 tsubst_flags_t complain)
5316 tree type = NULL_TREE;
5318 if (!expr || error_operand_p (expr))
5319 return error_mark_node;
5322 || TREE_CODE (expr) == TYPE_DECL
5323 || (TREE_CODE (expr) == BIT_NOT_EXPR
5324 && TYPE_P (TREE_OPERAND (expr, 0))))
5326 if (complain & tf_error)
5327 error ("argument to decltype must be an expression");
5328 return error_mark_node;
5331 /* Depending on the resolution of DR 1172, we may later need to distinguish
5332 instantiation-dependent but not type-dependent expressions so that, say,
5333 A<decltype(sizeof(T))>::U doesn't require 'typename'. */
5334 if (instantiation_dependent_expression_p (expr))
5336 type = cxx_make_type (DECLTYPE_TYPE);
5337 DECLTYPE_TYPE_EXPR (type) = expr;
5338 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type)
5339 = id_expression_or_member_access_p;
5340 SET_TYPE_STRUCTURAL_EQUALITY (type);
5345 /* The type denoted by decltype(e) is defined as follows: */
5347 expr = resolve_nondeduced_context (expr);
5349 if (invalid_nonstatic_memfn_p (expr, complain))
5350 return error_mark_node;
5352 if (type_unknown_p (expr))
5354 if (complain & tf_error)
5355 error ("decltype cannot resolve address of overloaded function");
5356 return error_mark_node;
5359 /* To get the size of a static data member declared as an array of
5360 unknown bound, we need to instantiate it. */
5362 && VAR_HAD_UNKNOWN_BOUND (expr)
5363 && DECL_TEMPLATE_INSTANTIATION (expr))
5364 instantiate_decl (expr, /*defer_ok*/true, /*expl_inst_mem*/false);
5366 if (id_expression_or_member_access_p)
5368 /* If e is an id-expression or a class member access (5.2.5
5369 [expr.ref]), decltype(e) is defined as the type of the entity
5370 named by e. If there is no such entity, or e names a set of
5371 overloaded functions, the program is ill-formed. */
5372 if (identifier_p (expr))
5373 expr = lookup_name (expr);
5375 if (INDIRECT_REF_P (expr))
5376 /* This can happen when the expression is, e.g., "a.b". Just
5377 look at the underlying operand. */
5378 expr = TREE_OPERAND (expr, 0);
5380 if (TREE_CODE (expr) == OFFSET_REF
5381 || TREE_CODE (expr) == MEMBER_REF
5382 || TREE_CODE (expr) == SCOPE_REF)
5383 /* We're only interested in the field itself. If it is a
5384 BASELINK, we will need to see through it in the next
5386 expr = TREE_OPERAND (expr, 1);
5388 if (BASELINK_P (expr))
5389 /* See through BASELINK nodes to the underlying function. */
5390 expr = BASELINK_FUNCTIONS (expr);
5392 switch (TREE_CODE (expr))
5395 if (DECL_BIT_FIELD_TYPE (expr))
5397 type = DECL_BIT_FIELD_TYPE (expr);
5400 /* Fall through for fields that aren't bitfields. */
5407 case TEMPLATE_PARM_INDEX:
5408 expr = mark_type_use (expr);
5409 type = TREE_TYPE (expr);
5413 type = error_mark_node;
5418 mark_type_use (expr);
5419 type = is_bitfield_expr_with_lowered_type (expr);
5421 type = TREE_TYPE (TREE_OPERAND (expr, 1));
5429 /* We can get here when the id-expression refers to an
5430 enumerator or non-type template parameter. */
5431 type = TREE_TYPE (expr);
5435 /* Handle instantiated template non-type arguments. */
5436 type = TREE_TYPE (expr);
5442 /* Within a lambda-expression:
5444 Every occurrence of decltype((x)) where x is a possibly
5445 parenthesized id-expression that names an entity of
5446 automatic storage duration is treated as if x were
5447 transformed into an access to a corresponding data member
5448 of the closure type that would have been declared if x
5449 were a use of the denoted entity. */
5450 if (outer_automatic_var_p (expr)
5451 && current_function_decl
5452 && LAMBDA_FUNCTION_P (current_function_decl))
5453 type = capture_decltype (expr);
5454 else if (error_operand_p (expr))
5455 type = error_mark_node;
5456 else if (expr == current_class_ptr)
5457 /* If the expression is just "this", we want the
5458 cv-unqualified pointer for the "this" type. */
5459 type = TYPE_MAIN_VARIANT (TREE_TYPE (expr));
5462 /* Otherwise, where T is the type of e, if e is an lvalue,
5463 decltype(e) is defined as T&; if an xvalue, T&&; otherwise, T. */
5464 cp_lvalue_kind clk = lvalue_kind (expr);
5465 type = unlowered_expr_type (expr);
5466 gcc_assert (TREE_CODE (type) != REFERENCE_TYPE);
5468 /* For vector types, pick a non-opaque variant. */
5469 if (TREE_CODE (type) == VECTOR_TYPE)
5470 type = strip_typedefs (type);
5472 if (clk != clk_none && !(clk & clk_class))
5473 type = cp_build_reference_type (type, (clk & clk_rvalueref));
5477 if (cxx_dialect >= cxx1y && array_of_runtime_bound_p (type))
5479 if (complain & tf_warning_or_error)
5480 pedwarn (input_location, OPT_Wvla,
5481 "taking decltype of array of runtime bound");
5483 return error_mark_node;
5489 /* Called from trait_expr_value to evaluate either __has_nothrow_assign or
5490 __has_nothrow_copy, depending on assign_p. */
5493 classtype_has_nothrow_assign_or_copy_p (tree type, bool assign_p)
5500 ix = lookup_fnfields_1 (type, ansi_assopname (NOP_EXPR));
5503 fns = (*CLASSTYPE_METHOD_VEC (type))[ix];
5505 else if (TYPE_HAS_COPY_CTOR (type))
5507 /* If construction of the copy constructor was postponed, create
5509 if (CLASSTYPE_LAZY_COPY_CTOR (type))
5510 lazily_declare_fn (sfk_copy_constructor, type);
5511 if (CLASSTYPE_LAZY_MOVE_CTOR (type))
5512 lazily_declare_fn (sfk_move_constructor, type);
5513 fns = CLASSTYPE_CONSTRUCTORS (type);
5518 for (; fns; fns = OVL_NEXT (fns))
5520 tree fn = OVL_CURRENT (fns);
5524 if (copy_fn_p (fn) == 0)
5527 else if (copy_fn_p (fn) <= 0)
5530 maybe_instantiate_noexcept (fn);
5531 if (!TYPE_NOTHROW_P (TREE_TYPE (fn)))
5538 /* Actually evaluates the trait. */
5541 trait_expr_value (cp_trait_kind kind, tree type1, tree type2)
5543 enum tree_code type_code1;
5546 type_code1 = TREE_CODE (type1);
5550 case CPTK_HAS_NOTHROW_ASSIGN:
5551 type1 = strip_array_types (type1);
5552 return (!CP_TYPE_CONST_P (type1) && type_code1 != REFERENCE_TYPE
5553 && (trait_expr_value (CPTK_HAS_TRIVIAL_ASSIGN, type1, type2)
5554 || (CLASS_TYPE_P (type1)
5555 && classtype_has_nothrow_assign_or_copy_p (type1,
5558 case CPTK_HAS_TRIVIAL_ASSIGN:
5559 /* ??? The standard seems to be missing the "or array of such a class
5560 type" wording for this trait. */
5561 type1 = strip_array_types (type1);
5562 return (!CP_TYPE_CONST_P (type1) && type_code1 != REFERENCE_TYPE
5563 && (trivial_type_p (type1)
5564 || (CLASS_TYPE_P (type1)
5565 && TYPE_HAS_TRIVIAL_COPY_ASSIGN (type1))));
5567 case CPTK_HAS_NOTHROW_CONSTRUCTOR:
5568 type1 = strip_array_types (type1);
5569 return (trait_expr_value (CPTK_HAS_TRIVIAL_CONSTRUCTOR, type1, type2)
5570 || (CLASS_TYPE_P (type1)
5571 && (t = locate_ctor (type1))
5572 && (maybe_instantiate_noexcept (t),
5573 TYPE_NOTHROW_P (TREE_TYPE (t)))));
5575 case CPTK_HAS_TRIVIAL_CONSTRUCTOR:
5576 type1 = strip_array_types (type1);
5577 return (trivial_type_p (type1)
5578 || (CLASS_TYPE_P (type1) && TYPE_HAS_TRIVIAL_DFLT (type1)));
5580 case CPTK_HAS_NOTHROW_COPY:
5581 type1 = strip_array_types (type1);
5582 return (trait_expr_value (CPTK_HAS_TRIVIAL_COPY, type1, type2)
5583 || (CLASS_TYPE_P (type1)
5584 && classtype_has_nothrow_assign_or_copy_p (type1, false)));
5586 case CPTK_HAS_TRIVIAL_COPY:
5587 /* ??? The standard seems to be missing the "or array of such a class
5588 type" wording for this trait. */
5589 type1 = strip_array_types (type1);
5590 return (trivial_type_p (type1) || type_code1 == REFERENCE_TYPE
5591 || (CLASS_TYPE_P (type1) && TYPE_HAS_TRIVIAL_COPY_CTOR (type1)));
5593 case CPTK_HAS_TRIVIAL_DESTRUCTOR:
5594 type1 = strip_array_types (type1);
5595 return (trivial_type_p (type1) || type_code1 == REFERENCE_TYPE
5596 || (CLASS_TYPE_P (type1)
5597 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type1)));
5599 case CPTK_HAS_VIRTUAL_DESTRUCTOR:
5600 return type_has_virtual_destructor (type1);
5602 case CPTK_IS_ABSTRACT:
5603 return (ABSTRACT_CLASS_TYPE_P (type1));
5605 case CPTK_IS_BASE_OF:
5606 return (NON_UNION_CLASS_TYPE_P (type1) && NON_UNION_CLASS_TYPE_P (type2)
5607 && DERIVED_FROM_P (type1, type2));
5610 return (NON_UNION_CLASS_TYPE_P (type1));
5612 case CPTK_IS_CONVERTIBLE_TO:
5617 return (NON_UNION_CLASS_TYPE_P (type1) && CLASSTYPE_EMPTY_P (type1));
5620 return (type_code1 == ENUMERAL_TYPE);
5623 return (CLASS_TYPE_P (type1) && CLASSTYPE_FINAL (type1));
5625 case CPTK_IS_LITERAL_TYPE:
5626 return (literal_type_p (type1));
5629 return (pod_type_p (type1));
5631 case CPTK_IS_POLYMORPHIC:
5632 return (CLASS_TYPE_P (type1) && TYPE_POLYMORPHIC_P (type1));
5634 case CPTK_IS_STD_LAYOUT:
5635 return (std_layout_type_p (type1));
5637 case CPTK_IS_TRIVIAL:
5638 return (trivial_type_p (type1));
5641 return (type_code1 == UNION_TYPE);
5649 /* If TYPE is an array of unknown bound, or (possibly cv-qualified)
5650 void, or a complete type, returns it, otherwise NULL_TREE. */
5653 check_trait_type (tree type)
5655 if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
5656 && COMPLETE_TYPE_P (TREE_TYPE (type)))
5659 if (VOID_TYPE_P (type))
5662 return complete_type_or_else (strip_array_types (type), NULL_TREE);
5665 /* Process a trait expression. */
5668 finish_trait_expr (cp_trait_kind kind, tree type1, tree type2)
5670 gcc_assert (kind == CPTK_HAS_NOTHROW_ASSIGN
5671 || kind == CPTK_HAS_NOTHROW_CONSTRUCTOR
5672 || kind == CPTK_HAS_NOTHROW_COPY
5673 || kind == CPTK_HAS_TRIVIAL_ASSIGN
5674 || kind == CPTK_HAS_TRIVIAL_CONSTRUCTOR
5675 || kind == CPTK_HAS_TRIVIAL_COPY
5676 || kind == CPTK_HAS_TRIVIAL_DESTRUCTOR
5677 || kind == CPTK_HAS_VIRTUAL_DESTRUCTOR
5678 || kind == CPTK_IS_ABSTRACT
5679 || kind == CPTK_IS_BASE_OF
5680 || kind == CPTK_IS_CLASS
5681 || kind == CPTK_IS_CONVERTIBLE_TO
5682 || kind == CPTK_IS_EMPTY
5683 || kind == CPTK_IS_ENUM
5684 || kind == CPTK_IS_FINAL
5685 || kind == CPTK_IS_LITERAL_TYPE
5686 || kind == CPTK_IS_POD
5687 || kind == CPTK_IS_POLYMORPHIC
5688 || kind == CPTK_IS_STD_LAYOUT
5689 || kind == CPTK_IS_TRIVIAL
5690 || kind == CPTK_IS_UNION);
5692 if (kind == CPTK_IS_CONVERTIBLE_TO)
5694 sorry ("__is_convertible_to");
5695 return error_mark_node;
5698 if (type1 == error_mark_node
5699 || ((kind == CPTK_IS_BASE_OF || kind == CPTK_IS_CONVERTIBLE_TO)
5700 && type2 == error_mark_node))
5701 return error_mark_node;
5703 if (processing_template_decl)
5705 tree trait_expr = make_node (TRAIT_EXPR);
5706 TREE_TYPE (trait_expr) = boolean_type_node;
5707 TRAIT_EXPR_TYPE1 (trait_expr) = type1;
5708 TRAIT_EXPR_TYPE2 (trait_expr) = type2;
5709 TRAIT_EXPR_KIND (trait_expr) = kind;
5715 case CPTK_HAS_NOTHROW_ASSIGN:
5716 case CPTK_HAS_TRIVIAL_ASSIGN:
5717 case CPTK_HAS_NOTHROW_CONSTRUCTOR:
5718 case CPTK_HAS_TRIVIAL_CONSTRUCTOR:
5719 case CPTK_HAS_NOTHROW_COPY:
5720 case CPTK_HAS_TRIVIAL_COPY:
5721 case CPTK_HAS_TRIVIAL_DESTRUCTOR:
5722 case CPTK_HAS_VIRTUAL_DESTRUCTOR:
5723 case CPTK_IS_ABSTRACT:
5726 case CPTK_IS_LITERAL_TYPE:
5728 case CPTK_IS_POLYMORPHIC:
5729 case CPTK_IS_STD_LAYOUT:
5730 case CPTK_IS_TRIVIAL:
5731 if (!check_trait_type (type1))
5732 return error_mark_node;
5735 case CPTK_IS_BASE_OF:
5736 if (NON_UNION_CLASS_TYPE_P (type1) && NON_UNION_CLASS_TYPE_P (type2)
5737 && !same_type_ignoring_top_level_qualifiers_p (type1, type2)
5738 && !complete_type_or_else (type2, NULL_TREE))
5739 /* We already issued an error. */
5740 return error_mark_node;
5748 case CPTK_IS_CONVERTIBLE_TO:
5753 return (trait_expr_value (kind, type1, type2)
5754 ? boolean_true_node : boolean_false_node);
5757 /* Do-nothing variants of functions to handle pragma FLOAT_CONST_DECIMAL64,
5758 which is ignored for C++. */
5761 set_float_const_decimal64 (void)
5766 clear_float_const_decimal64 (void)
5771 float_const_decimal64_p (void)
5777 /* Return true if T is a literal type. */
5780 literal_type_p (tree t)
5782 if (SCALAR_TYPE_P (t)
5783 || TREE_CODE (t) == VECTOR_TYPE
5784 || TREE_CODE (t) == REFERENCE_TYPE)
5786 if (CLASS_TYPE_P (t))
5788 t = complete_type (t);
5789 gcc_assert (COMPLETE_TYPE_P (t) || errorcount);
5790 return CLASSTYPE_LITERAL_P (t);
5792 if (TREE_CODE (t) == ARRAY_TYPE)
5793 return literal_type_p (strip_array_types (t));
5797 /* If DECL is a variable declared `constexpr', require its type
5798 be literal. Return the DECL if OK, otherwise NULL. */
5801 ensure_literal_type_for_constexpr_object (tree decl)
5803 tree type = TREE_TYPE (decl);
5804 if (VAR_P (decl) && DECL_DECLARED_CONSTEXPR_P (decl)
5805 && !processing_template_decl)
5807 if (CLASS_TYPE_P (type) && !COMPLETE_TYPE_P (complete_type (type)))
5808 /* Don't complain here, we'll complain about incompleteness
5809 when we try to initialize the variable. */;
5810 else if (!literal_type_p (type))
5812 error ("the type %qT of constexpr variable %qD is not literal",
5814 explain_non_literal_class (type);
5821 /* Representation of entries in the constexpr function definition table. */
5823 typedef struct GTY(()) constexpr_fundef {
5828 /* This table holds all constexpr function definitions seen in
5829 the current translation unit. */
5831 static GTY ((param_is (constexpr_fundef))) htab_t constexpr_fundef_table;
5833 /* Utility function used for managing the constexpr function table.
5834 Return true if the entries pointed to by P and Q are for the
5835 same constexpr function. */
5838 constexpr_fundef_equal (const void *p, const void *q)
5840 const constexpr_fundef *lhs = (const constexpr_fundef *) p;
5841 const constexpr_fundef *rhs = (const constexpr_fundef *) q;
5842 return lhs->decl == rhs->decl;
5845 /* Utility function used for managing the constexpr function table.
5846 Return a hash value for the entry pointed to by Q. */
5848 static inline hashval_t
5849 constexpr_fundef_hash (const void *p)
5851 const constexpr_fundef *fundef = (const constexpr_fundef *) p;
5852 return DECL_UID (fundef->decl);
5855 /* Return a previously saved definition of function FUN. */
5857 static constexpr_fundef *
5858 retrieve_constexpr_fundef (tree fun)
5860 constexpr_fundef fundef = { NULL, NULL };
5861 if (constexpr_fundef_table == NULL)
5865 return (constexpr_fundef *) htab_find (constexpr_fundef_table, &fundef);
5868 /* Check whether the parameter and return types of FUN are valid for a
5869 constexpr function, and complain if COMPLAIN. */
5872 is_valid_constexpr_fn (tree fun, bool complain)
5874 tree parm = FUNCTION_FIRST_USER_PARM (fun);
5876 for (; parm != NULL; parm = TREE_CHAIN (parm))
5877 if (!literal_type_p (TREE_TYPE (parm)))
5882 error ("invalid type for parameter %d of constexpr "
5883 "function %q+#D", DECL_PARM_INDEX (parm), fun);
5884 explain_non_literal_class (TREE_TYPE (parm));
5888 if (!DECL_CONSTRUCTOR_P (fun))
5890 tree rettype = TREE_TYPE (TREE_TYPE (fun));
5891 if (!literal_type_p (rettype))
5896 error ("invalid return type %qT of constexpr function %q+D",
5898 explain_non_literal_class (rettype);
5902 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun)
5903 && !CLASSTYPE_LITERAL_P (DECL_CONTEXT (fun)))
5908 error ("enclosing class of constexpr non-static member "
5909 "function %q+#D is not a literal type", fun);
5910 explain_non_literal_class (DECL_CONTEXT (fun));
5914 else if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fun)))
5918 error ("%q#T has virtual base classes", DECL_CONTEXT (fun));
5924 /* Subroutine of build_data_member_initialization. MEMBER is a COMPONENT_REF
5925 for a member of an anonymous aggregate, INIT is the initializer for that
5926 member, and VEC_OUTER is the vector of constructor elements for the class
5927 whose constructor we are processing. Add the initializer to the vector
5928 and return true to indicate success. */
5931 build_anon_member_initialization (tree member, tree init,
5932 vec<constructor_elt, va_gc> **vec_outer)
5934 /* MEMBER presents the relevant fields from the inside out, but we need
5935 to build up the initializer from the outside in so that we can reuse
5936 previously built CONSTRUCTORs if this is, say, the second field in an
5937 anonymous struct. So we use a vec as a stack. */
5942 fields.safe_push (TREE_OPERAND (member, 1));
5943 member = TREE_OPERAND (member, 0);
5945 while (ANON_AGGR_TYPE_P (TREE_TYPE (member)));
5947 /* VEC has the constructor elements vector for the context of FIELD.
5948 If FIELD is an anonymous aggregate, we will push inside it. */
5949 vec<constructor_elt, va_gc> **vec = vec_outer;
5951 while (field = fields.pop(),
5952 ANON_AGGR_TYPE_P (TREE_TYPE (field)))
5955 /* If there is already an outer constructor entry for the anonymous
5956 aggregate FIELD, use it; otherwise, insert one. */
5957 if (vec_safe_is_empty (*vec)
5958 || (*vec)->last().index != field)
5960 ctor = build_constructor (TREE_TYPE (field), NULL);
5961 CONSTRUCTOR_APPEND_ELT (*vec, field, ctor);
5964 ctor = (*vec)->last().value;
5965 vec = &CONSTRUCTOR_ELTS (ctor);
5968 /* Now we're at the innermost field, the one that isn't an anonymous
5969 aggregate. Add its initializer to the CONSTRUCTOR and we're done. */
5970 gcc_assert (fields.is_empty());
5972 CONSTRUCTOR_APPEND_ELT (*vec, field, init);
5977 /* Subroutine of build_constexpr_constructor_member_initializers.
5978 The expression tree T represents a data member initialization
5979 in a (constexpr) constructor definition. Build a pairing of
5980 the data member with its initializer, and prepend that pair
5981 to the existing initialization pair INITS. */
5984 build_data_member_initialization (tree t, vec<constructor_elt, va_gc> **vec)
5987 if (TREE_CODE (t) == CLEANUP_POINT_EXPR)
5988 t = TREE_OPERAND (t, 0);
5989 if (TREE_CODE (t) == EXPR_STMT)
5990 t = TREE_OPERAND (t, 0);
5991 if (t == error_mark_node)
5993 if (TREE_CODE (t) == STATEMENT_LIST)
5995 tree_stmt_iterator i;
5996 for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
5998 if (! build_data_member_initialization (tsi_stmt (i), vec))
6003 if (TREE_CODE (t) == CLEANUP_STMT)
6005 /* We can't see a CLEANUP_STMT in a constructor for a literal class,
6006 but we can in a constexpr constructor for a non-literal class. Just
6007 ignore it; either all the initialization will be constant, in which
6008 case the cleanup can't run, or it can't be constexpr.
6009 Still recurse into CLEANUP_BODY. */
6010 return build_data_member_initialization (CLEANUP_BODY (t), vec);
6012 if (TREE_CODE (t) == CONVERT_EXPR)
6013 t = TREE_OPERAND (t, 0);
6014 if (TREE_CODE (t) == INIT_EXPR
6015 || TREE_CODE (t) == MODIFY_EXPR)
6017 member = TREE_OPERAND (t, 0);
6018 init = break_out_target_exprs (TREE_OPERAND (t, 1));
6020 else if (TREE_CODE (t) == CALL_EXPR)
6022 member = CALL_EXPR_ARG (t, 0);
6023 /* We don't use build_cplus_new here because it complains about
6024 abstract bases. Leaving the call unwrapped means that it has the
6025 wrong type, but cxx_eval_constant_expression doesn't care. */
6026 init = break_out_target_exprs (t);
6028 else if (TREE_CODE (t) == DECL_EXPR)
6029 /* Declaring a temporary, don't add it to the CONSTRUCTOR. */
6033 if (INDIRECT_REF_P (member))
6034 member = TREE_OPERAND (member, 0);
6035 if (TREE_CODE (member) == NOP_EXPR)
6039 if (TREE_CODE (op) == ADDR_EXPR)
6041 gcc_assert (same_type_ignoring_top_level_qualifiers_p
6042 (TREE_TYPE (TREE_TYPE (op)),
6043 TREE_TYPE (TREE_TYPE (member))));
6044 /* Initializing a cv-qualified member; we need to look through
6048 else if (op == current_class_ptr
6049 && (same_type_ignoring_top_level_qualifiers_p
6050 (TREE_TYPE (TREE_TYPE (member)),
6051 current_class_type)))
6052 /* Delegating constructor. */
6056 /* This is an initializer for an empty base; keep it for now so
6057 we can check it in cxx_eval_bare_aggregate. */
6058 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member))));
6061 if (TREE_CODE (member) == ADDR_EXPR)
6062 member = TREE_OPERAND (member, 0);
6063 if (TREE_CODE (member) == COMPONENT_REF)
6065 tree aggr = TREE_OPERAND (member, 0);
6066 if (TREE_CODE (aggr) != COMPONENT_REF)
6067 /* Normal member initialization. */
6068 member = TREE_OPERAND (member, 1);
6069 else if (ANON_AGGR_TYPE_P (TREE_TYPE (aggr)))
6070 /* Initializing a member of an anonymous union. */
6071 return build_anon_member_initialization (member, init, vec);
6073 /* We're initializing a vtable pointer in a base. Leave it as
6074 COMPONENT_REF so we remember the path to get to the vfield. */
6075 gcc_assert (TREE_TYPE (member) == vtbl_ptr_type_node);
6078 CONSTRUCTOR_APPEND_ELT (*vec, member, init);
6082 /* Make sure that there are no statements after LAST in the constructor
6083 body represented by LIST. */
6086 check_constexpr_ctor_body (tree last, tree list)
6089 if (TREE_CODE (list) == STATEMENT_LIST)
6091 tree_stmt_iterator i = tsi_last (list);
6092 for (; !tsi_end_p (i); tsi_prev (&i))
6094 tree t = tsi_stmt (i);
6097 if (TREE_CODE (t) == BIND_EXPR)
6099 if (!check_constexpr_ctor_body (last, BIND_EXPR_BODY (t)))
6104 /* We currently allow typedefs and static_assert.
6105 FIXME allow them in the standard, too. */
6106 if (TREE_CODE (t) != STATIC_ASSERT)
6113 else if (list != last
6114 && TREE_CODE (list) != STATIC_ASSERT)
6118 error ("constexpr constructor does not have empty body");
6119 DECL_DECLARED_CONSTEXPR_P (current_function_decl) = false;
6124 /* V is a vector of constructor elements built up for the base and member
6125 initializers of a constructor for TYPE. They need to be in increasing
6126 offset order, which they might not be yet if TYPE has a primary base
6127 which is not first in the base-clause or a vptr and at least one base
6128 all of which are non-primary. */
6130 static vec<constructor_elt, va_gc> *
6131 sort_constexpr_mem_initializers (tree type, vec<constructor_elt, va_gc> *v)
6133 tree pri = CLASSTYPE_PRIMARY_BINFO (type);
6135 constructor_elt elt;
6139 field_type = BINFO_TYPE (pri);
6140 else if (TYPE_CONTAINS_VPTR_P (type))
6141 field_type = vtbl_ptr_type_node;
6145 /* Find the element for the primary base or vptr and move it to the
6146 beginning of the vec. */
6147 vec<constructor_elt, va_gc> &vref = *v;
6149 if (TREE_TYPE (vref[i].index) == field_type)
6156 vref[i] = vref[i-1];
6163 /* Build compile-time evalable representations of member-initializer list
6164 for a constexpr constructor. */
6167 build_constexpr_constructor_member_initializers (tree type, tree body)
6169 vec<constructor_elt, va_gc> *vec = NULL;
6171 if (TREE_CODE (body) == MUST_NOT_THROW_EXPR
6172 || TREE_CODE (body) == EH_SPEC_BLOCK)
6173 body = TREE_OPERAND (body, 0);
6174 if (TREE_CODE (body) == STATEMENT_LIST)
6175 body = STATEMENT_LIST_HEAD (body)->stmt;
6176 body = BIND_EXPR_BODY (body);
6177 if (TREE_CODE (body) == CLEANUP_POINT_EXPR)
6179 body = TREE_OPERAND (body, 0);
6180 if (TREE_CODE (body) == EXPR_STMT)
6181 body = TREE_OPERAND (body, 0);
6182 if (TREE_CODE (body) == INIT_EXPR
6183 && (same_type_ignoring_top_level_qualifiers_p
6184 (TREE_TYPE (TREE_OPERAND (body, 0)),
6185 current_class_type)))
6188 return TREE_OPERAND (body, 1);
6190 ok = build_data_member_initialization (body, &vec);
6192 else if (TREE_CODE (body) == STATEMENT_LIST)
6194 tree_stmt_iterator i;
6195 for (i = tsi_start (body); !tsi_end_p (i); tsi_next (&i))
6197 ok = build_data_member_initialization (tsi_stmt (i), &vec);
6202 else if (TREE_CODE (body) == TRY_BLOCK)
6204 error ("body of %<constexpr%> constructor cannot be "
6205 "a function-try-block");
6206 return error_mark_node;
6208 else if (EXPR_P (body))
6209 ok = build_data_member_initialization (body, &vec);
6211 gcc_assert (errorcount > 0);
6214 if (vec_safe_length (vec) > 0)
6216 /* In a delegating constructor, return the target. */
6217 constructor_elt *ce = &(*vec)[0];
6218 if (ce->index == current_class_ptr)
6225 vec = sort_constexpr_mem_initializers (type, vec);
6226 return build_constructor (type, vec);
6229 return error_mark_node;
6232 /* Subroutine of register_constexpr_fundef. BODY is the body of a function
6233 declared to be constexpr, or a sub-statement thereof. Returns the
6234 return value if suitable, error_mark_node for a statement not allowed in
6235 a constexpr function, or NULL_TREE if no return value was found. */
6238 constexpr_fn_retval (tree body)
6240 switch (TREE_CODE (body))
6242 case STATEMENT_LIST:
6244 tree_stmt_iterator i;
6245 tree expr = NULL_TREE;
6246 for (i = tsi_start (body); !tsi_end_p (i); tsi_next (&i))
6248 tree s = constexpr_fn_retval (tsi_stmt (i));
6249 if (s == error_mark_node)
6250 return error_mark_node;
6251 else if (s == NULL_TREE)
6252 /* Keep iterating. */;
6254 /* Multiple return statements. */
6255 return error_mark_node;
6263 return break_out_target_exprs (TREE_OPERAND (body, 0));
6266 if (TREE_CODE (DECL_EXPR_DECL (body)) == USING_DECL)
6268 return error_mark_node;
6270 case CLEANUP_POINT_EXPR:
6271 return constexpr_fn_retval (TREE_OPERAND (body, 0));
6277 return error_mark_node;
6281 /* Subroutine of register_constexpr_fundef. BODY is the DECL_SAVED_TREE of
6282 FUN; do the necessary transformations to turn it into a single expression
6283 that we can store in the hash table. */
6286 massage_constexpr_body (tree fun, tree body)
6288 if (DECL_CONSTRUCTOR_P (fun))
6289 body = build_constexpr_constructor_member_initializers
6290 (DECL_CONTEXT (fun), body);
6293 if (TREE_CODE (body) == EH_SPEC_BLOCK)
6294 body = EH_SPEC_STMTS (body);
6295 if (TREE_CODE (body) == MUST_NOT_THROW_EXPR)
6296 body = TREE_OPERAND (body, 0);
6297 if (TREE_CODE (body) == BIND_EXPR)
6298 body = BIND_EXPR_BODY (body);
6299 body = constexpr_fn_retval (body);
6304 /* FUN is a constexpr constructor with massaged body BODY. Return true
6305 if some bases/fields are uninitialized, and complain if COMPLAIN. */
6308 cx_check_missing_mem_inits (tree fun, tree body, bool complain)
6315 if (TREE_CODE (body) != CONSTRUCTOR)
6318 nelts = CONSTRUCTOR_NELTS (body);
6319 ctype = DECL_CONTEXT (fun);
6320 field = TYPE_FIELDS (ctype);
6322 if (TREE_CODE (ctype) == UNION_TYPE)
6324 if (nelts == 0 && next_initializable_field (field))
6327 error ("%<constexpr%> constructor for union %qT must "
6328 "initialize exactly one non-static data member", ctype);
6335 for (i = 0; i <= nelts; ++i)
6342 index = CONSTRUCTOR_ELT (body, i)->index;
6343 /* Skip base and vtable inits. */
6344 if (TREE_CODE (index) != FIELD_DECL
6345 || DECL_ARTIFICIAL (index))
6348 for (; field != index; field = DECL_CHAIN (field))
6351 if (TREE_CODE (field) != FIELD_DECL
6352 || (DECL_C_BIT_FIELD (field) && !DECL_NAME (field))
6353 || DECL_ARTIFICIAL (field))
6355 ftype = strip_array_types (TREE_TYPE (field));
6356 if (type_has_constexpr_default_constructor (ftype))
6358 /* It's OK to skip a member with a trivial constexpr ctor.
6359 A constexpr ctor that isn't trivial should have been
6361 gcc_checking_assert (!TYPE_HAS_COMPLEX_DFLT (ftype)
6362 || errorcount != 0);
6367 error ("uninitialized member %qD in %<constexpr%> constructor",
6371 if (field == NULL_TREE)
6373 field = DECL_CHAIN (field);
6379 /* We are processing the definition of the constexpr function FUN.
6380 Check that its BODY fulfills the propriate requirements and
6381 enter it in the constexpr function definition table.
6382 For constructor BODY is actually the TREE_LIST of the
6383 member-initializer list. */
6386 register_constexpr_fundef (tree fun, tree body)
6388 constexpr_fundef entry;
6389 constexpr_fundef **slot;
6391 if (!is_valid_constexpr_fn (fun, !DECL_GENERATED_P (fun)))
6394 body = massage_constexpr_body (fun, body);
6395 if (body == NULL_TREE || body == error_mark_node)
6397 if (!DECL_CONSTRUCTOR_P (fun))
6398 error ("body of constexpr function %qD not a return-statement", fun);
6402 if (!potential_rvalue_constant_expression (body))
6404 if (!DECL_GENERATED_P (fun))
6405 require_potential_rvalue_constant_expression (body);
6409 if (DECL_CONSTRUCTOR_P (fun)
6410 && cx_check_missing_mem_inits (fun, body, !DECL_GENERATED_P (fun)))
6413 /* Create the constexpr function table if necessary. */
6414 if (constexpr_fundef_table == NULL)
6415 constexpr_fundef_table = htab_create_ggc (101,
6416 constexpr_fundef_hash,
6417 constexpr_fundef_equal,
6421 slot = (constexpr_fundef **)
6422 htab_find_slot (constexpr_fundef_table, &entry, INSERT);
6424 gcc_assert (*slot == NULL);
6425 *slot = ggc_alloc_constexpr_fundef ();
6431 /* FUN is a non-constexpr function called in a context that requires a
6432 constant expression. If it comes from a constexpr template, explain why
6433 the instantiation isn't constexpr. */
6436 explain_invalid_constexpr_fn (tree fun)
6438 static struct pointer_set_t *diagnosed;
6440 location_t save_loc;
6441 /* Only diagnose defaulted functions or instantiations. */
6442 if (!DECL_DEFAULTED_FN (fun)
6443 && !is_instantiation_of_constexpr (fun))
6445 if (diagnosed == NULL)
6446 diagnosed = pointer_set_create ();
6447 if (pointer_set_insert (diagnosed, fun) != 0)
6448 /* Already explained. */
6451 save_loc = input_location;
6452 input_location = DECL_SOURCE_LOCATION (fun);
6453 inform (0, "%q+D is not usable as a constexpr function because:", fun);
6454 /* First check the declaration. */
6455 if (is_valid_constexpr_fn (fun, true))
6457 /* Then if it's OK, the body. */
6458 if (DECL_DEFAULTED_FN (fun))
6459 explain_implicit_non_constexpr (fun);
6462 body = massage_constexpr_body (fun, DECL_SAVED_TREE (fun));
6463 require_potential_rvalue_constant_expression (body);
6464 if (DECL_CONSTRUCTOR_P (fun))
6465 cx_check_missing_mem_inits (fun, body, true);
6468 input_location = save_loc;
6471 /* Objects of this type represent calls to constexpr functions
6472 along with the bindings of parameters to their arguments, for
6473 the purpose of compile time evaluation. */
6475 typedef struct GTY(()) constexpr_call {
6476 /* Description of the constexpr function definition. */
6477 constexpr_fundef *fundef;
6478 /* Parameter bindings environment. A TREE_LIST where each TREE_PURPOSE
6479 is a parameter _DECL and the TREE_VALUE is the value of the parameter.
6480 Note: This arrangement is made to accommodate the use of
6481 iterative_hash_template_arg (see pt.c). If you change this
6482 representation, also change the hash calculation in
6483 cxx_eval_call_expression. */
6485 /* Result of the call.
6486 NULL means the call is being evaluated.
6487 error_mark_node means that the evaluation was erroneous;
6488 otherwise, the actuall value of the call. */
6490 /* The hash of this call; we remember it here to avoid having to
6491 recalculate it when expanding the hash table. */
6495 /* A table of all constexpr calls that have been evaluated by the
6496 compiler in this translation unit. */
6498 static GTY ((param_is (constexpr_call))) htab_t constexpr_call_table;
6500 static tree cxx_eval_constant_expression (const constexpr_call *, tree,
6501 bool, bool, bool *, bool *);
6503 /* Compute a hash value for a constexpr call representation. */
6506 constexpr_call_hash (const void *p)
6508 const constexpr_call *info = (const constexpr_call *) p;
6512 /* Return 1 if the objects pointed to by P and Q represent calls
6513 to the same constexpr function with the same arguments.
6514 Otherwise, return 0. */
6517 constexpr_call_equal (const void *p, const void *q)
6519 const constexpr_call *lhs = (const constexpr_call *) p;
6520 const constexpr_call *rhs = (const constexpr_call *) q;
6525 if (!constexpr_fundef_equal (lhs->fundef, rhs->fundef))
6527 lhs_bindings = lhs->bindings;
6528 rhs_bindings = rhs->bindings;
6529 while (lhs_bindings != NULL && rhs_bindings != NULL)
6531 tree lhs_arg = TREE_VALUE (lhs_bindings);
6532 tree rhs_arg = TREE_VALUE (rhs_bindings);
6533 gcc_assert (TREE_TYPE (lhs_arg) == TREE_TYPE (rhs_arg));
6534 if (!cp_tree_equal (lhs_arg, rhs_arg))
6536 lhs_bindings = TREE_CHAIN (lhs_bindings);
6537 rhs_bindings = TREE_CHAIN (rhs_bindings);
6539 return lhs_bindings == rhs_bindings;
6542 /* Initialize the constexpr call table, if needed. */
6545 maybe_initialize_constexpr_call_table (void)
6547 if (constexpr_call_table == NULL)
6548 constexpr_call_table = htab_create_ggc (101,
6549 constexpr_call_hash,
6550 constexpr_call_equal,
6554 /* Return true if T designates the implied `this' parameter. */
6557 is_this_parameter (tree t)
6559 return t == current_class_ptr;
6562 /* We have an expression tree T that represents a call, either CALL_EXPR
6563 or AGGR_INIT_EXPR. If the call is lexically to a named function,
6564 retrun the _DECL for that function. */
6567 get_function_named_in_call (tree t)
6570 switch (TREE_CODE (t))
6573 fun = CALL_EXPR_FN (t);
6576 case AGGR_INIT_EXPR:
6577 fun = AGGR_INIT_EXPR_FN (t);
6584 if (TREE_CODE (fun) == ADDR_EXPR
6585 && TREE_CODE (TREE_OPERAND (fun, 0)) == FUNCTION_DECL)
6586 fun = TREE_OPERAND (fun, 0);
6590 /* We have an expression tree T that represents a call, either CALL_EXPR
6591 or AGGR_INIT_EXPR. Return the Nth argument. */
6594 get_nth_callarg (tree t, int n)
6596 switch (TREE_CODE (t))
6599 return CALL_EXPR_ARG (t, n);
6601 case AGGR_INIT_EXPR:
6602 return AGGR_INIT_EXPR_ARG (t, n);
6610 /* Look up the binding of the function parameter T in a constexpr
6611 function call context CALL. */
6614 lookup_parameter_binding (const constexpr_call *call, tree t)
6616 tree b = purpose_member (t, call->bindings);
6617 return TREE_VALUE (b);
6620 /* Attempt to evaluate T which represents a call to a builtin function.
6621 We assume here that all builtin functions evaluate to scalar types
6622 represented by _CST nodes. */
6625 cxx_eval_builtin_function_call (const constexpr_call *call, tree t,
6626 bool allow_non_constant, bool addr,
6627 bool *non_constant_p, bool *overflow_p)
6629 const int nargs = call_expr_nargs (t);
6630 tree *args = (tree *) alloca (nargs * sizeof (tree));
6633 for (i = 0; i < nargs; ++i)
6635 args[i] = cxx_eval_constant_expression (call, CALL_EXPR_ARG (t, i),
6636 allow_non_constant, addr,
6637 non_constant_p, overflow_p);
6638 if (allow_non_constant && *non_constant_p)
6641 if (*non_constant_p)
6643 new_call = build_call_array_loc (EXPR_LOCATION (t), TREE_TYPE (t),
6644 CALL_EXPR_FN (t), nargs, args);
6645 new_call = fold (new_call);
6646 VERIFY_CONSTANT (new_call);
6650 /* TEMP is the constant value of a temporary object of type TYPE. Adjust
6651 the type of the value to match. */
6654 adjust_temp_type (tree type, tree temp)
6656 if (TREE_TYPE (temp) == type)
6658 /* Avoid wrapping an aggregate value in a NOP_EXPR. */
6659 if (TREE_CODE (temp) == CONSTRUCTOR)
6660 return build_constructor (type, CONSTRUCTOR_ELTS (temp));
6661 gcc_assert (scalarish_type_p (type));
6662 return cp_fold_convert (type, temp);
6665 /* Subroutine of cxx_eval_call_expression.
6666 We are processing a call expression (either CALL_EXPR or
6667 AGGR_INIT_EXPR) in the call context of OLD_CALL. Evaluate
6668 all arguments and bind their values to correspondings
6669 parameters, making up the NEW_CALL context. */
6672 cxx_bind_parameters_in_call (const constexpr_call *old_call, tree t,
6673 constexpr_call *new_call,
6674 bool allow_non_constant,
6675 bool *non_constant_p, bool *overflow_p)
6677 const int nargs = call_expr_nargs (t);
6678 tree fun = new_call->fundef->decl;
6679 tree parms = DECL_ARGUMENTS (fun);
6681 for (i = 0; i < nargs; ++i)
6684 tree type = parms ? TREE_TYPE (parms) : void_type_node;
6685 /* For member function, the first argument is a pointer to the implied
6686 object. And for an object construction, don't bind `this' before
6687 it is fully constructed. */
6688 if (i == 0 && DECL_CONSTRUCTOR_P (fun))
6690 x = get_nth_callarg (t, i);
6691 if (parms && DECL_BY_REFERENCE (parms))
6693 /* cp_genericize made this a reference for argument passing, but
6694 we don't want to treat it like one for constexpr evaluation. */
6695 gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
6696 gcc_assert (TREE_CODE (TREE_TYPE (x)) == REFERENCE_TYPE);
6697 type = TREE_TYPE (type);
6698 x = convert_from_reference (x);
6700 arg = cxx_eval_constant_expression (old_call, x, allow_non_constant,
6701 TREE_CODE (type) == REFERENCE_TYPE,
6702 non_constant_p, overflow_p);
6703 /* Don't VERIFY_CONSTANT here. */
6704 if (*non_constant_p && allow_non_constant)
6706 /* Just discard ellipsis args after checking their constantitude. */
6709 if (*non_constant_p)
6710 /* Don't try to adjust the type of non-constant args. */
6713 /* Make sure the binding has the same type as the parm. */
6714 if (TREE_CODE (type) != REFERENCE_TYPE)
6715 arg = adjust_temp_type (type, arg);
6716 new_call->bindings = tree_cons (parms, arg, new_call->bindings);
6718 parms = TREE_CHAIN (parms);
6722 /* Variables and functions to manage constexpr call expansion context.
6723 These do not need to be marked for PCH or GC. */
6725 /* FIXME remember and print actual constant arguments. */
6726 static vec<tree> call_stack = vNULL;
6727 static int call_stack_tick;
6728 static int last_cx_error_tick;
6731 push_cx_call_context (tree call)
6734 if (!EXPR_HAS_LOCATION (call))
6735 SET_EXPR_LOCATION (call, input_location);
6736 call_stack.safe_push (call);
6737 if (call_stack.length () > (unsigned) max_constexpr_depth)
6743 pop_cx_call_context (void)
6750 cx_error_context (void)
6752 vec<tree> r = vNULL;
6753 if (call_stack_tick != last_cx_error_tick
6754 && !call_stack.is_empty ())
6756 last_cx_error_tick = call_stack_tick;
6760 /* Subroutine of cxx_eval_constant_expression.
6761 Evaluate the call expression tree T in the context of OLD_CALL expression
6765 cxx_eval_call_expression (const constexpr_call *old_call, tree t,
6766 bool allow_non_constant, bool addr,
6767 bool *non_constant_p, bool *overflow_p)
6769 location_t loc = EXPR_LOC_OR_HERE (t);
6770 tree fun = get_function_named_in_call (t);
6772 constexpr_call new_call = { NULL, NULL, NULL, 0 };
6773 constexpr_call **slot;
6774 constexpr_call *entry;
6777 if (TREE_CODE (fun) != FUNCTION_DECL)
6779 /* Might be a constexpr function pointer. */
6780 fun = cxx_eval_constant_expression (old_call, fun, allow_non_constant,
6781 /*addr*/false, non_constant_p, overflow_p);
6782 if (TREE_CODE (fun) == ADDR_EXPR)
6783 fun = TREE_OPERAND (fun, 0);
6785 if (TREE_CODE (fun) != FUNCTION_DECL)
6787 if (!allow_non_constant && !*non_constant_p)
6788 error_at (loc, "expression %qE does not designate a constexpr "
6790 *non_constant_p = true;
6793 if (DECL_CLONED_FUNCTION_P (fun))
6794 fun = DECL_CLONED_FUNCTION (fun);
6795 if (is_builtin_fn (fun))
6796 return cxx_eval_builtin_function_call (old_call, t, allow_non_constant,
6797 addr, non_constant_p, overflow_p);
6798 if (!DECL_DECLARED_CONSTEXPR_P (fun))
6800 if (!allow_non_constant)
6802 error_at (loc, "call to non-constexpr function %qD", fun);
6803 explain_invalid_constexpr_fn (fun);
6805 *non_constant_p = true;
6809 /* Shortcut trivial copy constructor/op=. */
6810 if (call_expr_nargs (t) == 2 && trivial_fn_p (fun))
6812 tree arg = convert_from_reference (get_nth_callarg (t, 1));
6813 return cxx_eval_constant_expression (old_call, arg, allow_non_constant,
6814 addr, non_constant_p, overflow_p);
6817 /* If in direct recursive call, optimize definition search. */
6818 if (old_call != NULL && old_call->fundef->decl == fun)
6819 new_call.fundef = old_call->fundef;
6822 new_call.fundef = retrieve_constexpr_fundef (fun);
6823 if (new_call.fundef == NULL || new_call.fundef->body == NULL)
6825 if (!allow_non_constant)
6827 if (DECL_INITIAL (fun))
6829 /* The definition of fun was somehow unsuitable. */
6830 error_at (loc, "%qD called in a constant expression", fun);
6831 explain_invalid_constexpr_fn (fun);
6834 error_at (loc, "%qD used before its definition", fun);
6836 *non_constant_p = true;
6840 cxx_bind_parameters_in_call (old_call, t, &new_call,
6841 allow_non_constant, non_constant_p, overflow_p);
6842 if (*non_constant_p)
6845 depth_ok = push_cx_call_context (t);
6848 = iterative_hash_template_arg (new_call.bindings,
6849 constexpr_fundef_hash (new_call.fundef));
6851 /* If we have seen this call before, we are done. */
6852 maybe_initialize_constexpr_call_table ();
6853 slot = (constexpr_call **)
6854 htab_find_slot (constexpr_call_table, &new_call, INSERT);
6858 /* We need to keep a pointer to the entry, not just the slot, as the
6859 slot can move in the call to cxx_eval_builtin_function_call. */
6860 *slot = entry = ggc_alloc_constexpr_call ();
6863 /* Calls which are in progress have their result set to NULL
6864 so that we can detect circular dependencies. */
6865 else if (entry->result == NULL)
6867 if (!allow_non_constant)
6868 error ("call has circular dependency");
6869 *non_constant_p = true;
6870 entry->result = result = error_mark_node;
6875 if (!allow_non_constant)
6876 error ("constexpr evaluation depth exceeds maximum of %d (use "
6877 "-fconstexpr-depth= to increase the maximum)",
6878 max_constexpr_depth);
6879 *non_constant_p = true;
6880 entry->result = result = error_mark_node;
6884 result = entry->result;
6885 if (!result || result == error_mark_node)
6886 result = (cxx_eval_constant_expression
6887 (&new_call, new_call.fundef->body,
6888 allow_non_constant, addr,
6889 non_constant_p, overflow_p));
6890 if (result == error_mark_node)
6891 *non_constant_p = true;
6892 if (*non_constant_p)
6893 entry->result = result = error_mark_node;
6896 /* If this was a call to initialize an object, set the type of
6897 the CONSTRUCTOR to the type of that object. */
6898 if (DECL_CONSTRUCTOR_P (fun))
6900 tree ob_arg = get_nth_callarg (t, 0);
6901 STRIP_NOPS (ob_arg);
6902 gcc_assert (TYPE_PTR_P (TREE_TYPE (ob_arg))
6903 && CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (ob_arg))));
6904 result = adjust_temp_type (TREE_TYPE (TREE_TYPE (ob_arg)),
6907 entry->result = result;
6911 pop_cx_call_context ();
6912 return unshare_expr (result);
6915 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
6918 reduced_constant_expression_p (tree t)
6920 if (TREE_CODE (t) == PTRMEM_CST)
6921 /* Even if we can't lower this yet, it's constant. */
6923 /* FIXME are we calling this too much? */
6924 return initializer_constant_valid_p (t, TREE_TYPE (t)) != NULL_TREE;
6927 /* Some expressions may have constant operands but are not constant
6928 themselves, such as 1/0. Call this function (or rather, the macro
6929 following it) to check for that condition.
6931 We only call this in places that require an arithmetic constant, not in
6932 places where we might have a non-constant expression that can be a
6933 component of a constant expression, such as the address of a constexpr
6934 variable that might be dereferenced later. */
6937 verify_constant (tree t, bool allow_non_constant, bool *non_constant_p,
6940 if (!*non_constant_p && !reduced_constant_expression_p (t))
6942 if (!allow_non_constant)
6943 error ("%q+E is not a constant expression", t);
6944 *non_constant_p = true;
6946 if (TREE_OVERFLOW_P (t))
6948 if (!allow_non_constant)
6950 permerror (input_location, "overflow in constant expression");
6951 /* If we're being permissive (and are in an enforcing
6952 context), ignore the overflow. */
6953 if (flag_permissive)
6954 return *non_constant_p;
6958 return *non_constant_p;
6961 /* Subroutine of cxx_eval_constant_expression.
6962 Attempt to reduce the unary expression tree T to a compile time value.
6963 If successful, return the value. Otherwise issue a diagnostic
6964 and return error_mark_node. */
6967 cxx_eval_unary_expression (const constexpr_call *call, tree t,
6968 bool allow_non_constant, bool addr,
6969 bool *non_constant_p, bool *overflow_p)
6972 tree orig_arg = TREE_OPERAND (t, 0);
6973 tree arg = cxx_eval_constant_expression (call, orig_arg, allow_non_constant,
6974 addr, non_constant_p, overflow_p);
6975 VERIFY_CONSTANT (arg);
6976 if (arg == orig_arg)
6978 r = fold_build1 (TREE_CODE (t), TREE_TYPE (t), arg);
6979 VERIFY_CONSTANT (r);
6983 /* Subroutine of cxx_eval_constant_expression.
6984 Like cxx_eval_unary_expression, except for binary expressions. */
6987 cxx_eval_binary_expression (const constexpr_call *call, tree t,
6988 bool allow_non_constant, bool addr,
6989 bool *non_constant_p, bool *overflow_p)
6992 tree orig_lhs = TREE_OPERAND (t, 0);
6993 tree orig_rhs = TREE_OPERAND (t, 1);
6995 lhs = cxx_eval_constant_expression (call, orig_lhs,
6996 allow_non_constant, addr,
6997 non_constant_p, overflow_p);
6998 VERIFY_CONSTANT (lhs);
6999 rhs = cxx_eval_constant_expression (call, orig_rhs,
7000 allow_non_constant, addr,
7001 non_constant_p, overflow_p);
7002 VERIFY_CONSTANT (rhs);
7003 if (lhs == orig_lhs && rhs == orig_rhs)
7005 r = fold_build2 (TREE_CODE (t), TREE_TYPE (t), lhs, rhs);
7006 VERIFY_CONSTANT (r);
7010 /* Subroutine of cxx_eval_constant_expression.
7011 Attempt to evaluate condition expressions. Dead branches are not
7015 cxx_eval_conditional_expression (const constexpr_call *call, tree t,
7016 bool allow_non_constant, bool addr,
7017 bool *non_constant_p, bool *overflow_p)
7019 tree val = cxx_eval_constant_expression (call, TREE_OPERAND (t, 0),
7020 allow_non_constant, addr,
7021 non_constant_p, overflow_p);
7022 VERIFY_CONSTANT (val);
7023 /* Don't VERIFY_CONSTANT the other operands. */
7024 if (integer_zerop (val))
7025 return cxx_eval_constant_expression (call, TREE_OPERAND (t, 2),
7026 allow_non_constant, addr,
7027 non_constant_p, overflow_p);
7028 return cxx_eval_constant_expression (call, TREE_OPERAND (t, 1),
7029 allow_non_constant, addr,
7030 non_constant_p, overflow_p);
7033 /* Subroutine of cxx_eval_constant_expression.
7034 Attempt to reduce a reference to an array slot. */
7037 cxx_eval_array_reference (const constexpr_call *call, tree t,
7038 bool allow_non_constant, bool addr,
7039 bool *non_constant_p, bool *overflow_p)
7041 tree oldary = TREE_OPERAND (t, 0);
7042 tree ary = cxx_eval_constant_expression (call, oldary,
7043 allow_non_constant, addr,
7044 non_constant_p, overflow_p);
7048 unsigned len, elem_nchars = 1;
7049 if (*non_constant_p)
7051 oldidx = TREE_OPERAND (t, 1);
7052 index = cxx_eval_constant_expression (call, oldidx,
7053 allow_non_constant, false,
7054 non_constant_p, overflow_p);
7055 VERIFY_CONSTANT (index);
7056 if (addr && ary == oldary && index == oldidx)
7059 return build4 (ARRAY_REF, TREE_TYPE (t), ary, index, NULL, NULL);
7060 elem_type = TREE_TYPE (TREE_TYPE (ary));
7061 if (TREE_CODE (ary) == CONSTRUCTOR)
7062 len = CONSTRUCTOR_NELTS (ary);
7063 else if (TREE_CODE (ary) == STRING_CST)
7065 elem_nchars = (TYPE_PRECISION (elem_type)
7066 / TYPE_PRECISION (char_type_node));
7067 len = (unsigned) TREE_STRING_LENGTH (ary) / elem_nchars;
7071 /* We can't do anything with other tree codes, so use
7072 VERIFY_CONSTANT to complain and fail. */
7073 VERIFY_CONSTANT (ary);
7076 if (compare_tree_int (index, len) >= 0)
7078 if (tree_int_cst_lt (index, array_type_nelts_top (TREE_TYPE (ary))))
7080 /* If it's within the array bounds but doesn't have an explicit
7081 initializer, it's value-initialized. */
7082 tree val = build_value_init (elem_type, tf_warning_or_error);
7083 return cxx_eval_constant_expression (call, val,
7084 allow_non_constant, addr,
7085 non_constant_p, overflow_p);
7088 if (!allow_non_constant)
7089 error ("array subscript out of bound");
7090 *non_constant_p = true;
7093 else if (tree_int_cst_lt (index, integer_zero_node))
7095 if (!allow_non_constant)
7096 error ("negative array subscript");
7097 *non_constant_p = true;
7100 i = tree_low_cst (index, 0);
7101 if (TREE_CODE (ary) == CONSTRUCTOR)
7102 return (*CONSTRUCTOR_ELTS (ary))[i].value;
7103 else if (elem_nchars == 1)
7104 return build_int_cst (cv_unqualified (TREE_TYPE (TREE_TYPE (ary))),
7105 TREE_STRING_POINTER (ary)[i]);
7108 tree type = cv_unqualified (TREE_TYPE (TREE_TYPE (ary)));
7109 return native_interpret_expr (type, (const unsigned char *)
7110 TREE_STRING_POINTER (ary)
7111 + i * elem_nchars, elem_nchars);
7113 /* Don't VERIFY_CONSTANT here. */
7116 /* Subroutine of cxx_eval_constant_expression.
7117 Attempt to reduce a field access of a value of class type. */
7120 cxx_eval_component_reference (const constexpr_call *call, tree t,
7121 bool allow_non_constant, bool addr,
7122 bool *non_constant_p, bool *overflow_p)
7124 unsigned HOST_WIDE_INT i;
7127 tree part = TREE_OPERAND (t, 1);
7128 tree orig_whole = TREE_OPERAND (t, 0);
7129 tree whole = cxx_eval_constant_expression (call, orig_whole,
7130 allow_non_constant, addr,
7131 non_constant_p, overflow_p);
7132 if (whole == orig_whole)
7135 return fold_build3 (COMPONENT_REF, TREE_TYPE (t),
7136 whole, part, NULL_TREE);
7137 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
7139 if (!*non_constant_p && TREE_CODE (whole) != CONSTRUCTOR)
7141 if (!allow_non_constant)
7142 error ("%qE is not a constant expression", orig_whole);
7143 *non_constant_p = true;
7145 if (DECL_MUTABLE_P (part))
7147 if (!allow_non_constant)
7148 error ("mutable %qD is not usable in a constant expression", part);
7149 *non_constant_p = true;
7151 if (*non_constant_p)
7153 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole), i, field, value)
7158 if (TREE_CODE (TREE_TYPE (whole)) == UNION_TYPE
7159 && CONSTRUCTOR_NELTS (whole) > 0)
7161 /* DR 1188 says we don't have to deal with this. */
7162 if (!allow_non_constant)
7163 error ("accessing %qD member instead of initialized %qD member in "
7164 "constant expression", part, CONSTRUCTOR_ELT (whole, 0)->index);
7165 *non_constant_p = true;
7169 /* If there's no explicit init for this field, it's value-initialized. */
7170 value = build_value_init (TREE_TYPE (t), tf_warning_or_error);
7171 return cxx_eval_constant_expression (call, value,
7172 allow_non_constant, addr,
7173 non_constant_p, overflow_p);
7176 /* Subroutine of cxx_eval_constant_expression.
7177 Attempt to reduce a field access of a value of class type that is
7178 expressed as a BIT_FIELD_REF. */
7181 cxx_eval_bit_field_ref (const constexpr_call *call, tree t,
7182 bool allow_non_constant, bool addr,
7183 bool *non_constant_p, bool *overflow_p)
7185 tree orig_whole = TREE_OPERAND (t, 0);
7186 tree retval, fldval, utype, mask;
7187 bool fld_seen = false;
7188 HOST_WIDE_INT istart, isize;
7189 tree whole = cxx_eval_constant_expression (call, orig_whole,
7190 allow_non_constant, addr,
7191 non_constant_p, overflow_p);
7192 tree start, field, value;
7193 unsigned HOST_WIDE_INT i;
7195 if (whole == orig_whole)
7197 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
7199 if (!*non_constant_p
7200 && TREE_CODE (whole) != VECTOR_CST
7201 && TREE_CODE (whole) != CONSTRUCTOR)
7203 if (!allow_non_constant)
7204 error ("%qE is not a constant expression", orig_whole);
7205 *non_constant_p = true;
7207 if (*non_constant_p)
7210 if (TREE_CODE (whole) == VECTOR_CST)
7211 return fold_ternary (BIT_FIELD_REF, TREE_TYPE (t), whole,
7212 TREE_OPERAND (t, 1), TREE_OPERAND (t, 2));
7214 start = TREE_OPERAND (t, 2);
7215 istart = tree_low_cst (start, 0);
7216 isize = tree_low_cst (TREE_OPERAND (t, 1), 0);
7217 utype = TREE_TYPE (t);
7218 if (!TYPE_UNSIGNED (utype))
7219 utype = build_nonstandard_integer_type (TYPE_PRECISION (utype), 1);
7220 retval = build_int_cst (utype, 0);
7221 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole), i, field, value)
7223 tree bitpos = bit_position (field);
7224 if (bitpos == start && DECL_SIZE (field) == TREE_OPERAND (t, 1))
7226 if (TREE_CODE (TREE_TYPE (field)) == INTEGER_TYPE
7227 && TREE_CODE (value) == INTEGER_CST
7228 && host_integerp (bitpos, 0)
7229 && host_integerp (DECL_SIZE (field), 0))
7231 HOST_WIDE_INT bit = tree_low_cst (bitpos, 0);
7232 HOST_WIDE_INT sz = tree_low_cst (DECL_SIZE (field), 0);
7233 HOST_WIDE_INT shift;
7234 if (bit >= istart && bit + sz <= istart + isize)
7236 fldval = fold_convert (utype, value);
7237 mask = build_int_cst_type (utype, -1);
7238 mask = fold_build2 (LSHIFT_EXPR, utype, mask,
7239 size_int (TYPE_PRECISION (utype) - sz));
7240 mask = fold_build2 (RSHIFT_EXPR, utype, mask,
7241 size_int (TYPE_PRECISION (utype) - sz));
7242 fldval = fold_build2 (BIT_AND_EXPR, utype, fldval, mask);
7243 shift = bit - istart;
7244 if (BYTES_BIG_ENDIAN)
7245 shift = TYPE_PRECISION (utype) - shift - sz;
7246 fldval = fold_build2 (LSHIFT_EXPR, utype, fldval,
7248 retval = fold_build2 (BIT_IOR_EXPR, utype, retval, fldval);
7254 return fold_convert (TREE_TYPE (t), retval);
7256 return error_mark_node;
7259 /* Subroutine of cxx_eval_constant_expression.
7260 Evaluate a short-circuited logical expression T in the context
7261 of a given constexpr CALL. BAILOUT_VALUE is the value for
7262 early return. CONTINUE_VALUE is used here purely for
7263 sanity check purposes. */
7266 cxx_eval_logical_expression (const constexpr_call *call, tree t,
7267 tree bailout_value, tree continue_value,
7268 bool allow_non_constant, bool addr,
7269 bool *non_constant_p, bool *overflow_p)
7272 tree lhs = cxx_eval_constant_expression (call, TREE_OPERAND (t, 0),
7273 allow_non_constant, addr,
7274 non_constant_p, overflow_p);
7275 VERIFY_CONSTANT (lhs);
7276 if (tree_int_cst_equal (lhs, bailout_value))
7278 gcc_assert (tree_int_cst_equal (lhs, continue_value));
7279 r = cxx_eval_constant_expression (call, TREE_OPERAND (t, 1),
7280 allow_non_constant, addr, non_constant_p, overflow_p);
7281 VERIFY_CONSTANT (r);
7285 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
7286 CONSTRUCTOR elements to initialize (part of) an object containing that
7287 field. Return a pointer to the constructor_elt corresponding to the
7288 initialization of the field. */
7290 static constructor_elt *
7291 base_field_constructor_elt (vec<constructor_elt, va_gc> *v, tree ref)
7293 tree aggr = TREE_OPERAND (ref, 0);
7294 tree field = TREE_OPERAND (ref, 1);
7296 constructor_elt *ce;
7298 gcc_assert (TREE_CODE (ref) == COMPONENT_REF);
7300 if (TREE_CODE (aggr) == COMPONENT_REF)
7302 constructor_elt *base_ce
7303 = base_field_constructor_elt (v, aggr);
7304 v = CONSTRUCTOR_ELTS (base_ce->value);
7307 for (i = 0; vec_safe_iterate (v, i, &ce); ++i)
7308 if (ce->index == field)
7315 /* Subroutine of cxx_eval_constant_expression.
7316 The expression tree T denotes a C-style array or a C-style
7317 aggregate. Reduce it to a constant expression. */
7320 cxx_eval_bare_aggregate (const constexpr_call *call, tree t,
7321 bool allow_non_constant, bool addr,
7322 bool *non_constant_p, bool *overflow_p)
7324 vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (t);
7325 vec<constructor_elt, va_gc> *n;
7326 vec_alloc (n, vec_safe_length (v));
7327 constructor_elt *ce;
7329 bool changed = false;
7330 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t));
7331 for (i = 0; vec_safe_iterate (v, i, &ce); ++i)
7333 tree elt = cxx_eval_constant_expression (call, ce->value,
7334 allow_non_constant, addr,
7335 non_constant_p, overflow_p);
7336 /* Don't VERIFY_CONSTANT here. */
7337 if (allow_non_constant && *non_constant_p)
7339 if (elt != ce->value)
7341 if (ce->index && TREE_CODE (ce->index) == COMPONENT_REF)
7343 /* This is an initialization of a vfield inside a base
7344 subaggregate that we already initialized; push this
7345 initialization into the previous initialization. */
7346 constructor_elt *inner = base_field_constructor_elt (n, ce->index);
7349 else if (ce->index && TREE_CODE (ce->index) == NOP_EXPR)
7351 /* This is an initializer for an empty base; now that we've
7352 checked that it's constant, we can ignore it. */
7353 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (ce->index))));
7356 CONSTRUCTOR_APPEND_ELT (n, ce->index, elt);
7358 if (*non_constant_p || !changed)
7364 t = build_constructor (TREE_TYPE (t), n);
7365 TREE_CONSTANT (t) = true;
7366 if (TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
7371 /* Subroutine of cxx_eval_constant_expression.
7372 The expression tree T is a VEC_INIT_EXPR which denotes the desired
7373 initialization of a non-static data member of array type. Reduce it to a
7376 Note that apart from value-initialization (when VALUE_INIT is true),
7377 this is only intended to support value-initialization and the
7378 initializations done by defaulted constructors for classes with
7379 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
7380 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
7381 for the copy/move constructor. */
7384 cxx_eval_vec_init_1 (const constexpr_call *call, tree atype, tree init,
7385 bool value_init, bool allow_non_constant, bool addr,
7386 bool *non_constant_p, bool *overflow_p)
7388 tree elttype = TREE_TYPE (atype);
7389 int max = tree_low_cst (array_type_nelts (atype), 0);
7390 vec<constructor_elt, va_gc> *n;
7391 vec_alloc (n, max + 1);
7392 bool pre_init = false;
7395 /* For the default constructor, build up a call to the default
7396 constructor of the element type. We only need to handle class types
7397 here, as for a constructor to be constexpr, all members must be
7398 initialized, which for a defaulted default constructor means they must
7399 be of a class type with a constexpr default constructor. */
7400 if (TREE_CODE (elttype) == ARRAY_TYPE)
7401 /* We only do this at the lowest level. */;
7402 else if (value_init)
7404 init = build_value_init (elttype, tf_warning_or_error);
7405 init = cxx_eval_constant_expression
7406 (call, init, allow_non_constant, addr, non_constant_p, overflow_p);
7411 vec<tree, va_gc> *argvec = make_tree_vector ();
7412 init = build_special_member_call (NULL_TREE, complete_ctor_identifier,
7413 &argvec, elttype, LOOKUP_NORMAL,
7414 tf_warning_or_error);
7415 release_tree_vector (argvec);
7416 init = cxx_eval_constant_expression (call, init, allow_non_constant,
7417 addr, non_constant_p, overflow_p);
7421 if (*non_constant_p && !allow_non_constant)
7424 for (i = 0; i <= max; ++i)
7426 tree idx = build_int_cst (size_type_node, i);
7428 if (TREE_CODE (elttype) == ARRAY_TYPE)
7430 /* A multidimensional array; recurse. */
7431 if (value_init || init == NULL_TREE)
7432 eltinit = NULL_TREE;
7434 eltinit = cp_build_array_ref (input_location, init, idx,
7435 tf_warning_or_error);
7436 eltinit = cxx_eval_vec_init_1 (call, elttype, eltinit, value_init,
7437 allow_non_constant, addr,
7438 non_constant_p, overflow_p);
7442 /* Initializing an element using value or default initialization
7443 we just pre-built above. */
7447 eltinit = unshare_expr (init);
7451 /* Copying an element. */
7452 vec<tree, va_gc> *argvec;
7453 gcc_assert (same_type_ignoring_top_level_qualifiers_p
7454 (atype, TREE_TYPE (init)));
7455 eltinit = cp_build_array_ref (input_location, init, idx,
7456 tf_warning_or_error);
7457 if (!real_lvalue_p (init))
7458 eltinit = move (eltinit);
7459 argvec = make_tree_vector ();
7460 argvec->quick_push (eltinit);
7461 eltinit = (build_special_member_call
7462 (NULL_TREE, complete_ctor_identifier, &argvec,
7463 elttype, LOOKUP_NORMAL, tf_warning_or_error));
7464 release_tree_vector (argvec);
7465 eltinit = cxx_eval_constant_expression
7466 (call, eltinit, allow_non_constant, addr, non_constant_p, overflow_p);
7468 if (*non_constant_p && !allow_non_constant)
7470 CONSTRUCTOR_APPEND_ELT (n, idx, eltinit);
7473 if (!*non_constant_p)
7475 init = build_constructor (atype, n);
7476 TREE_CONSTANT (init) = true;
7486 cxx_eval_vec_init (const constexpr_call *call, tree t,
7487 bool allow_non_constant, bool addr,
7488 bool *non_constant_p, bool *overflow_p)
7490 tree atype = TREE_TYPE (t);
7491 tree init = VEC_INIT_EXPR_INIT (t);
7492 tree r = cxx_eval_vec_init_1 (call, atype, init,
7493 VEC_INIT_EXPR_VALUE_INIT (t),
7494 allow_non_constant, addr, non_constant_p, overflow_p);
7495 if (*non_constant_p)
7501 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
7502 match. We want to be less strict for simple *& folding; if we have a
7503 non-const temporary that we access through a const pointer, that should
7504 work. We handle this here rather than change fold_indirect_ref_1
7505 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
7506 don't really make sense outside of constant expression evaluation. Also
7507 we want to allow folding to COMPONENT_REF, which could cause trouble
7508 with TBAA in fold_indirect_ref_1.
7510 Try to keep this function synced with fold_indirect_ref_1. */
7513 cxx_fold_indirect_ref (location_t loc, tree type, tree op0, bool *empty_base)
7519 subtype = TREE_TYPE (sub);
7520 if (!POINTER_TYPE_P (subtype))
7523 if (TREE_CODE (sub) == ADDR_EXPR)
7525 tree op = TREE_OPERAND (sub, 0);
7526 tree optype = TREE_TYPE (op);
7528 /* *&CONST_DECL -> to the value of the const decl. */
7529 if (TREE_CODE (op) == CONST_DECL)
7530 return DECL_INITIAL (op);
7531 /* *&p => p; make sure to handle *&"str"[cst] here. */
7532 if (same_type_ignoring_top_level_qualifiers_p (optype, type))
7534 tree fop = fold_read_from_constant_string (op);
7540 /* *(foo *)&fooarray => fooarray[0] */
7541 else if (TREE_CODE (optype) == ARRAY_TYPE
7542 && (same_type_ignoring_top_level_qualifiers_p
7543 (type, TREE_TYPE (optype))))
7545 tree type_domain = TYPE_DOMAIN (optype);
7546 tree min_val = size_zero_node;
7547 if (type_domain && TYPE_MIN_VALUE (type_domain))
7548 min_val = TYPE_MIN_VALUE (type_domain);
7549 return build4_loc (loc, ARRAY_REF, type, op, min_val,
7550 NULL_TREE, NULL_TREE);
7552 /* *(foo *)&complexfoo => __real__ complexfoo */
7553 else if (TREE_CODE (optype) == COMPLEX_TYPE
7554 && (same_type_ignoring_top_level_qualifiers_p
7555 (type, TREE_TYPE (optype))))
7556 return fold_build1_loc (loc, REALPART_EXPR, type, op);
7557 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
7558 else if (TREE_CODE (optype) == VECTOR_TYPE
7559 && (same_type_ignoring_top_level_qualifiers_p
7560 (type, TREE_TYPE (optype))))
7562 tree part_width = TYPE_SIZE (type);
7563 tree index = bitsize_int (0);
7564 return fold_build3_loc (loc, BIT_FIELD_REF, type, op, part_width, index);
7566 /* Also handle conversion to an empty base class, which
7567 is represented with a NOP_EXPR. */
7568 else if (is_empty_class (type)
7569 && CLASS_TYPE_P (optype)
7570 && DERIVED_FROM_P (type, optype))
7575 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
7576 else if (RECORD_OR_UNION_TYPE_P (optype))
7578 tree field = TYPE_FIELDS (optype);
7579 for (; field; field = DECL_CHAIN (field))
7580 if (TREE_CODE (field) == FIELD_DECL
7581 && integer_zerop (byte_position (field))
7582 && (same_type_ignoring_top_level_qualifiers_p
7583 (TREE_TYPE (field), type)))
7585 return fold_build3 (COMPONENT_REF, type, op, field, NULL_TREE);
7590 else if (TREE_CODE (sub) == POINTER_PLUS_EXPR
7591 && TREE_CODE (TREE_OPERAND (sub, 1)) == INTEGER_CST)
7593 tree op00 = TREE_OPERAND (sub, 0);
7594 tree op01 = TREE_OPERAND (sub, 1);
7597 if (TREE_CODE (op00) == ADDR_EXPR)
7600 op00 = TREE_OPERAND (op00, 0);
7601 op00type = TREE_TYPE (op00);
7603 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
7604 if (TREE_CODE (op00type) == VECTOR_TYPE
7605 && (same_type_ignoring_top_level_qualifiers_p
7606 (type, TREE_TYPE (op00type))))
7608 HOST_WIDE_INT offset = tree_low_cst (op01, 0);
7609 tree part_width = TYPE_SIZE (type);
7610 unsigned HOST_WIDE_INT part_widthi = tree_low_cst (part_width, 0)/BITS_PER_UNIT;
7611 unsigned HOST_WIDE_INT indexi = offset * BITS_PER_UNIT;
7612 tree index = bitsize_int (indexi);
7614 if (offset/part_widthi <= TYPE_VECTOR_SUBPARTS (op00type))
7615 return fold_build3_loc (loc,
7616 BIT_FIELD_REF, type, op00,
7620 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
7621 else if (TREE_CODE (op00type) == COMPLEX_TYPE
7622 && (same_type_ignoring_top_level_qualifiers_p
7623 (type, TREE_TYPE (op00type))))
7625 tree size = TYPE_SIZE_UNIT (type);
7626 if (tree_int_cst_equal (size, op01))
7627 return fold_build1_loc (loc, IMAGPART_EXPR, type, op00);
7629 /* ((foo *)&fooarray)[1] => fooarray[1] */
7630 else if (TREE_CODE (op00type) == ARRAY_TYPE
7631 && (same_type_ignoring_top_level_qualifiers_p
7632 (type, TREE_TYPE (op00type))))
7634 tree type_domain = TYPE_DOMAIN (op00type);
7635 tree min_val = size_zero_node;
7636 if (type_domain && TYPE_MIN_VALUE (type_domain))
7637 min_val = TYPE_MIN_VALUE (type_domain);
7638 op01 = size_binop_loc (loc, EXACT_DIV_EXPR, op01,
7639 TYPE_SIZE_UNIT (type));
7640 op01 = size_binop_loc (loc, PLUS_EXPR, op01, min_val);
7641 return build4_loc (loc, ARRAY_REF, type, op00, op01,
7642 NULL_TREE, NULL_TREE);
7644 /* Also handle conversion to an empty base class, which
7645 is represented with a NOP_EXPR. */
7646 else if (is_empty_class (type)
7647 && CLASS_TYPE_P (op00type)
7648 && DERIVED_FROM_P (type, op00type))
7653 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
7654 else if (RECORD_OR_UNION_TYPE_P (op00type))
7656 tree field = TYPE_FIELDS (op00type);
7657 for (; field; field = DECL_CHAIN (field))
7658 if (TREE_CODE (field) == FIELD_DECL
7659 && tree_int_cst_equal (byte_position (field), op01)
7660 && (same_type_ignoring_top_level_qualifiers_p
7661 (TREE_TYPE (field), type)))
7663 return fold_build3 (COMPONENT_REF, type, op00,
7670 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
7671 else if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE
7672 && (same_type_ignoring_top_level_qualifiers_p
7673 (type, TREE_TYPE (TREE_TYPE (subtype)))))
7676 tree min_val = size_zero_node;
7677 tree newsub = cxx_fold_indirect_ref (loc, TREE_TYPE (subtype), sub, NULL);
7681 sub = build1_loc (loc, INDIRECT_REF, TREE_TYPE (subtype), sub);
7682 type_domain = TYPE_DOMAIN (TREE_TYPE (sub));
7683 if (type_domain && TYPE_MIN_VALUE (type_domain))
7684 min_val = TYPE_MIN_VALUE (type_domain);
7685 return build4_loc (loc, ARRAY_REF, type, sub, min_val, NULL_TREE,
7693 cxx_eval_indirect_ref (const constexpr_call *call, tree t,
7694 bool allow_non_constant, bool addr,
7695 bool *non_constant_p, bool *overflow_p)
7697 tree orig_op0 = TREE_OPERAND (t, 0);
7698 tree op0 = cxx_eval_constant_expression (call, orig_op0, allow_non_constant,
7699 /*addr*/false, non_constant_p, overflow_p);
7700 bool empty_base = false;
7703 /* Don't VERIFY_CONSTANT here. */
7704 if (*non_constant_p)
7707 r = cxx_fold_indirect_ref (EXPR_LOCATION (t), TREE_TYPE (t), op0,
7711 r = cxx_eval_constant_expression (call, r, allow_non_constant,
7712 addr, non_constant_p, overflow_p);
7717 if (TREE_CODE (sub) == ADDR_EXPR)
7719 /* We couldn't fold to a constant value. Make sure it's not
7720 something we should have been able to fold. */
7721 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
7722 (TREE_TYPE (TREE_TYPE (sub)), TREE_TYPE (t)));
7723 /* DR 1188 says we don't have to deal with this. */
7724 if (!allow_non_constant)
7725 error ("accessing value of %qE through a %qT glvalue in a "
7726 "constant expression", build_fold_indirect_ref (sub),
7728 *non_constant_p = true;
7733 /* If we're pulling out the value of an empty base, make sure
7734 that the whole object is constant and then return an empty
7738 VERIFY_CONSTANT (r);
7739 r = build_constructor (TREE_TYPE (t), NULL);
7740 TREE_CONSTANT (r) = true;
7745 if (addr && op0 != orig_op0)
7746 return build1 (INDIRECT_REF, TREE_TYPE (t), op0);
7748 VERIFY_CONSTANT (t);
7754 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
7755 Shared between potential_constant_expression and
7756 cxx_eval_constant_expression. */
7759 non_const_var_error (tree r)
7761 tree type = TREE_TYPE (r);
7762 error ("the value of %qD is not usable in a constant "
7764 /* Avoid error cascade. */
7765 if (DECL_INITIAL (r) == error_mark_node)
7767 if (DECL_DECLARED_CONSTEXPR_P (r))
7768 inform (DECL_SOURCE_LOCATION (r),
7769 "%qD used in its own initializer", r);
7770 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type))
7772 if (!CP_TYPE_CONST_P (type))
7773 inform (DECL_SOURCE_LOCATION (r),
7774 "%q#D is not const", r);
7775 else if (CP_TYPE_VOLATILE_P (type))
7776 inform (DECL_SOURCE_LOCATION (r),
7777 "%q#D is volatile", r);
7778 else if (!DECL_INITIAL (r)
7779 || !TREE_CONSTANT (DECL_INITIAL (r)))
7780 inform (DECL_SOURCE_LOCATION (r),
7781 "%qD was not initialized with a constant "
7788 if (cxx_dialect >= cxx11 && !DECL_DECLARED_CONSTEXPR_P (r))
7789 inform (DECL_SOURCE_LOCATION (r),
7790 "%qD was not declared %<constexpr%>", r);
7792 inform (DECL_SOURCE_LOCATION (r),
7793 "%qD does not have integral or enumeration type",
7798 /* Subroutine of cxx_eval_constant_expression.
7799 Like cxx_eval_unary_expression, except for trinary expressions. */
7802 cxx_eval_trinary_expression (const constexpr_call *call, tree t,
7803 bool allow_non_constant, bool addr,
7804 bool *non_constant_p, bool *overflow_p)
7810 for (i = 0; i < 3; i++)
7812 args[i] = cxx_eval_constant_expression (call, TREE_OPERAND (t, i),
7813 allow_non_constant, addr,
7814 non_constant_p, overflow_p);
7815 VERIFY_CONSTANT (args[i]);
7818 val = fold_ternary_loc (EXPR_LOCATION (t), TREE_CODE (t), TREE_TYPE (t),
7819 args[0], args[1], args[2]);
7820 if (val == NULL_TREE)
7822 VERIFY_CONSTANT (val);
7826 /* Attempt to reduce the expression T to a constant value.
7827 On failure, issue diagnostic and return error_mark_node. */
7828 /* FIXME unify with c_fully_fold */
7831 cxx_eval_constant_expression (const constexpr_call *call, tree t,
7832 bool allow_non_constant, bool addr,
7833 bool *non_constant_p, bool *overflow_p)
7837 if (t == error_mark_node)
7839 *non_constant_p = true;
7842 if (CONSTANT_CLASS_P (t))
7844 if (TREE_CODE (t) == PTRMEM_CST)
7845 t = cplus_expand_constant (t);
7846 else if (TREE_OVERFLOW (t) && (!flag_permissive || allow_non_constant))
7850 if (TREE_CODE (t) != NOP_EXPR
7851 && reduced_constant_expression_p (t))
7854 switch (TREE_CODE (t))
7859 /* else fall through. */
7861 r = integral_constant_value (t);
7862 if (TREE_CODE (r) == TARGET_EXPR
7863 && TREE_CODE (TARGET_EXPR_INITIAL (r)) == CONSTRUCTOR)
7864 r = TARGET_EXPR_INITIAL (r);
7867 if (!allow_non_constant)
7868 non_const_var_error (r);
7869 *non_constant_p = true;
7879 if (call && DECL_CONTEXT (t) == call->fundef->decl)
7881 if (DECL_ARTIFICIAL (t) && DECL_CONSTRUCTOR_P (DECL_CONTEXT (t)))
7883 if (!allow_non_constant)
7884 sorry ("use of the value of the object being constructed "
7885 "in a constant expression");
7886 *non_constant_p = true;
7889 r = lookup_parameter_binding (call, t);
7892 /* Defer in case this is only used for its type. */;
7895 if (!allow_non_constant)
7896 error ("%qE is not a constant expression", t);
7897 *non_constant_p = true;
7902 case AGGR_INIT_EXPR:
7903 r = cxx_eval_call_expression (call, t, allow_non_constant, addr,
7904 non_constant_p, overflow_p);
7908 if (!literal_type_p (TREE_TYPE (t)))
7910 if (!allow_non_constant)
7912 error ("temporary of non-literal type %qT in a "
7913 "constant expression", TREE_TYPE (t));
7914 explain_non_literal_class (TREE_TYPE (t));
7916 *non_constant_p = true;
7919 /* else fall through. */
7921 /* Pass false for 'addr' because these codes indicate
7922 initialization of a temporary. */
7923 r = cxx_eval_constant_expression (call, TREE_OPERAND (t, 1),
7924 allow_non_constant, false,
7925 non_constant_p, overflow_p);
7926 if (!*non_constant_p)
7927 /* Adjust the type of the result to the type of the temporary. */
7928 r = adjust_temp_type (TREE_TYPE (t), r);
7932 r = cxx_eval_constant_expression (call, TREE_OPERAND (t, 1),
7933 allow_non_constant, addr,
7934 non_constant_p, overflow_p);
7938 case NON_LVALUE_EXPR:
7939 case TRY_CATCH_EXPR:
7940 case CLEANUP_POINT_EXPR:
7941 case MUST_NOT_THROW_EXPR:
7943 r = cxx_eval_constant_expression (call, TREE_OPERAND (t, 0),
7944 allow_non_constant, addr,
7945 non_constant_p, overflow_p);
7948 /* These differ from cxx_eval_unary_expression in that this doesn't
7949 check for a constant operand or result; an address can be
7950 constant without its operand being, and vice versa. */
7952 r = cxx_eval_indirect_ref (call, t, allow_non_constant, addr,
7953 non_constant_p, overflow_p);
7958 tree oldop = TREE_OPERAND (t, 0);
7959 tree op = cxx_eval_constant_expression (call, oldop,
7962 non_constant_p, overflow_p);
7963 /* Don't VERIFY_CONSTANT here. */
7964 if (*non_constant_p)
7966 /* This function does more aggressive folding than fold itself. */
7967 r = build_fold_addr_expr_with_type (op, TREE_TYPE (t));
7968 if (TREE_CODE (r) == ADDR_EXPR && TREE_OPERAND (r, 0) == oldop)
7976 case FIX_TRUNC_EXPR:
7981 case TRUTH_NOT_EXPR:
7982 case FIXED_CONVERT_EXPR:
7983 r = cxx_eval_unary_expression (call, t, allow_non_constant, addr,
7984 non_constant_p, overflow_p);
7988 if (SIZEOF_EXPR_TYPE_P (t))
7989 r = cxx_sizeof_or_alignof_type (TREE_TYPE (TREE_OPERAND (t, 0)),
7990 SIZEOF_EXPR, false);
7991 else if (TYPE_P (TREE_OPERAND (t, 0)))
7992 r = cxx_sizeof_or_alignof_type (TREE_OPERAND (t, 0), SIZEOF_EXPR,
7995 r = cxx_sizeof_or_alignof_expr (TREE_OPERAND (t, 0), SIZEOF_EXPR,
7997 if (r == error_mark_node)
7999 VERIFY_CONSTANT (r);
8004 /* check_return_expr sometimes wraps a TARGET_EXPR in a
8005 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
8006 introduced by build_call_a. */
8007 tree op0 = TREE_OPERAND (t, 0);
8008 tree op1 = TREE_OPERAND (t, 1);
8010 if ((TREE_CODE (op0) == TARGET_EXPR && op1 == TARGET_EXPR_SLOT (op0))
8011 || TREE_CODE (op1) == EMPTY_CLASS_EXPR)
8012 r = cxx_eval_constant_expression (call, op0, allow_non_constant,
8013 addr, non_constant_p, overflow_p);
8016 /* Check that the LHS is constant and then discard it. */
8017 cxx_eval_constant_expression (call, op0, allow_non_constant,
8018 false, non_constant_p, overflow_p);
8019 op1 = TREE_OPERAND (t, 1);
8020 r = cxx_eval_constant_expression (call, op1, allow_non_constant,
8021 addr, non_constant_p, overflow_p);
8026 case POINTER_PLUS_EXPR:
8030 case TRUNC_DIV_EXPR:
8032 case FLOOR_DIV_EXPR:
8033 case ROUND_DIV_EXPR:
8034 case TRUNC_MOD_EXPR:
8036 case ROUND_MOD_EXPR:
8038 case EXACT_DIV_EXPR:
8048 case TRUTH_XOR_EXPR:
8055 case UNORDERED_EXPR:
8065 r = cxx_eval_binary_expression (call, t, allow_non_constant, addr,
8066 non_constant_p, overflow_p);
8069 /* fold can introduce non-IF versions of these; still treat them as
8070 short-circuiting. */
8071 case TRUTH_AND_EXPR:
8072 case TRUTH_ANDIF_EXPR:
8073 r = cxx_eval_logical_expression (call, t, boolean_false_node,
8075 allow_non_constant, addr,
8076 non_constant_p, overflow_p);
8080 case TRUTH_ORIF_EXPR:
8081 r = cxx_eval_logical_expression (call, t, boolean_true_node,
8083 allow_non_constant, addr,
8084 non_constant_p, overflow_p);
8088 r = cxx_eval_array_reference (call, t, allow_non_constant, addr,
8089 non_constant_p, overflow_p);
8093 r = cxx_eval_component_reference (call, t, allow_non_constant, addr,
8094 non_constant_p, overflow_p);
8098 r = cxx_eval_bit_field_ref (call, t, allow_non_constant, addr,
8099 non_constant_p, overflow_p);
8104 r = cxx_eval_conditional_expression (call, t, allow_non_constant, addr,
8105 non_constant_p, overflow_p);
8109 r = cxx_eval_bare_aggregate (call, t, allow_non_constant, addr,
8110 non_constant_p, overflow_p);
8114 /* We can get this in a defaulted constructor for a class with a
8115 non-static data member of array type. Either the initializer will
8116 be NULL, meaning default-initialization, or it will be an lvalue
8117 or xvalue of the same type, meaning direct-initialization from the
8118 corresponding member. */
8119 r = cxx_eval_vec_init (call, t, allow_non_constant, addr,
8120 non_constant_p, overflow_p);
8125 r = cxx_eval_trinary_expression (call, t, allow_non_constant, addr,
8126 non_constant_p, overflow_p);
8130 case VIEW_CONVERT_EXPR:
8133 tree oldop = TREE_OPERAND (t, 0);
8134 tree op = cxx_eval_constant_expression (call, oldop,
8135 allow_non_constant, addr,
8136 non_constant_p, overflow_p);
8137 if (*non_constant_p)
8139 if (POINTER_TYPE_P (TREE_TYPE (t))
8140 && TREE_CODE (op) == INTEGER_CST
8141 && !integer_zerop (op))
8143 if (!allow_non_constant)
8144 error_at (EXPR_LOC_OR_HERE (t),
8145 "reinterpret_cast from integer to pointer");
8146 *non_constant_p = true;
8150 /* We didn't fold at the top so we could check for ptr-int
8153 r = fold_build1 (TREE_CODE (t), TREE_TYPE (t), op);
8154 /* Conversion of an out-of-range value has implementation-defined
8155 behavior; the language considers it different from arithmetic
8156 overflow, which is undefined. */
8157 if (TREE_OVERFLOW_P (r) && !TREE_OVERFLOW_P (op))
8158 TREE_OVERFLOW (r) = false;
8162 case EMPTY_CLASS_EXPR:
8163 /* This is good enough for a function argument that might not get
8164 used, and they can't do anything with it, so just return it. */
8168 case PREINCREMENT_EXPR:
8169 case POSTINCREMENT_EXPR:
8170 case PREDECREMENT_EXPR:
8171 case POSTDECREMENT_EXPR:
8175 case VEC_DELETE_EXPR:
8179 /* GCC internal stuff. */
8182 case WITH_CLEANUP_EXPR:
8183 case STATEMENT_LIST:
8185 case NON_DEPENDENT_EXPR:
8189 if (!allow_non_constant)
8190 error_at (EXPR_LOC_OR_HERE (t),
8191 "expression %qE is not a constant-expression", t);
8192 *non_constant_p = true;
8196 internal_error ("unexpected expression %qE of kind %s", t,
8197 tree_code_name[TREE_CODE (t)]);
8198 *non_constant_p = true;
8202 if (r == error_mark_node)
8203 *non_constant_p = true;
8205 if (*non_constant_p)
8212 cxx_eval_outermost_constant_expr (tree t, bool allow_non_constant)
8214 bool non_constant_p = false;
8215 bool overflow_p = false;
8216 tree r = cxx_eval_constant_expression (NULL, t, allow_non_constant,
8217 false, &non_constant_p, &overflow_p);
8219 verify_constant (r, allow_non_constant, &non_constant_p, &overflow_p);
8221 if (TREE_CODE (t) != CONSTRUCTOR
8222 && cp_has_mutable_p (TREE_TYPE (t)))
8224 /* We allow a mutable type if the original expression was a
8225 CONSTRUCTOR so that we can do aggregate initialization of
8226 constexpr variables. */
8227 if (!allow_non_constant)
8228 error ("%qT cannot be the type of a complete constant expression "
8229 "because it has mutable sub-objects", TREE_TYPE (t));
8230 non_constant_p = true;
8233 /* Technically we should check this for all subexpressions, but that
8234 runs into problems with our internal representation of pointer
8235 subtraction and the 5.19 rules are still in flux. */
8236 if (CONVERT_EXPR_CODE_P (TREE_CODE (r))
8237 && ARITHMETIC_TYPE_P (TREE_TYPE (r))
8238 && TREE_CODE (TREE_OPERAND (r, 0)) == ADDR_EXPR)
8240 if (!allow_non_constant)
8241 error ("conversion from pointer type %qT "
8242 "to arithmetic type %qT in a constant-expression",
8243 TREE_TYPE (TREE_OPERAND (r, 0)), TREE_TYPE (r));
8244 non_constant_p = true;
8247 if (!non_constant_p && overflow_p)
8248 non_constant_p = true;
8250 if (non_constant_p && !allow_non_constant)
8251 return error_mark_node;
8252 else if (non_constant_p && TREE_CONSTANT (r))
8254 /* This isn't actually constant, so unset TREE_CONSTANT. */
8257 else if (TREE_CODE (r) == CONSTRUCTOR)
8258 r = build1 (VIEW_CONVERT_EXPR, TREE_TYPE (r), r);
8260 r = build_nop (TREE_TYPE (r), r);
8261 TREE_CONSTANT (r) = false;
8263 else if (non_constant_p || r == t)
8266 if (TREE_CODE (r) == CONSTRUCTOR && CLASS_TYPE_P (TREE_TYPE (r)))
8268 if (TREE_CODE (t) == TARGET_EXPR
8269 && TARGET_EXPR_INITIAL (t) == r)
8273 r = get_target_expr (r);
8274 TREE_CONSTANT (r) = true;
8282 /* Returns true if T is a valid subexpression of a constant expression,
8283 even if it isn't itself a constant expression. */
8286 is_sub_constant_expr (tree t)
8288 bool non_constant_p = false;
8289 bool overflow_p = false;
8290 cxx_eval_constant_expression (NULL, t, true, false, &non_constant_p,
8292 return !non_constant_p && !overflow_p;
8295 /* If T represents a constant expression returns its reduced value.
8296 Otherwise return error_mark_node. If T is dependent, then
8300 cxx_constant_value (tree t)
8302 return cxx_eval_outermost_constant_expr (t, false);
8305 /* If T is a constant expression, returns its reduced value.
8306 Otherwise, if T does not have TREE_CONSTANT set, returns T.
8307 Otherwise, returns a version of T without TREE_CONSTANT. */
8310 maybe_constant_value (tree t)
8314 if (instantiation_dependent_expression_p (t)
8315 || type_unknown_p (t)
8316 || BRACE_ENCLOSED_INITIALIZER_P (t)
8317 || !potential_constant_expression (t))
8319 if (TREE_OVERFLOW_P (t))
8321 t = build_nop (TREE_TYPE (t), t);
8322 TREE_CONSTANT (t) = false;
8327 r = cxx_eval_outermost_constant_expr (t, true);
8328 #ifdef ENABLE_CHECKING
8329 /* cp_tree_equal looks through NOPs, so allow them. */
8331 || CONVERT_EXPR_P (t)
8332 || (TREE_CONSTANT (t) && !TREE_CONSTANT (r))
8333 || !cp_tree_equal (r, t));
8338 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
8339 than wrapped in a TARGET_EXPR. */
8342 maybe_constant_init (tree t)
8344 t = maybe_constant_value (t);
8345 if (TREE_CODE (t) == TARGET_EXPR)
8347 tree init = TARGET_EXPR_INITIAL (t);
8348 if (TREE_CODE (init) == CONSTRUCTOR)
8355 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
8356 /* Return true if the object referred to by REF has automatic or thread
8359 enum { ck_ok, ck_bad, ck_unknown };
8361 check_automatic_or_tls (tree ref)
8363 enum machine_mode mode;
8364 HOST_WIDE_INT bitsize, bitpos;
8366 int volatilep = 0, unsignedp = 0;
8367 tree decl = get_inner_reference (ref, &bitsize, &bitpos, &offset,
8368 &mode, &unsignedp, &volatilep, false);
8371 /* If there isn't a decl in the middle, we don't know the linkage here,
8372 and this isn't a constant expression anyway. */
8375 dk = decl_storage_duration (decl);
8376 return (dk == dk_auto || dk == dk_thread) ? ck_bad : ck_ok;
8380 /* Return true if T denotes a potentially constant expression. Issue
8381 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
8382 an lvalue-rvalue conversion is implied.
8384 C++0x [expr.const] used to say
8386 6 An expression is a potential constant expression if it is
8387 a constant expression where all occurrences of function
8388 parameters are replaced by arbitrary constant expressions
8389 of the appropriate type.
8391 2 A conditional expression is a constant expression unless it
8392 involves one of the following as a potentially evaluated
8393 subexpression (3.2), but subexpressions of logical AND (5.14),
8394 logical OR (5.15), and conditional (5.16) operations that are
8395 not evaluated are not considered. */
8398 potential_constant_expression_1 (tree t, bool want_rval, tsubst_flags_t flags)
8400 enum { any = false, rval = true };
8404 if (t == error_mark_node)
8408 if (TREE_THIS_VOLATILE (t))
8410 if (flags & tf_error)
8411 error ("expression %qE has side-effects", t);
8414 if (CONSTANT_CLASS_P (t))
8417 switch (TREE_CODE (t))
8423 case TEMPLATE_ID_EXPR:
8430 case TEMPLATE_PARM_INDEX:
8432 case IDENTIFIER_NODE:
8433 case USERDEF_LITERAL:
8434 /* We can see a FIELD_DECL in a pointer-to-member expression. */
8440 case AGGR_INIT_EXPR:
8442 /* -- an invocation of a function other than a constexpr function
8443 or a constexpr constructor. */
8445 tree fun = get_function_named_in_call (t);
8446 const int nargs = call_expr_nargs (t);
8449 if (is_overloaded_fn (fun))
8451 if (TREE_CODE (fun) == FUNCTION_DECL)
8453 if (builtin_valid_in_constant_expr_p (fun))
8455 if (!DECL_DECLARED_CONSTEXPR_P (fun)
8456 /* Allow any built-in function; if the expansion
8457 isn't constant, we'll deal with that then. */
8458 && !is_builtin_fn (fun))
8460 if (flags & tf_error)
8462 error_at (EXPR_LOC_OR_HERE (t),
8463 "call to non-constexpr function %qD", fun);
8464 explain_invalid_constexpr_fn (fun);
8468 /* A call to a non-static member function takes the address
8469 of the object as the first argument. But in a constant
8470 expression the address will be folded away, so look
8472 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun)
8473 && !DECL_CONSTRUCTOR_P (fun))
8475 tree x = get_nth_callarg (t, 0);
8476 if (is_this_parameter (x))
8478 if (DECL_CONTEXT (x) == NULL_TREE
8479 || DECL_CONSTRUCTOR_P (DECL_CONTEXT (x)))
8481 if (flags & tf_error)
8482 sorry ("calling a member function of the "
8483 "object being constructed in a constant "
8487 /* Otherwise OK. */;
8489 else if (!potential_constant_expression_1 (x, rval, flags))
8496 if (!potential_constant_expression_1 (fun, true, flags))
8498 fun = get_first_fn (fun);
8500 /* Skip initial arguments to base constructors. */
8501 if (DECL_BASE_CONSTRUCTOR_P (fun))
8502 i = num_artificial_parms_for (fun);
8503 fun = DECL_ORIGIN (fun);
8507 if (potential_constant_expression_1 (fun, rval, flags))
8508 /* Might end up being a constant function pointer. */;
8512 for (; i < nargs; ++i)
8514 tree x = get_nth_callarg (t, i);
8515 if (!potential_constant_expression_1 (x, rval, flags))
8521 case NON_LVALUE_EXPR:
8522 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
8523 -- an lvalue of integral type that refers to a non-volatile
8524 const variable or static data member initialized with
8525 constant expressions, or
8527 -- an lvalue of literal type that refers to non-volatile
8528 object defined with constexpr, or that refers to a
8529 sub-object of such an object; */
8530 return potential_constant_expression_1 (TREE_OPERAND (t, 0), rval, flags);
8533 if (want_rval && !decl_constant_var_p (t)
8534 && !dependent_type_p (TREE_TYPE (t)))
8536 if (flags & tf_error)
8537 non_const_var_error (t);
8544 case VIEW_CONVERT_EXPR:
8545 /* -- a reinterpret_cast. FIXME not implemented, and this rule
8546 may change to something more specific to type-punning (DR 1312). */
8548 tree from = TREE_OPERAND (t, 0);
8549 if (POINTER_TYPE_P (TREE_TYPE (t))
8550 && TREE_CODE (from) == INTEGER_CST
8551 && !integer_zerop (from))
8553 if (flags & tf_error)
8554 error_at (EXPR_LOC_OR_HERE (t),
8555 "reinterpret_cast from integer to pointer");
8558 return (potential_constant_expression_1
8559 (from, TREE_CODE (t) != VIEW_CONVERT_EXPR, flags));
8563 /* -- a unary operator & that is applied to an lvalue that
8564 designates an object with thread or automatic storage
8566 t = TREE_OPERAND (t, 0);
8568 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
8569 any checking here, as we might dereference the pointer later. If
8570 we remove this code, also remove check_automatic_or_tls. */
8571 i = check_automatic_or_tls (t);
8576 if (flags & tf_error)
8577 error ("address-of an object %qE with thread local or "
8578 "automatic storage is not a constant expression", t);
8582 return potential_constant_expression_1 (t, any, flags);
8588 /* -- a class member access unless its postfix-expression is
8589 of literal type or of pointer to literal type. */
8590 /* This test would be redundant, as it follows from the
8591 postfix-expression being a potential constant expression. */
8592 return potential_constant_expression_1 (TREE_OPERAND (t, 0),
8595 case EXPR_PACK_EXPANSION:
8596 return potential_constant_expression_1 (PACK_EXPANSION_PATTERN (t),
8601 tree x = TREE_OPERAND (t, 0);
8603 if (is_this_parameter (x))
8605 if (DECL_CONTEXT (x)
8606 && !DECL_DECLARED_CONSTEXPR_P (DECL_CONTEXT (x)))
8608 if (flags & tf_error)
8609 error ("use of %<this%> in a constant expression");
8612 if (want_rval && DECL_CONTEXT (x)
8613 && DECL_CONSTRUCTOR_P (DECL_CONTEXT (x)))
8615 if (flags & tf_error)
8616 sorry ("use of the value of the object being constructed "
8617 "in a constant expression");
8622 return potential_constant_expression_1 (x, rval, flags);
8626 case DYNAMIC_CAST_EXPR:
8627 case PSEUDO_DTOR_EXPR:
8628 case PREINCREMENT_EXPR:
8629 case POSTINCREMENT_EXPR:
8630 case PREDECREMENT_EXPR:
8631 case POSTDECREMENT_EXPR:
8635 case VEC_DELETE_EXPR:
8640 case OMP_ATOMIC_READ:
8641 case OMP_ATOMIC_CAPTURE_OLD:
8642 case OMP_ATOMIC_CAPTURE_NEW:
8643 /* GCC internal stuff. */
8646 case WITH_CLEANUP_EXPR:
8647 case CLEANUP_POINT_EXPR:
8648 case MUST_NOT_THROW_EXPR:
8649 case TRY_CATCH_EXPR:
8650 case STATEMENT_LIST:
8651 /* Don't bother trying to define a subset of statement-expressions to
8652 be constant-expressions, at least for now. */
8656 case TRANSACTION_EXPR:
8661 if (flags & tf_error)
8662 error ("expression %qE is not a constant-expression", t);
8666 /* -- a typeid expression whose operand is of polymorphic
8669 tree e = TREE_OPERAND (t, 0);
8670 if (!TYPE_P (e) && !type_dependent_expression_p (e)
8671 && TYPE_POLYMORPHIC_P (TREE_TYPE (e)))
8673 if (flags & tf_error)
8674 error ("typeid-expression is not a constant expression "
8675 "because %qE is of polymorphic type", e);
8682 /* -- a subtraction where both operands are pointers. */
8683 if (TYPE_PTR_P (TREE_OPERAND (t, 0))
8684 && TYPE_PTR_P (TREE_OPERAND (t, 1)))
8686 if (flags & tf_error)
8687 error ("difference of two pointer expressions is not "
8688 "a constant expression");
8700 /* -- a relational or equality operator where at least
8701 one of the operands is a pointer. */
8702 if (TYPE_PTR_P (TREE_OPERAND (t, 0))
8703 || TYPE_PTR_P (TREE_OPERAND (t, 1)))
8705 if (flags & tf_error)
8706 error ("pointer comparison expression is not a "
8707 "constant expression");
8715 if (TYPE_P (TREE_OPERAND (t, 0)))
8717 /* else fall through. */
8723 case FIX_TRUNC_EXPR:
8727 case TRUTH_NOT_EXPR:
8728 case FIXED_CONVERT_EXPR:
8729 case UNARY_PLUS_EXPR:
8730 return potential_constant_expression_1 (TREE_OPERAND (t, 0), rval,
8734 case CONST_CAST_EXPR:
8735 case STATIC_CAST_EXPR:
8736 case REINTERPRET_CAST_EXPR:
8737 case IMPLICIT_CONV_EXPR:
8738 if (cxx_dialect < cxx11
8739 && !dependent_type_p (TREE_TYPE (t))
8740 && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t)))
8741 /* In C++98, a conversion to non-integral type can't be part of a
8742 constant expression. */
8744 if (flags & tf_error)
8745 error ("cast to non-integral type %qT in a constant expression",
8750 return (potential_constant_expression_1
8751 (TREE_OPERAND (t, 0),
8752 TREE_CODE (TREE_TYPE (t)) != REFERENCE_TYPE, flags));
8755 case NON_DEPENDENT_EXPR:
8756 /* For convenience. */
8758 return potential_constant_expression_1 (TREE_OPERAND (t, 0),
8762 return potential_constant_expression_1 (TREE_OPERAND (t, 1),
8766 if (!literal_type_p (TREE_TYPE (t)))
8768 if (flags & tf_error)
8770 error ("temporary of non-literal type %qT in a "
8771 "constant expression", TREE_TYPE (t));
8772 explain_non_literal_class (TREE_TYPE (t));
8777 return potential_constant_expression_1 (TREE_OPERAND (t, 1),
8782 vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (t);
8783 constructor_elt *ce;
8784 for (i = 0; vec_safe_iterate (v, i, &ce); ++i)
8785 if (!potential_constant_expression_1 (ce->value, want_rval, flags))
8792 gcc_assert (TREE_PURPOSE (t) == NULL_TREE
8793 || DECL_P (TREE_PURPOSE (t)));
8794 if (!potential_constant_expression_1 (TREE_VALUE (t), want_rval,
8797 if (TREE_CHAIN (t) == NULL_TREE)
8799 return potential_constant_expression_1 (TREE_CHAIN (t), want_rval,
8803 case TRUNC_DIV_EXPR:
8805 case FLOOR_DIV_EXPR:
8806 case ROUND_DIV_EXPR:
8807 case TRUNC_MOD_EXPR:
8809 case ROUND_MOD_EXPR:
8811 tree denom = TREE_OPERAND (t, 1);
8812 if (!potential_constant_expression_1 (denom, rval, flags))
8814 /* We can't call cxx_eval_outermost_constant_expr on an expression
8815 that hasn't been through fold_non_dependent_expr yet. */
8816 if (!processing_template_decl)
8817 denom = cxx_eval_outermost_constant_expr (denom, true);
8818 if (integer_zerop (denom))
8820 if (flags & tf_error)
8821 error ("division by zero is not a constant-expression");
8827 return potential_constant_expression_1 (TREE_OPERAND (t, 0),
8834 /* check_return_expr sometimes wraps a TARGET_EXPR in a
8835 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
8836 introduced by build_call_a. */
8837 tree op0 = TREE_OPERAND (t, 0);
8838 tree op1 = TREE_OPERAND (t, 1);
8840 if ((TREE_CODE (op0) == TARGET_EXPR && op1 == TARGET_EXPR_SLOT (op0))
8841 || TREE_CODE (op1) == EMPTY_CLASS_EXPR)
8842 return potential_constant_expression_1 (op0, want_rval, flags);
8847 /* If the first operand is the non-short-circuit constant, look at
8848 the second operand; otherwise we only care about the first one for
8850 case TRUTH_AND_EXPR:
8851 case TRUTH_ANDIF_EXPR:
8852 tmp = boolean_true_node;
8855 case TRUTH_ORIF_EXPR:
8856 tmp = boolean_false_node;
8859 tree op = TREE_OPERAND (t, 0);
8860 if (!potential_constant_expression_1 (op, rval, flags))
8862 if (!processing_template_decl)
8863 op = cxx_eval_outermost_constant_expr (op, true);
8864 if (tree_int_cst_equal (op, tmp))
8865 return potential_constant_expression_1 (TREE_OPERAND (t, 1), rval, flags);
8872 case POINTER_PLUS_EXPR:
8874 case EXACT_DIV_EXPR:
8884 case TRUTH_XOR_EXPR:
8885 case UNORDERED_EXPR:
8898 case ARRAY_RANGE_REF:
8902 for (i = 0; i < 2; ++i)
8903 if (!potential_constant_expression_1 (TREE_OPERAND (t, i),
8908 case ARRAY_NOTATION_REF:
8913 for (i = 0; i < 3; ++i)
8914 if (!potential_constant_expression_1 (TREE_OPERAND (t, i),
8921 /* If the condition is a known constant, we know which of the legs we
8922 care about; otherwise we only require that the condition and
8923 either of the legs be potentially constant. */
8924 tmp = TREE_OPERAND (t, 0);
8925 if (!potential_constant_expression_1 (tmp, rval, flags))
8927 if (!processing_template_decl)
8928 tmp = cxx_eval_outermost_constant_expr (tmp, true);
8929 if (integer_zerop (tmp))
8930 return potential_constant_expression_1 (TREE_OPERAND (t, 2),
8932 else if (TREE_CODE (tmp) == INTEGER_CST)
8933 return potential_constant_expression_1 (TREE_OPERAND (t, 1),
8935 for (i = 1; i < 3; ++i)
8936 if (potential_constant_expression_1 (TREE_OPERAND (t, i),
8937 want_rval, tf_none))
8939 if (flags & tf_error)
8940 error ("expression %qE is not a constant-expression", t);
8944 if (VEC_INIT_EXPR_IS_CONSTEXPR (t))
8946 if (flags & tf_error)
8948 error ("non-constant array initialization");
8949 diagnose_non_constexpr_vec_init (t);
8954 if (objc_is_property_ref (t))
8957 sorry ("unexpected AST of kind %s", tree_code_name[TREE_CODE (t)]);
8963 /* The main entry point to the above. */
8966 potential_constant_expression (tree t)
8968 return potential_constant_expression_1 (t, false, tf_none);
8971 /* As above, but require a constant rvalue. */
8974 potential_rvalue_constant_expression (tree t)
8976 return potential_constant_expression_1 (t, true, tf_none);
8979 /* Like above, but complain about non-constant expressions. */
8982 require_potential_constant_expression (tree t)
8984 return potential_constant_expression_1 (t, false, tf_warning_or_error);
8987 /* Cross product of the above. */
8990 require_potential_rvalue_constant_expression (tree t)
8992 return potential_constant_expression_1 (t, true, tf_warning_or_error);
8995 /* Insert the deduced return type for an auto function. */
8998 apply_deduced_return_type (tree fco, tree return_type)
9002 if (return_type == error_mark_node)
9005 if (LAMBDA_FUNCTION_P (fco))
9007 tree lambda = CLASSTYPE_LAMBDA_EXPR (current_class_type);
9008 LAMBDA_EXPR_RETURN_TYPE (lambda) = return_type;
9011 if (DECL_CONV_FN_P (fco))
9012 DECL_NAME (fco) = mangle_conv_op_name_for_type (return_type);
9014 TREE_TYPE (fco) = change_return_type (return_type, TREE_TYPE (fco));
9016 result = DECL_RESULT (fco);
9017 if (result == NULL_TREE)
9019 if (TREE_TYPE (result) == return_type)
9022 /* We already have a DECL_RESULT from start_preparsed_function.
9023 Now we need to redo the work it and allocate_struct_function
9024 did to reflect the new type. */
9025 gcc_assert (current_function_decl == fco);
9026 result = build_decl (input_location, RESULT_DECL, NULL_TREE,
9027 TYPE_MAIN_VARIANT (return_type));
9028 DECL_ARTIFICIAL (result) = 1;
9029 DECL_IGNORED_P (result) = 1;
9030 cp_apply_type_quals_to_decl (cp_type_quals (return_type),
9033 DECL_RESULT (fco) = result;
9035 if (!processing_template_decl)
9037 bool aggr = aggregate_value_p (result, fco);
9038 #ifdef PCC_STATIC_STRUCT_RETURN
9039 cfun->returns_pcc_struct = aggr;
9041 cfun->returns_struct = aggr;
9046 /* DECL is a local variable or parameter from the surrounding scope of a
9047 lambda-expression. Returns the decltype for a use of the capture field
9048 for DECL even if it hasn't been captured yet. */
9051 capture_decltype (tree decl)
9053 tree lam = CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (current_function_decl));
9054 /* FIXME do lookup instead of list walk? */
9055 tree cap = value_member (decl, LAMBDA_EXPR_CAPTURE_LIST (lam));
9059 type = TREE_TYPE (TREE_PURPOSE (cap));
9061 switch (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lam))
9064 error ("%qD is not captured", decl);
9065 return error_mark_node;
9068 type = TREE_TYPE (decl);
9069 if (TREE_CODE (type) == REFERENCE_TYPE
9070 && TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE)
9071 type = TREE_TYPE (type);
9074 case CPLD_REFERENCE:
9075 type = TREE_TYPE (decl);
9076 if (TREE_CODE (type) != REFERENCE_TYPE)
9077 type = build_reference_type (TREE_TYPE (decl));
9084 if (TREE_CODE (type) != REFERENCE_TYPE)
9086 if (!LAMBDA_EXPR_MUTABLE_P (lam))
9087 type = cp_build_qualified_type (type, (cp_type_quals (type)
9089 type = build_reference_type (type);
9094 #include "gt-cp-semantics.h"