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 SET_EXPR_LOCATION (body
, EXPR_LOCATION (TRANSACTION_EXPR_BODY (stmt
)));
5203 TREE_SIDE_EFFECTS (body
) = 1;
5204 TRANSACTION_EXPR_BODY (stmt
) = body
;
5208 finish_compound_stmt (compound_stmt
);
5211 /* Build a __transaction_atomic or __transaction_relaxed expression. If
5212 NOEX is non-NULL, we wrap the body in a MUST_NOT_THROW_EXPR with NOEX as
5216 build_transaction_expr (location_t loc
, tree expr
, int flags
, tree noex
)
5221 expr
= build_must_not_throw_expr (expr
, noex
);
5222 SET_EXPR_LOCATION (expr
, loc
);
5223 TREE_SIDE_EFFECTS (expr
) = 1;
5225 ret
= build1 (TRANSACTION_EXPR
, TREE_TYPE (expr
), expr
);
5226 if (flags
& TM_STMT_ATTR_RELAXED
)
5227 TRANSACTION_EXPR_RELAXED (ret
) = 1;
5228 TREE_SIDE_EFFECTS (ret
) = 1;
5229 SET_EXPR_LOCATION (ret
, loc
);
5234 init_cp_semantics (void)
5238 /* Build a STATIC_ASSERT for a static assertion with the condition
5239 CONDITION and the message text MESSAGE. LOCATION is the location
5240 of the static assertion in the source code. When MEMBER_P, this
5241 static assertion is a member of a class. */
5243 finish_static_assert (tree condition
, tree message
, location_t location
,
5246 if (message
== NULL_TREE
5247 || message
== error_mark_node
5248 || condition
== NULL_TREE
5249 || condition
== error_mark_node
)
5252 if (check_for_bare_parameter_packs (condition
))
5253 condition
= error_mark_node
;
5255 if (type_dependent_expression_p (condition
)
5256 || value_dependent_expression_p (condition
))
5258 /* We're in a template; build a STATIC_ASSERT and put it in
5262 assertion
= make_node (STATIC_ASSERT
);
5263 STATIC_ASSERT_CONDITION (assertion
) = condition
;
5264 STATIC_ASSERT_MESSAGE (assertion
) = message
;
5265 STATIC_ASSERT_SOURCE_LOCATION (assertion
) = location
;
5268 maybe_add_class_template_decl_list (current_class_type
,
5272 add_stmt (assertion
);
5277 /* Fold the expression and convert it to a boolean value. */
5278 condition
= fold_non_dependent_expr (condition
);
5279 condition
= cp_convert (boolean_type_node
, condition
, tf_warning_or_error
);
5280 condition
= maybe_constant_value (condition
);
5282 if (TREE_CODE (condition
) == INTEGER_CST
&& !integer_zerop (condition
))
5283 /* Do nothing; the condition is satisfied. */
5287 location_t saved_loc
= input_location
;
5289 input_location
= location
;
5290 if (TREE_CODE (condition
) == INTEGER_CST
5291 && integer_zerop (condition
))
5292 /* Report the error. */
5293 error ("static assertion failed: %s", TREE_STRING_POINTER (message
));
5294 else if (condition
&& condition
!= error_mark_node
)
5296 error ("non-constant condition for static assertion");
5297 cxx_constant_value (condition
);
5299 input_location
= saved_loc
;
5303 /* Implements the C++0x decltype keyword. Returns the type of EXPR,
5304 suitable for use as a type-specifier.
5306 ID_EXPRESSION_OR_MEMBER_ACCESS_P is true when EXPR was parsed as an
5307 id-expression or a class member access, FALSE when it was parsed as
5308 a full expression. */
5311 finish_decltype_type (tree expr
, bool id_expression_or_member_access_p
,
5312 tsubst_flags_t complain
)
5314 tree type
= NULL_TREE
;
5316 if (!expr
|| error_operand_p (expr
))
5317 return error_mark_node
;
5320 || TREE_CODE (expr
) == TYPE_DECL
5321 || (TREE_CODE (expr
) == BIT_NOT_EXPR
5322 && TYPE_P (TREE_OPERAND (expr
, 0))))
5324 if (complain
& tf_error
)
5325 error ("argument to decltype must be an expression");
5326 return error_mark_node
;
5329 /* Depending on the resolution of DR 1172, we may later need to distinguish
5330 instantiation-dependent but not type-dependent expressions so that, say,
5331 A<decltype(sizeof(T))>::U doesn't require 'typename'. */
5332 if (instantiation_dependent_expression_p (expr
))
5334 type
= cxx_make_type (DECLTYPE_TYPE
);
5335 DECLTYPE_TYPE_EXPR (type
) = expr
;
5336 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type
)
5337 = id_expression_or_member_access_p
;
5338 SET_TYPE_STRUCTURAL_EQUALITY (type
);
5343 /* The type denoted by decltype(e) is defined as follows: */
5345 expr
= resolve_nondeduced_context (expr
);
5347 if (invalid_nonstatic_memfn_p (expr
, complain
))
5348 return error_mark_node
;
5350 if (type_unknown_p (expr
))
5352 if (complain
& tf_error
)
5353 error ("decltype cannot resolve address of overloaded function");
5354 return error_mark_node
;
5357 /* To get the size of a static data member declared as an array of
5358 unknown bound, we need to instantiate it. */
5360 && VAR_HAD_UNKNOWN_BOUND (expr
)
5361 && DECL_TEMPLATE_INSTANTIATION (expr
))
5362 instantiate_decl (expr
, /*defer_ok*/true, /*expl_inst_mem*/false);
5364 if (id_expression_or_member_access_p
)
5366 /* If e is an id-expression or a class member access (5.2.5
5367 [expr.ref]), decltype(e) is defined as the type of the entity
5368 named by e. If there is no such entity, or e names a set of
5369 overloaded functions, the program is ill-formed. */
5370 if (identifier_p (expr
))
5371 expr
= lookup_name (expr
);
5373 if (INDIRECT_REF_P (expr
))
5374 /* This can happen when the expression is, e.g., "a.b". Just
5375 look at the underlying operand. */
5376 expr
= TREE_OPERAND (expr
, 0);
5378 if (TREE_CODE (expr
) == OFFSET_REF
5379 || TREE_CODE (expr
) == MEMBER_REF
5380 || TREE_CODE (expr
) == SCOPE_REF
)
5381 /* We're only interested in the field itself. If it is a
5382 BASELINK, we will need to see through it in the next
5384 expr
= TREE_OPERAND (expr
, 1);
5386 if (BASELINK_P (expr
))
5387 /* See through BASELINK nodes to the underlying function. */
5388 expr
= BASELINK_FUNCTIONS (expr
);
5390 switch (TREE_CODE (expr
))
5393 if (DECL_BIT_FIELD_TYPE (expr
))
5395 type
= DECL_BIT_FIELD_TYPE (expr
);
5398 /* Fall through for fields that aren't bitfields. */
5405 case TEMPLATE_PARM_INDEX
:
5406 expr
= mark_type_use (expr
);
5407 type
= TREE_TYPE (expr
);
5411 type
= error_mark_node
;
5416 mark_type_use (expr
);
5417 type
= is_bitfield_expr_with_lowered_type (expr
);
5419 type
= TREE_TYPE (TREE_OPERAND (expr
, 1));
5427 /* We can get here when the id-expression refers to an
5428 enumerator or non-type template parameter. */
5429 type
= TREE_TYPE (expr
);
5433 /* Handle instantiated template non-type arguments. */
5434 type
= TREE_TYPE (expr
);
5440 /* Within a lambda-expression:
5442 Every occurrence of decltype((x)) where x is a possibly
5443 parenthesized id-expression that names an entity of
5444 automatic storage duration is treated as if x were
5445 transformed into an access to a corresponding data member
5446 of the closure type that would have been declared if x
5447 were a use of the denoted entity. */
5448 if (outer_automatic_var_p (expr
)
5449 && current_function_decl
5450 && LAMBDA_FUNCTION_P (current_function_decl
))
5451 type
= capture_decltype (expr
);
5452 else if (error_operand_p (expr
))
5453 type
= error_mark_node
;
5454 else if (expr
== current_class_ptr
)
5455 /* If the expression is just "this", we want the
5456 cv-unqualified pointer for the "this" type. */
5457 type
= TYPE_MAIN_VARIANT (TREE_TYPE (expr
));
5460 /* Otherwise, where T is the type of e, if e is an lvalue,
5461 decltype(e) is defined as T&; if an xvalue, T&&; otherwise, T. */
5462 cp_lvalue_kind clk
= lvalue_kind (expr
);
5463 type
= unlowered_expr_type (expr
);
5464 gcc_assert (TREE_CODE (type
) != REFERENCE_TYPE
);
5466 /* For vector types, pick a non-opaque variant. */
5467 if (TREE_CODE (type
) == VECTOR_TYPE
)
5468 type
= strip_typedefs (type
);
5470 if (clk
!= clk_none
&& !(clk
& clk_class
))
5471 type
= cp_build_reference_type (type
, (clk
& clk_rvalueref
));
5475 if (cxx_dialect
>= cxx1y
&& array_of_runtime_bound_p (type
))
5477 if (complain
& tf_warning_or_error
)
5478 pedwarn (input_location
, OPT_Wvla
,
5479 "taking decltype of array of runtime bound");
5481 return error_mark_node
;
5487 /* Called from trait_expr_value to evaluate either __has_nothrow_assign or
5488 __has_nothrow_copy, depending on assign_p. */
5491 classtype_has_nothrow_assign_or_copy_p (tree type
, bool assign_p
)
5498 ix
= lookup_fnfields_1 (type
, ansi_assopname (NOP_EXPR
));
5501 fns
= (*CLASSTYPE_METHOD_VEC (type
))[ix
];
5503 else if (TYPE_HAS_COPY_CTOR (type
))
5505 /* If construction of the copy constructor was postponed, create
5507 if (CLASSTYPE_LAZY_COPY_CTOR (type
))
5508 lazily_declare_fn (sfk_copy_constructor
, type
);
5509 if (CLASSTYPE_LAZY_MOVE_CTOR (type
))
5510 lazily_declare_fn (sfk_move_constructor
, type
);
5511 fns
= CLASSTYPE_CONSTRUCTORS (type
);
5516 for (; fns
; fns
= OVL_NEXT (fns
))
5518 tree fn
= OVL_CURRENT (fns
);
5522 if (copy_fn_p (fn
) == 0)
5525 else if (copy_fn_p (fn
) <= 0)
5528 maybe_instantiate_noexcept (fn
);
5529 if (!TYPE_NOTHROW_P (TREE_TYPE (fn
)))
5536 /* Actually evaluates the trait. */
5539 trait_expr_value (cp_trait_kind kind
, tree type1
, tree type2
)
5541 enum tree_code type_code1
;
5544 type_code1
= TREE_CODE (type1
);
5548 case CPTK_HAS_NOTHROW_ASSIGN
:
5549 type1
= strip_array_types (type1
);
5550 return (!CP_TYPE_CONST_P (type1
) && type_code1
!= REFERENCE_TYPE
5551 && (trait_expr_value (CPTK_HAS_TRIVIAL_ASSIGN
, type1
, type2
)
5552 || (CLASS_TYPE_P (type1
)
5553 && classtype_has_nothrow_assign_or_copy_p (type1
,
5556 case CPTK_HAS_TRIVIAL_ASSIGN
:
5557 /* ??? The standard seems to be missing the "or array of such a class
5558 type" wording for this trait. */
5559 type1
= strip_array_types (type1
);
5560 return (!CP_TYPE_CONST_P (type1
) && type_code1
!= REFERENCE_TYPE
5561 && (trivial_type_p (type1
)
5562 || (CLASS_TYPE_P (type1
)
5563 && TYPE_HAS_TRIVIAL_COPY_ASSIGN (type1
))));
5565 case CPTK_HAS_NOTHROW_CONSTRUCTOR
:
5566 type1
= strip_array_types (type1
);
5567 return (trait_expr_value (CPTK_HAS_TRIVIAL_CONSTRUCTOR
, type1
, type2
)
5568 || (CLASS_TYPE_P (type1
)
5569 && (t
= locate_ctor (type1
))
5570 && (maybe_instantiate_noexcept (t
),
5571 TYPE_NOTHROW_P (TREE_TYPE (t
)))));
5573 case CPTK_HAS_TRIVIAL_CONSTRUCTOR
:
5574 type1
= strip_array_types (type1
);
5575 return (trivial_type_p (type1
)
5576 || (CLASS_TYPE_P (type1
) && TYPE_HAS_TRIVIAL_DFLT (type1
)));
5578 case CPTK_HAS_NOTHROW_COPY
:
5579 type1
= strip_array_types (type1
);
5580 return (trait_expr_value (CPTK_HAS_TRIVIAL_COPY
, type1
, type2
)
5581 || (CLASS_TYPE_P (type1
)
5582 && classtype_has_nothrow_assign_or_copy_p (type1
, false)));
5584 case CPTK_HAS_TRIVIAL_COPY
:
5585 /* ??? The standard seems to be missing the "or array of such a class
5586 type" wording for this trait. */
5587 type1
= strip_array_types (type1
);
5588 return (trivial_type_p (type1
) || type_code1
== REFERENCE_TYPE
5589 || (CLASS_TYPE_P (type1
) && TYPE_HAS_TRIVIAL_COPY_CTOR (type1
)));
5591 case CPTK_HAS_TRIVIAL_DESTRUCTOR
:
5592 type1
= strip_array_types (type1
);
5593 return (trivial_type_p (type1
) || type_code1
== REFERENCE_TYPE
5594 || (CLASS_TYPE_P (type1
)
5595 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type1
)));
5597 case CPTK_HAS_VIRTUAL_DESTRUCTOR
:
5598 return type_has_virtual_destructor (type1
);
5600 case CPTK_IS_ABSTRACT
:
5601 return (ABSTRACT_CLASS_TYPE_P (type1
));
5603 case CPTK_IS_BASE_OF
:
5604 return (NON_UNION_CLASS_TYPE_P (type1
) && NON_UNION_CLASS_TYPE_P (type2
)
5605 && DERIVED_FROM_P (type1
, type2
));
5608 return (NON_UNION_CLASS_TYPE_P (type1
));
5610 case CPTK_IS_CONVERTIBLE_TO
:
5615 return (NON_UNION_CLASS_TYPE_P (type1
) && CLASSTYPE_EMPTY_P (type1
));
5618 return (type_code1
== ENUMERAL_TYPE
);
5621 return (CLASS_TYPE_P (type1
) && CLASSTYPE_FINAL (type1
));
5623 case CPTK_IS_LITERAL_TYPE
:
5624 return (literal_type_p (type1
));
5627 return (pod_type_p (type1
));
5629 case CPTK_IS_POLYMORPHIC
:
5630 return (CLASS_TYPE_P (type1
) && TYPE_POLYMORPHIC_P (type1
));
5632 case CPTK_IS_STD_LAYOUT
:
5633 return (std_layout_type_p (type1
));
5635 case CPTK_IS_TRIVIAL
:
5636 return (trivial_type_p (type1
));
5639 return (type_code1
== UNION_TYPE
);
5647 /* If TYPE is an array of unknown bound, or (possibly cv-qualified)
5648 void, or a complete type, returns it, otherwise NULL_TREE. */
5651 check_trait_type (tree type
)
5653 if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
)
5654 && COMPLETE_TYPE_P (TREE_TYPE (type
)))
5657 if (VOID_TYPE_P (type
))
5660 return complete_type_or_else (strip_array_types (type
), NULL_TREE
);
5663 /* Process a trait expression. */
5666 finish_trait_expr (cp_trait_kind kind
, tree type1
, tree type2
)
5668 gcc_assert (kind
== CPTK_HAS_NOTHROW_ASSIGN
5669 || kind
== CPTK_HAS_NOTHROW_CONSTRUCTOR
5670 || kind
== CPTK_HAS_NOTHROW_COPY
5671 || kind
== CPTK_HAS_TRIVIAL_ASSIGN
5672 || kind
== CPTK_HAS_TRIVIAL_CONSTRUCTOR
5673 || kind
== CPTK_HAS_TRIVIAL_COPY
5674 || kind
== CPTK_HAS_TRIVIAL_DESTRUCTOR
5675 || kind
== CPTK_HAS_VIRTUAL_DESTRUCTOR
5676 || kind
== CPTK_IS_ABSTRACT
5677 || kind
== CPTK_IS_BASE_OF
5678 || kind
== CPTK_IS_CLASS
5679 || kind
== CPTK_IS_CONVERTIBLE_TO
5680 || kind
== CPTK_IS_EMPTY
5681 || kind
== CPTK_IS_ENUM
5682 || kind
== CPTK_IS_FINAL
5683 || kind
== CPTK_IS_LITERAL_TYPE
5684 || kind
== CPTK_IS_POD
5685 || kind
== CPTK_IS_POLYMORPHIC
5686 || kind
== CPTK_IS_STD_LAYOUT
5687 || kind
== CPTK_IS_TRIVIAL
5688 || kind
== CPTK_IS_UNION
);
5690 if (kind
== CPTK_IS_CONVERTIBLE_TO
)
5692 sorry ("__is_convertible_to");
5693 return error_mark_node
;
5696 if (type1
== error_mark_node
5697 || ((kind
== CPTK_IS_BASE_OF
|| kind
== CPTK_IS_CONVERTIBLE_TO
)
5698 && type2
== error_mark_node
))
5699 return error_mark_node
;
5701 if (processing_template_decl
)
5703 tree trait_expr
= make_node (TRAIT_EXPR
);
5704 TREE_TYPE (trait_expr
) = boolean_type_node
;
5705 TRAIT_EXPR_TYPE1 (trait_expr
) = type1
;
5706 TRAIT_EXPR_TYPE2 (trait_expr
) = type2
;
5707 TRAIT_EXPR_KIND (trait_expr
) = kind
;
5713 case CPTK_HAS_NOTHROW_ASSIGN
:
5714 case CPTK_HAS_TRIVIAL_ASSIGN
:
5715 case CPTK_HAS_NOTHROW_CONSTRUCTOR
:
5716 case CPTK_HAS_TRIVIAL_CONSTRUCTOR
:
5717 case CPTK_HAS_NOTHROW_COPY
:
5718 case CPTK_HAS_TRIVIAL_COPY
:
5719 case CPTK_HAS_TRIVIAL_DESTRUCTOR
:
5720 case CPTK_HAS_VIRTUAL_DESTRUCTOR
:
5721 case CPTK_IS_ABSTRACT
:
5724 case CPTK_IS_LITERAL_TYPE
:
5726 case CPTK_IS_POLYMORPHIC
:
5727 case CPTK_IS_STD_LAYOUT
:
5728 case CPTK_IS_TRIVIAL
:
5729 if (!check_trait_type (type1
))
5730 return error_mark_node
;
5733 case CPTK_IS_BASE_OF
:
5734 if (NON_UNION_CLASS_TYPE_P (type1
) && NON_UNION_CLASS_TYPE_P (type2
)
5735 && !same_type_ignoring_top_level_qualifiers_p (type1
, type2
)
5736 && !complete_type_or_else (type2
, NULL_TREE
))
5737 /* We already issued an error. */
5738 return error_mark_node
;
5746 case CPTK_IS_CONVERTIBLE_TO
:
5751 return (trait_expr_value (kind
, type1
, type2
)
5752 ? boolean_true_node
: boolean_false_node
);
5755 /* Do-nothing variants of functions to handle pragma FLOAT_CONST_DECIMAL64,
5756 which is ignored for C++. */
5759 set_float_const_decimal64 (void)
5764 clear_float_const_decimal64 (void)
5769 float_const_decimal64_p (void)
5775 /* Return true if T is a literal type. */
5778 literal_type_p (tree t
)
5780 if (SCALAR_TYPE_P (t
)
5781 || TREE_CODE (t
) == VECTOR_TYPE
5782 || TREE_CODE (t
) == REFERENCE_TYPE
)
5784 if (CLASS_TYPE_P (t
))
5786 t
= complete_type (t
);
5787 gcc_assert (COMPLETE_TYPE_P (t
) || errorcount
);
5788 return CLASSTYPE_LITERAL_P (t
);
5790 if (TREE_CODE (t
) == ARRAY_TYPE
)
5791 return literal_type_p (strip_array_types (t
));
5795 /* If DECL is a variable declared `constexpr', require its type
5796 be literal. Return the DECL if OK, otherwise NULL. */
5799 ensure_literal_type_for_constexpr_object (tree decl
)
5801 tree type
= TREE_TYPE (decl
);
5802 if (VAR_P (decl
) && DECL_DECLARED_CONSTEXPR_P (decl
)
5803 && !processing_template_decl
)
5805 if (CLASS_TYPE_P (type
) && !COMPLETE_TYPE_P (complete_type (type
)))
5806 /* Don't complain here, we'll complain about incompleteness
5807 when we try to initialize the variable. */;
5808 else if (!literal_type_p (type
))
5810 error ("the type %qT of constexpr variable %qD is not literal",
5812 explain_non_literal_class (type
);
5819 /* Representation of entries in the constexpr function definition table. */
5821 typedef struct GTY(()) constexpr_fundef
{
5826 /* This table holds all constexpr function definitions seen in
5827 the current translation unit. */
5829 static GTY ((param_is (constexpr_fundef
))) htab_t constexpr_fundef_table
;
5831 /* Utility function used for managing the constexpr function table.
5832 Return true if the entries pointed to by P and Q are for the
5833 same constexpr function. */
5836 constexpr_fundef_equal (const void *p
, const void *q
)
5838 const constexpr_fundef
*lhs
= (const constexpr_fundef
*) p
;
5839 const constexpr_fundef
*rhs
= (const constexpr_fundef
*) q
;
5840 return lhs
->decl
== rhs
->decl
;
5843 /* Utility function used for managing the constexpr function table.
5844 Return a hash value for the entry pointed to by Q. */
5846 static inline hashval_t
5847 constexpr_fundef_hash (const void *p
)
5849 const constexpr_fundef
*fundef
= (const constexpr_fundef
*) p
;
5850 return DECL_UID (fundef
->decl
);
5853 /* Return a previously saved definition of function FUN. */
5855 static constexpr_fundef
*
5856 retrieve_constexpr_fundef (tree fun
)
5858 constexpr_fundef fundef
= { NULL
, NULL
};
5859 if (constexpr_fundef_table
== NULL
)
5863 return (constexpr_fundef
*) htab_find (constexpr_fundef_table
, &fundef
);
5866 /* Check whether the parameter and return types of FUN are valid for a
5867 constexpr function, and complain if COMPLAIN. */
5870 is_valid_constexpr_fn (tree fun
, bool complain
)
5872 tree parm
= FUNCTION_FIRST_USER_PARM (fun
);
5874 for (; parm
!= NULL
; parm
= TREE_CHAIN (parm
))
5875 if (!literal_type_p (TREE_TYPE (parm
)))
5880 error ("invalid type for parameter %d of constexpr "
5881 "function %q+#D", DECL_PARM_INDEX (parm
), fun
);
5882 explain_non_literal_class (TREE_TYPE (parm
));
5886 if (!DECL_CONSTRUCTOR_P (fun
))
5888 tree rettype
= TREE_TYPE (TREE_TYPE (fun
));
5889 if (!literal_type_p (rettype
))
5894 error ("invalid return type %qT of constexpr function %q+D",
5896 explain_non_literal_class (rettype
);
5900 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
5901 && !CLASSTYPE_LITERAL_P (DECL_CONTEXT (fun
)))
5906 error ("enclosing class of constexpr non-static member "
5907 "function %q+#D is not a literal type", fun
);
5908 explain_non_literal_class (DECL_CONTEXT (fun
));
5912 else if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fun
)))
5916 error ("%q#T has virtual base classes", DECL_CONTEXT (fun
));
5922 /* Subroutine of build_data_member_initialization. MEMBER is a COMPONENT_REF
5923 for a member of an anonymous aggregate, INIT is the initializer for that
5924 member, and VEC_OUTER is the vector of constructor elements for the class
5925 whose constructor we are processing. Add the initializer to the vector
5926 and return true to indicate success. */
5929 build_anon_member_initialization (tree member
, tree init
,
5930 vec
<constructor_elt
, va_gc
> **vec_outer
)
5932 /* MEMBER presents the relevant fields from the inside out, but we need
5933 to build up the initializer from the outside in so that we can reuse
5934 previously built CONSTRUCTORs if this is, say, the second field in an
5935 anonymous struct. So we use a vec as a stack. */
5940 fields
.safe_push (TREE_OPERAND (member
, 1));
5941 member
= TREE_OPERAND (member
, 0);
5943 while (ANON_AGGR_TYPE_P (TREE_TYPE (member
)));
5945 /* VEC has the constructor elements vector for the context of FIELD.
5946 If FIELD is an anonymous aggregate, we will push inside it. */
5947 vec
<constructor_elt
, va_gc
> **vec
= vec_outer
;
5949 while (field
= fields
.pop(),
5950 ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
5953 /* If there is already an outer constructor entry for the anonymous
5954 aggregate FIELD, use it; otherwise, insert one. */
5955 if (vec_safe_is_empty (*vec
)
5956 || (*vec
)->last().index
!= field
)
5958 ctor
= build_constructor (TREE_TYPE (field
), NULL
);
5959 CONSTRUCTOR_APPEND_ELT (*vec
, field
, ctor
);
5962 ctor
= (*vec
)->last().value
;
5963 vec
= &CONSTRUCTOR_ELTS (ctor
);
5966 /* Now we're at the innermost field, the one that isn't an anonymous
5967 aggregate. Add its initializer to the CONSTRUCTOR and we're done. */
5968 gcc_assert (fields
.is_empty());
5970 CONSTRUCTOR_APPEND_ELT (*vec
, field
, init
);
5975 /* Subroutine of build_constexpr_constructor_member_initializers.
5976 The expression tree T represents a data member initialization
5977 in a (constexpr) constructor definition. Build a pairing of
5978 the data member with its initializer, and prepend that pair
5979 to the existing initialization pair INITS. */
5982 build_data_member_initialization (tree t
, vec
<constructor_elt
, va_gc
> **vec
)
5985 if (TREE_CODE (t
) == CLEANUP_POINT_EXPR
)
5986 t
= TREE_OPERAND (t
, 0);
5987 if (TREE_CODE (t
) == EXPR_STMT
)
5988 t
= TREE_OPERAND (t
, 0);
5989 if (t
== error_mark_node
)
5991 if (TREE_CODE (t
) == STATEMENT_LIST
)
5993 tree_stmt_iterator i
;
5994 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
5996 if (! build_data_member_initialization (tsi_stmt (i
), vec
))
6001 if (TREE_CODE (t
) == CLEANUP_STMT
)
6003 /* We can't see a CLEANUP_STMT in a constructor for a literal class,
6004 but we can in a constexpr constructor for a non-literal class. Just
6005 ignore it; either all the initialization will be constant, in which
6006 case the cleanup can't run, or it can't be constexpr.
6007 Still recurse into CLEANUP_BODY. */
6008 return build_data_member_initialization (CLEANUP_BODY (t
), vec
);
6010 if (TREE_CODE (t
) == CONVERT_EXPR
)
6011 t
= TREE_OPERAND (t
, 0);
6012 if (TREE_CODE (t
) == INIT_EXPR
6013 || TREE_CODE (t
) == MODIFY_EXPR
)
6015 member
= TREE_OPERAND (t
, 0);
6016 init
= break_out_target_exprs (TREE_OPERAND (t
, 1));
6018 else if (TREE_CODE (t
) == CALL_EXPR
)
6020 member
= CALL_EXPR_ARG (t
, 0);
6021 /* We don't use build_cplus_new here because it complains about
6022 abstract bases. Leaving the call unwrapped means that it has the
6023 wrong type, but cxx_eval_constant_expression doesn't care. */
6024 init
= break_out_target_exprs (t
);
6026 else if (TREE_CODE (t
) == DECL_EXPR
)
6027 /* Declaring a temporary, don't add it to the CONSTRUCTOR. */
6031 if (INDIRECT_REF_P (member
))
6032 member
= TREE_OPERAND (member
, 0);
6033 if (TREE_CODE (member
) == NOP_EXPR
)
6037 if (TREE_CODE (op
) == ADDR_EXPR
)
6039 gcc_assert (same_type_ignoring_top_level_qualifiers_p
6040 (TREE_TYPE (TREE_TYPE (op
)),
6041 TREE_TYPE (TREE_TYPE (member
))));
6042 /* Initializing a cv-qualified member; we need to look through
6046 else if (op
== current_class_ptr
6047 && (same_type_ignoring_top_level_qualifiers_p
6048 (TREE_TYPE (TREE_TYPE (member
)),
6049 current_class_type
)))
6050 /* Delegating constructor. */
6054 /* This is an initializer for an empty base; keep it for now so
6055 we can check it in cxx_eval_bare_aggregate. */
6056 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member
))));
6059 if (TREE_CODE (member
) == ADDR_EXPR
)
6060 member
= TREE_OPERAND (member
, 0);
6061 if (TREE_CODE (member
) == COMPONENT_REF
)
6063 tree aggr
= TREE_OPERAND (member
, 0);
6064 if (TREE_CODE (aggr
) != COMPONENT_REF
)
6065 /* Normal member initialization. */
6066 member
= TREE_OPERAND (member
, 1);
6067 else if (ANON_AGGR_TYPE_P (TREE_TYPE (aggr
)))
6068 /* Initializing a member of an anonymous union. */
6069 return build_anon_member_initialization (member
, init
, vec
);
6071 /* We're initializing a vtable pointer in a base. Leave it as
6072 COMPONENT_REF so we remember the path to get to the vfield. */
6073 gcc_assert (TREE_TYPE (member
) == vtbl_ptr_type_node
);
6076 CONSTRUCTOR_APPEND_ELT (*vec
, member
, init
);
6080 /* Make sure that there are no statements after LAST in the constructor
6081 body represented by LIST. */
6084 check_constexpr_ctor_body (tree last
, tree list
)
6087 if (TREE_CODE (list
) == STATEMENT_LIST
)
6089 tree_stmt_iterator i
= tsi_last (list
);
6090 for (; !tsi_end_p (i
); tsi_prev (&i
))
6092 tree t
= tsi_stmt (i
);
6095 if (TREE_CODE (t
) == BIND_EXPR
)
6097 if (!check_constexpr_ctor_body (last
, BIND_EXPR_BODY (t
)))
6102 /* We currently allow typedefs and static_assert.
6103 FIXME allow them in the standard, too. */
6104 if (TREE_CODE (t
) != STATIC_ASSERT
)
6111 else if (list
!= last
6112 && TREE_CODE (list
) != STATIC_ASSERT
)
6116 error ("constexpr constructor does not have empty body");
6117 DECL_DECLARED_CONSTEXPR_P (current_function_decl
) = false;
6122 /* V is a vector of constructor elements built up for the base and member
6123 initializers of a constructor for TYPE. They need to be in increasing
6124 offset order, which they might not be yet if TYPE has a primary base
6125 which is not first in the base-clause or a vptr and at least one base
6126 all of which are non-primary. */
6128 static vec
<constructor_elt
, va_gc
> *
6129 sort_constexpr_mem_initializers (tree type
, vec
<constructor_elt
, va_gc
> *v
)
6131 tree pri
= CLASSTYPE_PRIMARY_BINFO (type
);
6133 constructor_elt elt
;
6137 field_type
= BINFO_TYPE (pri
);
6138 else if (TYPE_CONTAINS_VPTR_P (type
))
6139 field_type
= vtbl_ptr_type_node
;
6143 /* Find the element for the primary base or vptr and move it to the
6144 beginning of the vec. */
6145 vec
<constructor_elt
, va_gc
> &vref
= *v
;
6147 if (TREE_TYPE (vref
[i
].index
) == field_type
)
6154 vref
[i
] = vref
[i
-1];
6161 /* Build compile-time evalable representations of member-initializer list
6162 for a constexpr constructor. */
6165 build_constexpr_constructor_member_initializers (tree type
, tree body
)
6167 vec
<constructor_elt
, va_gc
> *vec
= NULL
;
6169 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
6170 || TREE_CODE (body
) == EH_SPEC_BLOCK
)
6171 body
= TREE_OPERAND (body
, 0);
6172 if (TREE_CODE (body
) == STATEMENT_LIST
)
6173 body
= STATEMENT_LIST_HEAD (body
)->stmt
;
6174 body
= BIND_EXPR_BODY (body
);
6175 if (TREE_CODE (body
) == CLEANUP_POINT_EXPR
)
6177 body
= TREE_OPERAND (body
, 0);
6178 if (TREE_CODE (body
) == EXPR_STMT
)
6179 body
= TREE_OPERAND (body
, 0);
6180 if (TREE_CODE (body
) == INIT_EXPR
6181 && (same_type_ignoring_top_level_qualifiers_p
6182 (TREE_TYPE (TREE_OPERAND (body
, 0)),
6183 current_class_type
)))
6186 return TREE_OPERAND (body
, 1);
6188 ok
= build_data_member_initialization (body
, &vec
);
6190 else if (TREE_CODE (body
) == STATEMENT_LIST
)
6192 tree_stmt_iterator i
;
6193 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
6195 ok
= build_data_member_initialization (tsi_stmt (i
), &vec
);
6200 else if (TREE_CODE (body
) == TRY_BLOCK
)
6202 error ("body of %<constexpr%> constructor cannot be "
6203 "a function-try-block");
6204 return error_mark_node
;
6206 else if (EXPR_P (body
))
6207 ok
= build_data_member_initialization (body
, &vec
);
6209 gcc_assert (errorcount
> 0);
6212 if (vec_safe_length (vec
) > 0)
6214 /* In a delegating constructor, return the target. */
6215 constructor_elt
*ce
= &(*vec
)[0];
6216 if (ce
->index
== current_class_ptr
)
6223 vec
= sort_constexpr_mem_initializers (type
, vec
);
6224 return build_constructor (type
, vec
);
6227 return error_mark_node
;
6230 /* Subroutine of register_constexpr_fundef. BODY is the body of a function
6231 declared to be constexpr, or a sub-statement thereof. Returns the
6232 return value if suitable, error_mark_node for a statement not allowed in
6233 a constexpr function, or NULL_TREE if no return value was found. */
6236 constexpr_fn_retval (tree body
)
6238 switch (TREE_CODE (body
))
6240 case STATEMENT_LIST
:
6242 tree_stmt_iterator i
;
6243 tree expr
= NULL_TREE
;
6244 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
6246 tree s
= constexpr_fn_retval (tsi_stmt (i
));
6247 if (s
== error_mark_node
)
6248 return error_mark_node
;
6249 else if (s
== NULL_TREE
)
6250 /* Keep iterating. */;
6252 /* Multiple return statements. */
6253 return error_mark_node
;
6261 return break_out_target_exprs (TREE_OPERAND (body
, 0));
6264 if (TREE_CODE (DECL_EXPR_DECL (body
)) == USING_DECL
)
6266 return error_mark_node
;
6268 case CLEANUP_POINT_EXPR
:
6269 return constexpr_fn_retval (TREE_OPERAND (body
, 0));
6275 return error_mark_node
;
6279 /* Subroutine of register_constexpr_fundef. BODY is the DECL_SAVED_TREE of
6280 FUN; do the necessary transformations to turn it into a single expression
6281 that we can store in the hash table. */
6284 massage_constexpr_body (tree fun
, tree body
)
6286 if (DECL_CONSTRUCTOR_P (fun
))
6287 body
= build_constexpr_constructor_member_initializers
6288 (DECL_CONTEXT (fun
), body
);
6291 if (TREE_CODE (body
) == EH_SPEC_BLOCK
)
6292 body
= EH_SPEC_STMTS (body
);
6293 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
6294 body
= TREE_OPERAND (body
, 0);
6295 if (TREE_CODE (body
) == BIND_EXPR
)
6296 body
= BIND_EXPR_BODY (body
);
6297 body
= constexpr_fn_retval (body
);
6302 /* FUN is a constexpr constructor with massaged body BODY. Return true
6303 if some bases/fields are uninitialized, and complain if COMPLAIN. */
6306 cx_check_missing_mem_inits (tree fun
, tree body
, bool complain
)
6313 if (TREE_CODE (body
) != CONSTRUCTOR
)
6316 nelts
= CONSTRUCTOR_NELTS (body
);
6317 ctype
= DECL_CONTEXT (fun
);
6318 field
= TYPE_FIELDS (ctype
);
6320 if (TREE_CODE (ctype
) == UNION_TYPE
)
6322 if (nelts
== 0 && next_initializable_field (field
))
6325 error ("%<constexpr%> constructor for union %qT must "
6326 "initialize exactly one non-static data member", ctype
);
6333 for (i
= 0; i
<= nelts
; ++i
)
6340 index
= CONSTRUCTOR_ELT (body
, i
)->index
;
6341 /* Skip base and vtable inits. */
6342 if (TREE_CODE (index
) != FIELD_DECL
6343 || DECL_ARTIFICIAL (index
))
6346 for (; field
!= index
; field
= DECL_CHAIN (field
))
6349 if (TREE_CODE (field
) != FIELD_DECL
6350 || (DECL_C_BIT_FIELD (field
) && !DECL_NAME (field
))
6351 || DECL_ARTIFICIAL (field
))
6353 ftype
= strip_array_types (TREE_TYPE (field
));
6354 if (type_has_constexpr_default_constructor (ftype
))
6356 /* It's OK to skip a member with a trivial constexpr ctor.
6357 A constexpr ctor that isn't trivial should have been
6359 gcc_checking_assert (!TYPE_HAS_COMPLEX_DFLT (ftype
)
6360 || errorcount
!= 0);
6365 error ("uninitialized member %qD in %<constexpr%> constructor",
6369 if (field
== NULL_TREE
)
6371 field
= DECL_CHAIN (field
);
6377 /* We are processing the definition of the constexpr function FUN.
6378 Check that its BODY fulfills the propriate requirements and
6379 enter it in the constexpr function definition table.
6380 For constructor BODY is actually the TREE_LIST of the
6381 member-initializer list. */
6384 register_constexpr_fundef (tree fun
, tree body
)
6386 constexpr_fundef entry
;
6387 constexpr_fundef
**slot
;
6389 if (!is_valid_constexpr_fn (fun
, !DECL_GENERATED_P (fun
)))
6392 body
= massage_constexpr_body (fun
, body
);
6393 if (body
== NULL_TREE
|| body
== error_mark_node
)
6395 if (!DECL_CONSTRUCTOR_P (fun
))
6396 error ("body of constexpr function %qD not a return-statement", fun
);
6400 if (!potential_rvalue_constant_expression (body
))
6402 if (!DECL_GENERATED_P (fun
))
6403 require_potential_rvalue_constant_expression (body
);
6407 if (DECL_CONSTRUCTOR_P (fun
)
6408 && cx_check_missing_mem_inits (fun
, body
, !DECL_GENERATED_P (fun
)))
6411 /* Create the constexpr function table if necessary. */
6412 if (constexpr_fundef_table
== NULL
)
6413 constexpr_fundef_table
= htab_create_ggc (101,
6414 constexpr_fundef_hash
,
6415 constexpr_fundef_equal
,
6419 slot
= (constexpr_fundef
**)
6420 htab_find_slot (constexpr_fundef_table
, &entry
, INSERT
);
6422 gcc_assert (*slot
== NULL
);
6423 *slot
= ggc_alloc_constexpr_fundef ();
6429 /* FUN is a non-constexpr function called in a context that requires a
6430 constant expression. If it comes from a constexpr template, explain why
6431 the instantiation isn't constexpr. */
6434 explain_invalid_constexpr_fn (tree fun
)
6436 static struct pointer_set_t
*diagnosed
;
6438 location_t save_loc
;
6439 /* Only diagnose defaulted functions or instantiations. */
6440 if (!DECL_DEFAULTED_FN (fun
)
6441 && !is_instantiation_of_constexpr (fun
))
6443 if (diagnosed
== NULL
)
6444 diagnosed
= pointer_set_create ();
6445 if (pointer_set_insert (diagnosed
, fun
) != 0)
6446 /* Already explained. */
6449 save_loc
= input_location
;
6450 input_location
= DECL_SOURCE_LOCATION (fun
);
6451 inform (0, "%q+D is not usable as a constexpr function because:", fun
);
6452 /* First check the declaration. */
6453 if (is_valid_constexpr_fn (fun
, true))
6455 /* Then if it's OK, the body. */
6456 if (DECL_DEFAULTED_FN (fun
))
6457 explain_implicit_non_constexpr (fun
);
6460 body
= massage_constexpr_body (fun
, DECL_SAVED_TREE (fun
));
6461 require_potential_rvalue_constant_expression (body
);
6462 if (DECL_CONSTRUCTOR_P (fun
))
6463 cx_check_missing_mem_inits (fun
, body
, true);
6466 input_location
= save_loc
;
6469 /* Objects of this type represent calls to constexpr functions
6470 along with the bindings of parameters to their arguments, for
6471 the purpose of compile time evaluation. */
6473 typedef struct GTY(()) constexpr_call
{
6474 /* Description of the constexpr function definition. */
6475 constexpr_fundef
*fundef
;
6476 /* Parameter bindings environment. A TREE_LIST where each TREE_PURPOSE
6477 is a parameter _DECL and the TREE_VALUE is the value of the parameter.
6478 Note: This arrangement is made to accommodate the use of
6479 iterative_hash_template_arg (see pt.c). If you change this
6480 representation, also change the hash calculation in
6481 cxx_eval_call_expression. */
6483 /* Result of the call.
6484 NULL means the call is being evaluated.
6485 error_mark_node means that the evaluation was erroneous;
6486 otherwise, the actuall value of the call. */
6488 /* The hash of this call; we remember it here to avoid having to
6489 recalculate it when expanding the hash table. */
6493 /* A table of all constexpr calls that have been evaluated by the
6494 compiler in this translation unit. */
6496 static GTY ((param_is (constexpr_call
))) htab_t constexpr_call_table
;
6498 static tree
cxx_eval_constant_expression (const constexpr_call
*, tree
,
6499 bool, bool, bool *, bool *);
6501 /* Compute a hash value for a constexpr call representation. */
6504 constexpr_call_hash (const void *p
)
6506 const constexpr_call
*info
= (const constexpr_call
*) p
;
6510 /* Return 1 if the objects pointed to by P and Q represent calls
6511 to the same constexpr function with the same arguments.
6512 Otherwise, return 0. */
6515 constexpr_call_equal (const void *p
, const void *q
)
6517 const constexpr_call
*lhs
= (const constexpr_call
*) p
;
6518 const constexpr_call
*rhs
= (const constexpr_call
*) q
;
6523 if (!constexpr_fundef_equal (lhs
->fundef
, rhs
->fundef
))
6525 lhs_bindings
= lhs
->bindings
;
6526 rhs_bindings
= rhs
->bindings
;
6527 while (lhs_bindings
!= NULL
&& rhs_bindings
!= NULL
)
6529 tree lhs_arg
= TREE_VALUE (lhs_bindings
);
6530 tree rhs_arg
= TREE_VALUE (rhs_bindings
);
6531 gcc_assert (TREE_TYPE (lhs_arg
) == TREE_TYPE (rhs_arg
));
6532 if (!cp_tree_equal (lhs_arg
, rhs_arg
))
6534 lhs_bindings
= TREE_CHAIN (lhs_bindings
);
6535 rhs_bindings
= TREE_CHAIN (rhs_bindings
);
6537 return lhs_bindings
== rhs_bindings
;
6540 /* Initialize the constexpr call table, if needed. */
6543 maybe_initialize_constexpr_call_table (void)
6545 if (constexpr_call_table
== NULL
)
6546 constexpr_call_table
= htab_create_ggc (101,
6547 constexpr_call_hash
,
6548 constexpr_call_equal
,
6552 /* Return true if T designates the implied `this' parameter. */
6555 is_this_parameter (tree t
)
6557 return t
== current_class_ptr
;
6560 /* We have an expression tree T that represents a call, either CALL_EXPR
6561 or AGGR_INIT_EXPR. If the call is lexically to a named function,
6562 retrun the _DECL for that function. */
6565 get_function_named_in_call (tree t
)
6568 switch (TREE_CODE (t
))
6571 fun
= CALL_EXPR_FN (t
);
6574 case AGGR_INIT_EXPR
:
6575 fun
= AGGR_INIT_EXPR_FN (t
);
6582 if (TREE_CODE (fun
) == ADDR_EXPR
6583 && TREE_CODE (TREE_OPERAND (fun
, 0)) == FUNCTION_DECL
)
6584 fun
= TREE_OPERAND (fun
, 0);
6588 /* We have an expression tree T that represents a call, either CALL_EXPR
6589 or AGGR_INIT_EXPR. Return the Nth argument. */
6592 get_nth_callarg (tree t
, int n
)
6594 switch (TREE_CODE (t
))
6597 return CALL_EXPR_ARG (t
, n
);
6599 case AGGR_INIT_EXPR
:
6600 return AGGR_INIT_EXPR_ARG (t
, n
);
6608 /* Look up the binding of the function parameter T in a constexpr
6609 function call context CALL. */
6612 lookup_parameter_binding (const constexpr_call
*call
, tree t
)
6614 tree b
= purpose_member (t
, call
->bindings
);
6615 return TREE_VALUE (b
);
6618 /* Attempt to evaluate T which represents a call to a builtin function.
6619 We assume here that all builtin functions evaluate to scalar types
6620 represented by _CST nodes. */
6623 cxx_eval_builtin_function_call (const constexpr_call
*call
, tree t
,
6624 bool allow_non_constant
, bool addr
,
6625 bool *non_constant_p
, bool *overflow_p
)
6627 const int nargs
= call_expr_nargs (t
);
6628 tree
*args
= (tree
*) alloca (nargs
* sizeof (tree
));
6631 for (i
= 0; i
< nargs
; ++i
)
6633 args
[i
] = cxx_eval_constant_expression (call
, CALL_EXPR_ARG (t
, i
),
6634 allow_non_constant
, addr
,
6635 non_constant_p
, overflow_p
);
6636 if (allow_non_constant
&& *non_constant_p
)
6639 if (*non_constant_p
)
6641 new_call
= build_call_array_loc (EXPR_LOCATION (t
), TREE_TYPE (t
),
6642 CALL_EXPR_FN (t
), nargs
, args
);
6643 new_call
= fold (new_call
);
6644 VERIFY_CONSTANT (new_call
);
6648 /* TEMP is the constant value of a temporary object of type TYPE. Adjust
6649 the type of the value to match. */
6652 adjust_temp_type (tree type
, tree temp
)
6654 if (TREE_TYPE (temp
) == type
)
6656 /* Avoid wrapping an aggregate value in a NOP_EXPR. */
6657 if (TREE_CODE (temp
) == CONSTRUCTOR
)
6658 return build_constructor (type
, CONSTRUCTOR_ELTS (temp
));
6659 gcc_assert (scalarish_type_p (type
));
6660 return cp_fold_convert (type
, temp
);
6663 /* Subroutine of cxx_eval_call_expression.
6664 We are processing a call expression (either CALL_EXPR or
6665 AGGR_INIT_EXPR) in the call context of OLD_CALL. Evaluate
6666 all arguments and bind their values to correspondings
6667 parameters, making up the NEW_CALL context. */
6670 cxx_bind_parameters_in_call (const constexpr_call
*old_call
, tree t
,
6671 constexpr_call
*new_call
,
6672 bool allow_non_constant
,
6673 bool *non_constant_p
, bool *overflow_p
)
6675 const int nargs
= call_expr_nargs (t
);
6676 tree fun
= new_call
->fundef
->decl
;
6677 tree parms
= DECL_ARGUMENTS (fun
);
6679 for (i
= 0; i
< nargs
; ++i
)
6682 tree type
= parms
? TREE_TYPE (parms
) : void_type_node
;
6683 /* For member function, the first argument is a pointer to the implied
6684 object. And for an object construction, don't bind `this' before
6685 it is fully constructed. */
6686 if (i
== 0 && DECL_CONSTRUCTOR_P (fun
))
6688 x
= get_nth_callarg (t
, i
);
6689 if (parms
&& DECL_BY_REFERENCE (parms
))
6691 /* cp_genericize made this a reference for argument passing, but
6692 we don't want to treat it like one for constexpr evaluation. */
6693 gcc_assert (TREE_CODE (type
) == REFERENCE_TYPE
);
6694 gcc_assert (TREE_CODE (TREE_TYPE (x
)) == REFERENCE_TYPE
);
6695 type
= TREE_TYPE (type
);
6696 x
= convert_from_reference (x
);
6698 arg
= cxx_eval_constant_expression (old_call
, x
, allow_non_constant
,
6699 TREE_CODE (type
) == REFERENCE_TYPE
,
6700 non_constant_p
, overflow_p
);
6701 /* Don't VERIFY_CONSTANT here. */
6702 if (*non_constant_p
&& allow_non_constant
)
6704 /* Just discard ellipsis args after checking their constantitude. */
6707 if (*non_constant_p
)
6708 /* Don't try to adjust the type of non-constant args. */
6711 /* Make sure the binding has the same type as the parm. */
6712 if (TREE_CODE (type
) != REFERENCE_TYPE
)
6713 arg
= adjust_temp_type (type
, arg
);
6714 new_call
->bindings
= tree_cons (parms
, arg
, new_call
->bindings
);
6716 parms
= TREE_CHAIN (parms
);
6720 /* Variables and functions to manage constexpr call expansion context.
6721 These do not need to be marked for PCH or GC. */
6723 /* FIXME remember and print actual constant arguments. */
6724 static vec
<tree
> call_stack
= vNULL
;
6725 static int call_stack_tick
;
6726 static int last_cx_error_tick
;
6729 push_cx_call_context (tree call
)
6732 if (!EXPR_HAS_LOCATION (call
))
6733 SET_EXPR_LOCATION (call
, input_location
);
6734 call_stack
.safe_push (call
);
6735 if (call_stack
.length () > (unsigned) max_constexpr_depth
)
6741 pop_cx_call_context (void)
6748 cx_error_context (void)
6750 vec
<tree
> r
= vNULL
;
6751 if (call_stack_tick
!= last_cx_error_tick
6752 && !call_stack
.is_empty ())
6754 last_cx_error_tick
= call_stack_tick
;
6758 /* Subroutine of cxx_eval_constant_expression.
6759 Evaluate the call expression tree T in the context of OLD_CALL expression
6763 cxx_eval_call_expression (const constexpr_call
*old_call
, tree t
,
6764 bool allow_non_constant
, bool addr
,
6765 bool *non_constant_p
, bool *overflow_p
)
6767 location_t loc
= EXPR_LOC_OR_HERE (t
);
6768 tree fun
= get_function_named_in_call (t
);
6770 constexpr_call new_call
= { NULL
, NULL
, NULL
, 0 };
6771 constexpr_call
**slot
;
6772 constexpr_call
*entry
;
6775 if (TREE_CODE (fun
) != FUNCTION_DECL
)
6777 /* Might be a constexpr function pointer. */
6778 fun
= cxx_eval_constant_expression (old_call
, fun
, allow_non_constant
,
6779 /*addr*/false, non_constant_p
, overflow_p
);
6780 if (TREE_CODE (fun
) == ADDR_EXPR
)
6781 fun
= TREE_OPERAND (fun
, 0);
6783 if (TREE_CODE (fun
) != FUNCTION_DECL
)
6785 if (!allow_non_constant
&& !*non_constant_p
)
6786 error_at (loc
, "expression %qE does not designate a constexpr "
6788 *non_constant_p
= true;
6791 if (DECL_CLONED_FUNCTION_P (fun
))
6792 fun
= DECL_CLONED_FUNCTION (fun
);
6793 if (is_builtin_fn (fun
))
6794 return cxx_eval_builtin_function_call (old_call
, t
, allow_non_constant
,
6795 addr
, non_constant_p
, overflow_p
);
6796 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
6798 if (!allow_non_constant
)
6800 error_at (loc
, "call to non-constexpr function %qD", fun
);
6801 explain_invalid_constexpr_fn (fun
);
6803 *non_constant_p
= true;
6807 /* Shortcut trivial copy constructor/op=. */
6808 if (call_expr_nargs (t
) == 2 && trivial_fn_p (fun
))
6810 tree arg
= convert_from_reference (get_nth_callarg (t
, 1));
6811 return cxx_eval_constant_expression (old_call
, arg
, allow_non_constant
,
6812 addr
, non_constant_p
, overflow_p
);
6815 /* If in direct recursive call, optimize definition search. */
6816 if (old_call
!= NULL
&& old_call
->fundef
->decl
== fun
)
6817 new_call
.fundef
= old_call
->fundef
;
6820 new_call
.fundef
= retrieve_constexpr_fundef (fun
);
6821 if (new_call
.fundef
== NULL
|| new_call
.fundef
->body
== NULL
)
6823 if (!allow_non_constant
)
6825 if (DECL_INITIAL (fun
))
6827 /* The definition of fun was somehow unsuitable. */
6828 error_at (loc
, "%qD called in a constant expression", fun
);
6829 explain_invalid_constexpr_fn (fun
);
6832 error_at (loc
, "%qD used before its definition", fun
);
6834 *non_constant_p
= true;
6838 cxx_bind_parameters_in_call (old_call
, t
, &new_call
,
6839 allow_non_constant
, non_constant_p
, overflow_p
);
6840 if (*non_constant_p
)
6843 depth_ok
= push_cx_call_context (t
);
6846 = iterative_hash_template_arg (new_call
.bindings
,
6847 constexpr_fundef_hash (new_call
.fundef
));
6849 /* If we have seen this call before, we are done. */
6850 maybe_initialize_constexpr_call_table ();
6851 slot
= (constexpr_call
**)
6852 htab_find_slot (constexpr_call_table
, &new_call
, INSERT
);
6856 /* We need to keep a pointer to the entry, not just the slot, as the
6857 slot can move in the call to cxx_eval_builtin_function_call. */
6858 *slot
= entry
= ggc_alloc_constexpr_call ();
6861 /* Calls which are in progress have their result set to NULL
6862 so that we can detect circular dependencies. */
6863 else if (entry
->result
== NULL
)
6865 if (!allow_non_constant
)
6866 error ("call has circular dependency");
6867 *non_constant_p
= true;
6868 entry
->result
= result
= error_mark_node
;
6873 if (!allow_non_constant
)
6874 error ("constexpr evaluation depth exceeds maximum of %d (use "
6875 "-fconstexpr-depth= to increase the maximum)",
6876 max_constexpr_depth
);
6877 *non_constant_p
= true;
6878 entry
->result
= result
= error_mark_node
;
6882 result
= entry
->result
;
6883 if (!result
|| result
== error_mark_node
)
6884 result
= (cxx_eval_constant_expression
6885 (&new_call
, new_call
.fundef
->body
,
6886 allow_non_constant
, addr
,
6887 non_constant_p
, overflow_p
));
6888 if (result
== error_mark_node
)
6889 *non_constant_p
= true;
6890 if (*non_constant_p
)
6891 entry
->result
= result
= error_mark_node
;
6894 /* If this was a call to initialize an object, set the type of
6895 the CONSTRUCTOR to the type of that object. */
6896 if (DECL_CONSTRUCTOR_P (fun
))
6898 tree ob_arg
= get_nth_callarg (t
, 0);
6899 STRIP_NOPS (ob_arg
);
6900 gcc_assert (TYPE_PTR_P (TREE_TYPE (ob_arg
))
6901 && CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (ob_arg
))));
6902 result
= adjust_temp_type (TREE_TYPE (TREE_TYPE (ob_arg
)),
6905 entry
->result
= result
;
6909 pop_cx_call_context ();
6910 return unshare_expr (result
);
6913 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
6916 reduced_constant_expression_p (tree t
)
6918 if (TREE_CODE (t
) == PTRMEM_CST
)
6919 /* Even if we can't lower this yet, it's constant. */
6921 /* FIXME are we calling this too much? */
6922 return initializer_constant_valid_p (t
, TREE_TYPE (t
)) != NULL_TREE
;
6925 /* Some expressions may have constant operands but are not constant
6926 themselves, such as 1/0. Call this function (or rather, the macro
6927 following it) to check for that condition.
6929 We only call this in places that require an arithmetic constant, not in
6930 places where we might have a non-constant expression that can be a
6931 component of a constant expression, such as the address of a constexpr
6932 variable that might be dereferenced later. */
6935 verify_constant (tree t
, bool allow_non_constant
, bool *non_constant_p
,
6938 if (!*non_constant_p
&& !reduced_constant_expression_p (t
))
6940 if (!allow_non_constant
)
6941 error ("%q+E is not a constant expression", t
);
6942 *non_constant_p
= true;
6944 if (TREE_OVERFLOW_P (t
))
6946 if (!allow_non_constant
)
6948 permerror (input_location
, "overflow in constant expression");
6949 /* If we're being permissive (and are in an enforcing
6950 context), ignore the overflow. */
6951 if (flag_permissive
)
6952 return *non_constant_p
;
6956 return *non_constant_p
;
6959 /* Subroutine of cxx_eval_constant_expression.
6960 Attempt to reduce the unary expression tree T to a compile time value.
6961 If successful, return the value. Otherwise issue a diagnostic
6962 and return error_mark_node. */
6965 cxx_eval_unary_expression (const constexpr_call
*call
, tree t
,
6966 bool allow_non_constant
, bool addr
,
6967 bool *non_constant_p
, bool *overflow_p
)
6970 tree orig_arg
= TREE_OPERAND (t
, 0);
6971 tree arg
= cxx_eval_constant_expression (call
, orig_arg
, allow_non_constant
,
6972 addr
, non_constant_p
, overflow_p
);
6973 VERIFY_CONSTANT (arg
);
6974 if (arg
== orig_arg
)
6976 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), arg
);
6977 VERIFY_CONSTANT (r
);
6981 /* Subroutine of cxx_eval_constant_expression.
6982 Like cxx_eval_unary_expression, except for binary expressions. */
6985 cxx_eval_binary_expression (const constexpr_call
*call
, tree t
,
6986 bool allow_non_constant
, bool addr
,
6987 bool *non_constant_p
, bool *overflow_p
)
6990 tree orig_lhs
= TREE_OPERAND (t
, 0);
6991 tree orig_rhs
= TREE_OPERAND (t
, 1);
6993 lhs
= cxx_eval_constant_expression (call
, orig_lhs
,
6994 allow_non_constant
, addr
,
6995 non_constant_p
, overflow_p
);
6996 VERIFY_CONSTANT (lhs
);
6997 rhs
= cxx_eval_constant_expression (call
, orig_rhs
,
6998 allow_non_constant
, addr
,
6999 non_constant_p
, overflow_p
);
7000 VERIFY_CONSTANT (rhs
);
7001 if (lhs
== orig_lhs
&& rhs
== orig_rhs
)
7003 r
= fold_build2 (TREE_CODE (t
), TREE_TYPE (t
), lhs
, rhs
);
7004 VERIFY_CONSTANT (r
);
7008 /* Subroutine of cxx_eval_constant_expression.
7009 Attempt to evaluate condition expressions. Dead branches are not
7013 cxx_eval_conditional_expression (const constexpr_call
*call
, tree t
,
7014 bool allow_non_constant
, bool addr
,
7015 bool *non_constant_p
, bool *overflow_p
)
7017 tree val
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 0),
7018 allow_non_constant
, addr
,
7019 non_constant_p
, overflow_p
);
7020 VERIFY_CONSTANT (val
);
7021 /* Don't VERIFY_CONSTANT the other operands. */
7022 if (integer_zerop (val
))
7023 return cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 2),
7024 allow_non_constant
, addr
,
7025 non_constant_p
, overflow_p
);
7026 return cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 1),
7027 allow_non_constant
, addr
,
7028 non_constant_p
, overflow_p
);
7031 /* Subroutine of cxx_eval_constant_expression.
7032 Attempt to reduce a reference to an array slot. */
7035 cxx_eval_array_reference (const constexpr_call
*call
, tree t
,
7036 bool allow_non_constant
, bool addr
,
7037 bool *non_constant_p
, bool *overflow_p
)
7039 tree oldary
= TREE_OPERAND (t
, 0);
7040 tree ary
= cxx_eval_constant_expression (call
, oldary
,
7041 allow_non_constant
, addr
,
7042 non_constant_p
, overflow_p
);
7046 unsigned len
, elem_nchars
= 1;
7047 if (*non_constant_p
)
7049 oldidx
= TREE_OPERAND (t
, 1);
7050 index
= cxx_eval_constant_expression (call
, oldidx
,
7051 allow_non_constant
, false,
7052 non_constant_p
, overflow_p
);
7053 VERIFY_CONSTANT (index
);
7054 if (addr
&& ary
== oldary
&& index
== oldidx
)
7057 return build4 (ARRAY_REF
, TREE_TYPE (t
), ary
, index
, NULL
, NULL
);
7058 elem_type
= TREE_TYPE (TREE_TYPE (ary
));
7059 if (TREE_CODE (ary
) == CONSTRUCTOR
)
7060 len
= CONSTRUCTOR_NELTS (ary
);
7061 else if (TREE_CODE (ary
) == STRING_CST
)
7063 elem_nchars
= (TYPE_PRECISION (elem_type
)
7064 / TYPE_PRECISION (char_type_node
));
7065 len
= (unsigned) TREE_STRING_LENGTH (ary
) / elem_nchars
;
7069 /* We can't do anything with other tree codes, so use
7070 VERIFY_CONSTANT to complain and fail. */
7071 VERIFY_CONSTANT (ary
);
7074 if (compare_tree_int (index
, len
) >= 0)
7076 if (tree_int_cst_lt (index
, array_type_nelts_top (TREE_TYPE (ary
))))
7078 /* If it's within the array bounds but doesn't have an explicit
7079 initializer, it's value-initialized. */
7080 tree val
= build_value_init (elem_type
, tf_warning_or_error
);
7081 return cxx_eval_constant_expression (call
, val
,
7082 allow_non_constant
, addr
,
7083 non_constant_p
, overflow_p
);
7086 if (!allow_non_constant
)
7087 error ("array subscript out of bound");
7088 *non_constant_p
= true;
7091 else if (tree_int_cst_lt (index
, integer_zero_node
))
7093 if (!allow_non_constant
)
7094 error ("negative array subscript");
7095 *non_constant_p
= true;
7098 i
= tree_low_cst (index
, 0);
7099 if (TREE_CODE (ary
) == CONSTRUCTOR
)
7100 return (*CONSTRUCTOR_ELTS (ary
))[i
].value
;
7101 else if (elem_nchars
== 1)
7102 return build_int_cst (cv_unqualified (TREE_TYPE (TREE_TYPE (ary
))),
7103 TREE_STRING_POINTER (ary
)[i
]);
7106 tree type
= cv_unqualified (TREE_TYPE (TREE_TYPE (ary
)));
7107 return native_interpret_expr (type
, (const unsigned char *)
7108 TREE_STRING_POINTER (ary
)
7109 + i
* elem_nchars
, elem_nchars
);
7111 /* Don't VERIFY_CONSTANT here. */
7114 /* Subroutine of cxx_eval_constant_expression.
7115 Attempt to reduce a field access of a value of class type. */
7118 cxx_eval_component_reference (const constexpr_call
*call
, tree t
,
7119 bool allow_non_constant
, bool addr
,
7120 bool *non_constant_p
, bool *overflow_p
)
7122 unsigned HOST_WIDE_INT i
;
7125 tree part
= TREE_OPERAND (t
, 1);
7126 tree orig_whole
= TREE_OPERAND (t
, 0);
7127 tree whole
= cxx_eval_constant_expression (call
, orig_whole
,
7128 allow_non_constant
, addr
,
7129 non_constant_p
, overflow_p
);
7130 if (whole
== orig_whole
)
7133 return fold_build3 (COMPONENT_REF
, TREE_TYPE (t
),
7134 whole
, part
, NULL_TREE
);
7135 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
7137 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
7139 if (!allow_non_constant
)
7140 error ("%qE is not a constant expression", orig_whole
);
7141 *non_constant_p
= true;
7143 if (DECL_MUTABLE_P (part
))
7145 if (!allow_non_constant
)
7146 error ("mutable %qD is not usable in a constant expression", part
);
7147 *non_constant_p
= true;
7149 if (*non_constant_p
)
7151 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
7156 if (TREE_CODE (TREE_TYPE (whole
)) == UNION_TYPE
7157 && CONSTRUCTOR_NELTS (whole
) > 0)
7159 /* DR 1188 says we don't have to deal with this. */
7160 if (!allow_non_constant
)
7161 error ("accessing %qD member instead of initialized %qD member in "
7162 "constant expression", part
, CONSTRUCTOR_ELT (whole
, 0)->index
);
7163 *non_constant_p
= true;
7167 /* If there's no explicit init for this field, it's value-initialized. */
7168 value
= build_value_init (TREE_TYPE (t
), tf_warning_or_error
);
7169 return cxx_eval_constant_expression (call
, value
,
7170 allow_non_constant
, addr
,
7171 non_constant_p
, overflow_p
);
7174 /* Subroutine of cxx_eval_constant_expression.
7175 Attempt to reduce a field access of a value of class type that is
7176 expressed as a BIT_FIELD_REF. */
7179 cxx_eval_bit_field_ref (const constexpr_call
*call
, tree t
,
7180 bool allow_non_constant
, bool addr
,
7181 bool *non_constant_p
, bool *overflow_p
)
7183 tree orig_whole
= TREE_OPERAND (t
, 0);
7184 tree retval
, fldval
, utype
, mask
;
7185 bool fld_seen
= false;
7186 HOST_WIDE_INT istart
, isize
;
7187 tree whole
= cxx_eval_constant_expression (call
, orig_whole
,
7188 allow_non_constant
, addr
,
7189 non_constant_p
, overflow_p
);
7190 tree start
, field
, value
;
7191 unsigned HOST_WIDE_INT i
;
7193 if (whole
== orig_whole
)
7195 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
7197 if (!*non_constant_p
7198 && TREE_CODE (whole
) != VECTOR_CST
7199 && TREE_CODE (whole
) != CONSTRUCTOR
)
7201 if (!allow_non_constant
)
7202 error ("%qE is not a constant expression", orig_whole
);
7203 *non_constant_p
= true;
7205 if (*non_constant_p
)
7208 if (TREE_CODE (whole
) == VECTOR_CST
)
7209 return fold_ternary (BIT_FIELD_REF
, TREE_TYPE (t
), whole
,
7210 TREE_OPERAND (t
, 1), TREE_OPERAND (t
, 2));
7212 start
= TREE_OPERAND (t
, 2);
7213 istart
= tree_low_cst (start
, 0);
7214 isize
= tree_low_cst (TREE_OPERAND (t
, 1), 0);
7215 utype
= TREE_TYPE (t
);
7216 if (!TYPE_UNSIGNED (utype
))
7217 utype
= build_nonstandard_integer_type (TYPE_PRECISION (utype
), 1);
7218 retval
= build_int_cst (utype
, 0);
7219 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
7221 tree bitpos
= bit_position (field
);
7222 if (bitpos
== start
&& DECL_SIZE (field
) == TREE_OPERAND (t
, 1))
7224 if (TREE_CODE (TREE_TYPE (field
)) == INTEGER_TYPE
7225 && TREE_CODE (value
) == INTEGER_CST
7226 && host_integerp (bitpos
, 0)
7227 && host_integerp (DECL_SIZE (field
), 0))
7229 HOST_WIDE_INT bit
= tree_low_cst (bitpos
, 0);
7230 HOST_WIDE_INT sz
= tree_low_cst (DECL_SIZE (field
), 0);
7231 HOST_WIDE_INT shift
;
7232 if (bit
>= istart
&& bit
+ sz
<= istart
+ isize
)
7234 fldval
= fold_convert (utype
, value
);
7235 mask
= build_int_cst_type (utype
, -1);
7236 mask
= fold_build2 (LSHIFT_EXPR
, utype
, mask
,
7237 size_int (TYPE_PRECISION (utype
) - sz
));
7238 mask
= fold_build2 (RSHIFT_EXPR
, utype
, mask
,
7239 size_int (TYPE_PRECISION (utype
) - sz
));
7240 fldval
= fold_build2 (BIT_AND_EXPR
, utype
, fldval
, mask
);
7241 shift
= bit
- istart
;
7242 if (BYTES_BIG_ENDIAN
)
7243 shift
= TYPE_PRECISION (utype
) - shift
- sz
;
7244 fldval
= fold_build2 (LSHIFT_EXPR
, utype
, fldval
,
7246 retval
= fold_build2 (BIT_IOR_EXPR
, utype
, retval
, fldval
);
7252 return fold_convert (TREE_TYPE (t
), retval
);
7254 return error_mark_node
;
7257 /* Subroutine of cxx_eval_constant_expression.
7258 Evaluate a short-circuited logical expression T in the context
7259 of a given constexpr CALL. BAILOUT_VALUE is the value for
7260 early return. CONTINUE_VALUE is used here purely for
7261 sanity check purposes. */
7264 cxx_eval_logical_expression (const constexpr_call
*call
, tree t
,
7265 tree bailout_value
, tree continue_value
,
7266 bool allow_non_constant
, bool addr
,
7267 bool *non_constant_p
, bool *overflow_p
)
7270 tree lhs
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 0),
7271 allow_non_constant
, addr
,
7272 non_constant_p
, overflow_p
);
7273 VERIFY_CONSTANT (lhs
);
7274 if (tree_int_cst_equal (lhs
, bailout_value
))
7276 gcc_assert (tree_int_cst_equal (lhs
, continue_value
));
7277 r
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 1),
7278 allow_non_constant
, addr
, non_constant_p
, overflow_p
);
7279 VERIFY_CONSTANT (r
);
7283 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
7284 CONSTRUCTOR elements to initialize (part of) an object containing that
7285 field. Return a pointer to the constructor_elt corresponding to the
7286 initialization of the field. */
7288 static constructor_elt
*
7289 base_field_constructor_elt (vec
<constructor_elt
, va_gc
> *v
, tree ref
)
7291 tree aggr
= TREE_OPERAND (ref
, 0);
7292 tree field
= TREE_OPERAND (ref
, 1);
7294 constructor_elt
*ce
;
7296 gcc_assert (TREE_CODE (ref
) == COMPONENT_REF
);
7298 if (TREE_CODE (aggr
) == COMPONENT_REF
)
7300 constructor_elt
*base_ce
7301 = base_field_constructor_elt (v
, aggr
);
7302 v
= CONSTRUCTOR_ELTS (base_ce
->value
);
7305 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
7306 if (ce
->index
== field
)
7313 /* Subroutine of cxx_eval_constant_expression.
7314 The expression tree T denotes a C-style array or a C-style
7315 aggregate. Reduce it to a constant expression. */
7318 cxx_eval_bare_aggregate (const constexpr_call
*call
, tree t
,
7319 bool allow_non_constant
, bool addr
,
7320 bool *non_constant_p
, bool *overflow_p
)
7322 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
7323 vec
<constructor_elt
, va_gc
> *n
;
7324 vec_alloc (n
, vec_safe_length (v
));
7325 constructor_elt
*ce
;
7327 bool changed
= false;
7328 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t
));
7329 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
7331 tree elt
= cxx_eval_constant_expression (call
, ce
->value
,
7332 allow_non_constant
, addr
,
7333 non_constant_p
, overflow_p
);
7334 /* Don't VERIFY_CONSTANT here. */
7335 if (allow_non_constant
&& *non_constant_p
)
7337 if (elt
!= ce
->value
)
7339 if (ce
->index
&& TREE_CODE (ce
->index
) == COMPONENT_REF
)
7341 /* This is an initialization of a vfield inside a base
7342 subaggregate that we already initialized; push this
7343 initialization into the previous initialization. */
7344 constructor_elt
*inner
= base_field_constructor_elt (n
, ce
->index
);
7347 else if (ce
->index
&& TREE_CODE (ce
->index
) == NOP_EXPR
)
7349 /* This is an initializer for an empty base; now that we've
7350 checked that it's constant, we can ignore it. */
7351 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (ce
->index
))));
7354 CONSTRUCTOR_APPEND_ELT (n
, ce
->index
, elt
);
7356 if (*non_constant_p
|| !changed
)
7362 t
= build_constructor (TREE_TYPE (t
), n
);
7363 TREE_CONSTANT (t
) = true;
7364 if (TREE_CODE (TREE_TYPE (t
)) == VECTOR_TYPE
)
7369 /* Subroutine of cxx_eval_constant_expression.
7370 The expression tree T is a VEC_INIT_EXPR which denotes the desired
7371 initialization of a non-static data member of array type. Reduce it to a
7374 Note that apart from value-initialization (when VALUE_INIT is true),
7375 this is only intended to support value-initialization and the
7376 initializations done by defaulted constructors for classes with
7377 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
7378 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
7379 for the copy/move constructor. */
7382 cxx_eval_vec_init_1 (const constexpr_call
*call
, tree atype
, tree init
,
7383 bool value_init
, bool allow_non_constant
, bool addr
,
7384 bool *non_constant_p
, bool *overflow_p
)
7386 tree elttype
= TREE_TYPE (atype
);
7387 int max
= tree_low_cst (array_type_nelts (atype
), 0);
7388 vec
<constructor_elt
, va_gc
> *n
;
7389 vec_alloc (n
, max
+ 1);
7390 bool pre_init
= false;
7393 /* For the default constructor, build up a call to the default
7394 constructor of the element type. We only need to handle class types
7395 here, as for a constructor to be constexpr, all members must be
7396 initialized, which for a defaulted default constructor means they must
7397 be of a class type with a constexpr default constructor. */
7398 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
7399 /* We only do this at the lowest level. */;
7400 else if (value_init
)
7402 init
= build_value_init (elttype
, tf_warning_or_error
);
7403 init
= cxx_eval_constant_expression
7404 (call
, init
, allow_non_constant
, addr
, non_constant_p
, overflow_p
);
7409 vec
<tree
, va_gc
> *argvec
= make_tree_vector ();
7410 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
7411 &argvec
, elttype
, LOOKUP_NORMAL
,
7412 tf_warning_or_error
);
7413 release_tree_vector (argvec
);
7414 init
= cxx_eval_constant_expression (call
, init
, allow_non_constant
,
7415 addr
, non_constant_p
, overflow_p
);
7419 if (*non_constant_p
&& !allow_non_constant
)
7422 for (i
= 0; i
<= max
; ++i
)
7424 tree idx
= build_int_cst (size_type_node
, i
);
7426 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
7428 /* A multidimensional array; recurse. */
7429 if (value_init
|| init
== NULL_TREE
)
7430 eltinit
= NULL_TREE
;
7432 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
7433 tf_warning_or_error
);
7434 eltinit
= cxx_eval_vec_init_1 (call
, elttype
, eltinit
, value_init
,
7435 allow_non_constant
, addr
,
7436 non_constant_p
, overflow_p
);
7440 /* Initializing an element using value or default initialization
7441 we just pre-built above. */
7445 eltinit
= unshare_expr (init
);
7449 /* Copying an element. */
7450 vec
<tree
, va_gc
> *argvec
;
7451 gcc_assert (same_type_ignoring_top_level_qualifiers_p
7452 (atype
, TREE_TYPE (init
)));
7453 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
7454 tf_warning_or_error
);
7455 if (!real_lvalue_p (init
))
7456 eltinit
= move (eltinit
);
7457 argvec
= make_tree_vector ();
7458 argvec
->quick_push (eltinit
);
7459 eltinit
= (build_special_member_call
7460 (NULL_TREE
, complete_ctor_identifier
, &argvec
,
7461 elttype
, LOOKUP_NORMAL
, tf_warning_or_error
));
7462 release_tree_vector (argvec
);
7463 eltinit
= cxx_eval_constant_expression
7464 (call
, eltinit
, allow_non_constant
, addr
, non_constant_p
, overflow_p
);
7466 if (*non_constant_p
&& !allow_non_constant
)
7468 CONSTRUCTOR_APPEND_ELT (n
, idx
, eltinit
);
7471 if (!*non_constant_p
)
7473 init
= build_constructor (atype
, n
);
7474 TREE_CONSTANT (init
) = true;
7484 cxx_eval_vec_init (const constexpr_call
*call
, tree t
,
7485 bool allow_non_constant
, bool addr
,
7486 bool *non_constant_p
, bool *overflow_p
)
7488 tree atype
= TREE_TYPE (t
);
7489 tree init
= VEC_INIT_EXPR_INIT (t
);
7490 tree r
= cxx_eval_vec_init_1 (call
, atype
, init
,
7491 VEC_INIT_EXPR_VALUE_INIT (t
),
7492 allow_non_constant
, addr
, non_constant_p
, overflow_p
);
7493 if (*non_constant_p
)
7499 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
7500 match. We want to be less strict for simple *& folding; if we have a
7501 non-const temporary that we access through a const pointer, that should
7502 work. We handle this here rather than change fold_indirect_ref_1
7503 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
7504 don't really make sense outside of constant expression evaluation. Also
7505 we want to allow folding to COMPONENT_REF, which could cause trouble
7506 with TBAA in fold_indirect_ref_1.
7508 Try to keep this function synced with fold_indirect_ref_1. */
7511 cxx_fold_indirect_ref (location_t loc
, tree type
, tree op0
, bool *empty_base
)
7517 subtype
= TREE_TYPE (sub
);
7518 if (!POINTER_TYPE_P (subtype
))
7521 if (TREE_CODE (sub
) == ADDR_EXPR
)
7523 tree op
= TREE_OPERAND (sub
, 0);
7524 tree optype
= TREE_TYPE (op
);
7526 /* *&CONST_DECL -> to the value of the const decl. */
7527 if (TREE_CODE (op
) == CONST_DECL
)
7528 return DECL_INITIAL (op
);
7529 /* *&p => p; make sure to handle *&"str"[cst] here. */
7530 if (same_type_ignoring_top_level_qualifiers_p (optype
, type
))
7532 tree fop
= fold_read_from_constant_string (op
);
7538 /* *(foo *)&fooarray => fooarray[0] */
7539 else if (TREE_CODE (optype
) == ARRAY_TYPE
7540 && (same_type_ignoring_top_level_qualifiers_p
7541 (type
, TREE_TYPE (optype
))))
7543 tree type_domain
= TYPE_DOMAIN (optype
);
7544 tree min_val
= size_zero_node
;
7545 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
7546 min_val
= TYPE_MIN_VALUE (type_domain
);
7547 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
7548 NULL_TREE
, NULL_TREE
);
7550 /* *(foo *)&complexfoo => __real__ complexfoo */
7551 else if (TREE_CODE (optype
) == COMPLEX_TYPE
7552 && (same_type_ignoring_top_level_qualifiers_p
7553 (type
, TREE_TYPE (optype
))))
7554 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
7555 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
7556 else if (TREE_CODE (optype
) == VECTOR_TYPE
7557 && (same_type_ignoring_top_level_qualifiers_p
7558 (type
, TREE_TYPE (optype
))))
7560 tree part_width
= TYPE_SIZE (type
);
7561 tree index
= bitsize_int (0);
7562 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
, index
);
7564 /* Also handle conversion to an empty base class, which
7565 is represented with a NOP_EXPR. */
7566 else if (is_empty_class (type
)
7567 && CLASS_TYPE_P (optype
)
7568 && DERIVED_FROM_P (type
, optype
))
7573 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
7574 else if (RECORD_OR_UNION_TYPE_P (optype
))
7576 tree field
= TYPE_FIELDS (optype
);
7577 for (; field
; field
= DECL_CHAIN (field
))
7578 if (TREE_CODE (field
) == FIELD_DECL
7579 && integer_zerop (byte_position (field
))
7580 && (same_type_ignoring_top_level_qualifiers_p
7581 (TREE_TYPE (field
), type
)))
7583 return fold_build3 (COMPONENT_REF
, type
, op
, field
, NULL_TREE
);
7588 else if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
7589 && TREE_CODE (TREE_OPERAND (sub
, 1)) == INTEGER_CST
)
7591 tree op00
= TREE_OPERAND (sub
, 0);
7592 tree op01
= TREE_OPERAND (sub
, 1);
7595 if (TREE_CODE (op00
) == ADDR_EXPR
)
7598 op00
= TREE_OPERAND (op00
, 0);
7599 op00type
= TREE_TYPE (op00
);
7601 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
7602 if (TREE_CODE (op00type
) == VECTOR_TYPE
7603 && (same_type_ignoring_top_level_qualifiers_p
7604 (type
, TREE_TYPE (op00type
))))
7606 HOST_WIDE_INT offset
= tree_low_cst (op01
, 0);
7607 tree part_width
= TYPE_SIZE (type
);
7608 unsigned HOST_WIDE_INT part_widthi
= tree_low_cst (part_width
, 0)/BITS_PER_UNIT
;
7609 unsigned HOST_WIDE_INT indexi
= offset
* BITS_PER_UNIT
;
7610 tree index
= bitsize_int (indexi
);
7612 if (offset
/part_widthi
<= TYPE_VECTOR_SUBPARTS (op00type
))
7613 return fold_build3_loc (loc
,
7614 BIT_FIELD_REF
, type
, op00
,
7618 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
7619 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
7620 && (same_type_ignoring_top_level_qualifiers_p
7621 (type
, TREE_TYPE (op00type
))))
7623 tree size
= TYPE_SIZE_UNIT (type
);
7624 if (tree_int_cst_equal (size
, op01
))
7625 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
7627 /* ((foo *)&fooarray)[1] => fooarray[1] */
7628 else if (TREE_CODE (op00type
) == ARRAY_TYPE
7629 && (same_type_ignoring_top_level_qualifiers_p
7630 (type
, TREE_TYPE (op00type
))))
7632 tree type_domain
= TYPE_DOMAIN (op00type
);
7633 tree min_val
= size_zero_node
;
7634 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
7635 min_val
= TYPE_MIN_VALUE (type_domain
);
7636 op01
= size_binop_loc (loc
, EXACT_DIV_EXPR
, op01
,
7637 TYPE_SIZE_UNIT (type
));
7638 op01
= size_binop_loc (loc
, PLUS_EXPR
, op01
, min_val
);
7639 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
7640 NULL_TREE
, NULL_TREE
);
7642 /* Also handle conversion to an empty base class, which
7643 is represented with a NOP_EXPR. */
7644 else if (is_empty_class (type
)
7645 && CLASS_TYPE_P (op00type
)
7646 && DERIVED_FROM_P (type
, op00type
))
7651 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
7652 else if (RECORD_OR_UNION_TYPE_P (op00type
))
7654 tree field
= TYPE_FIELDS (op00type
);
7655 for (; field
; field
= DECL_CHAIN (field
))
7656 if (TREE_CODE (field
) == FIELD_DECL
7657 && tree_int_cst_equal (byte_position (field
), op01
)
7658 && (same_type_ignoring_top_level_qualifiers_p
7659 (TREE_TYPE (field
), type
)))
7661 return fold_build3 (COMPONENT_REF
, type
, op00
,
7668 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
7669 else if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
7670 && (same_type_ignoring_top_level_qualifiers_p
7671 (type
, TREE_TYPE (TREE_TYPE (subtype
)))))
7674 tree min_val
= size_zero_node
;
7675 tree newsub
= cxx_fold_indirect_ref (loc
, TREE_TYPE (subtype
), sub
, NULL
);
7679 sub
= build1_loc (loc
, INDIRECT_REF
, TREE_TYPE (subtype
), sub
);
7680 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
7681 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
7682 min_val
= TYPE_MIN_VALUE (type_domain
);
7683 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
7691 cxx_eval_indirect_ref (const constexpr_call
*call
, tree t
,
7692 bool allow_non_constant
, bool addr
,
7693 bool *non_constant_p
, bool *overflow_p
)
7695 tree orig_op0
= TREE_OPERAND (t
, 0);
7696 tree op0
= cxx_eval_constant_expression (call
, orig_op0
, allow_non_constant
,
7697 /*addr*/false, non_constant_p
, overflow_p
);
7698 bool empty_base
= false;
7701 /* Don't VERIFY_CONSTANT here. */
7702 if (*non_constant_p
)
7705 r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), op0
,
7709 r
= cxx_eval_constant_expression (call
, r
, allow_non_constant
,
7710 addr
, non_constant_p
, overflow_p
);
7715 if (TREE_CODE (sub
) == ADDR_EXPR
)
7717 /* We couldn't fold to a constant value. Make sure it's not
7718 something we should have been able to fold. */
7719 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
7720 (TREE_TYPE (TREE_TYPE (sub
)), TREE_TYPE (t
)));
7721 /* DR 1188 says we don't have to deal with this. */
7722 if (!allow_non_constant
)
7723 error ("accessing value of %qE through a %qT glvalue in a "
7724 "constant expression", build_fold_indirect_ref (sub
),
7726 *non_constant_p
= true;
7731 /* If we're pulling out the value of an empty base, make sure
7732 that the whole object is constant and then return an empty
7736 VERIFY_CONSTANT (r
);
7737 r
= build_constructor (TREE_TYPE (t
), NULL
);
7738 TREE_CONSTANT (r
) = true;
7743 if (addr
&& op0
!= orig_op0
)
7744 return build1 (INDIRECT_REF
, TREE_TYPE (t
), op0
);
7746 VERIFY_CONSTANT (t
);
7752 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
7753 Shared between potential_constant_expression and
7754 cxx_eval_constant_expression. */
7757 non_const_var_error (tree r
)
7759 tree type
= TREE_TYPE (r
);
7760 error ("the value of %qD is not usable in a constant "
7762 /* Avoid error cascade. */
7763 if (DECL_INITIAL (r
) == error_mark_node
)
7765 if (DECL_DECLARED_CONSTEXPR_P (r
))
7766 inform (DECL_SOURCE_LOCATION (r
),
7767 "%qD used in its own initializer", r
);
7768 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
7770 if (!CP_TYPE_CONST_P (type
))
7771 inform (DECL_SOURCE_LOCATION (r
),
7772 "%q#D is not const", r
);
7773 else if (CP_TYPE_VOLATILE_P (type
))
7774 inform (DECL_SOURCE_LOCATION (r
),
7775 "%q#D is volatile", r
);
7776 else if (!DECL_INITIAL (r
)
7777 || !TREE_CONSTANT (DECL_INITIAL (r
)))
7778 inform (DECL_SOURCE_LOCATION (r
),
7779 "%qD was not initialized with a constant "
7786 if (cxx_dialect
>= cxx11
&& !DECL_DECLARED_CONSTEXPR_P (r
))
7787 inform (DECL_SOURCE_LOCATION (r
),
7788 "%qD was not declared %<constexpr%>", r
);
7790 inform (DECL_SOURCE_LOCATION (r
),
7791 "%qD does not have integral or enumeration type",
7796 /* Subroutine of cxx_eval_constant_expression.
7797 Like cxx_eval_unary_expression, except for trinary expressions. */
7800 cxx_eval_trinary_expression (const constexpr_call
*call
, tree t
,
7801 bool allow_non_constant
, bool addr
,
7802 bool *non_constant_p
, bool *overflow_p
)
7808 for (i
= 0; i
< 3; i
++)
7810 args
[i
] = cxx_eval_constant_expression (call
, TREE_OPERAND (t
, i
),
7811 allow_non_constant
, addr
,
7812 non_constant_p
, overflow_p
);
7813 VERIFY_CONSTANT (args
[i
]);
7816 val
= fold_ternary_loc (EXPR_LOCATION (t
), TREE_CODE (t
), TREE_TYPE (t
),
7817 args
[0], args
[1], args
[2]);
7818 if (val
== NULL_TREE
)
7820 VERIFY_CONSTANT (val
);
7824 /* Attempt to reduce the expression T to a constant value.
7825 On failure, issue diagnostic and return error_mark_node. */
7826 /* FIXME unify with c_fully_fold */
7829 cxx_eval_constant_expression (const constexpr_call
*call
, tree t
,
7830 bool allow_non_constant
, bool addr
,
7831 bool *non_constant_p
, bool *overflow_p
)
7835 if (t
== error_mark_node
)
7837 *non_constant_p
= true;
7840 if (CONSTANT_CLASS_P (t
))
7842 if (TREE_CODE (t
) == PTRMEM_CST
)
7843 t
= cplus_expand_constant (t
);
7844 else if (TREE_OVERFLOW (t
) && (!flag_permissive
|| allow_non_constant
))
7848 if (TREE_CODE (t
) != NOP_EXPR
7849 && reduced_constant_expression_p (t
))
7852 switch (TREE_CODE (t
))
7857 /* else fall through. */
7859 r
= integral_constant_value (t
);
7860 if (TREE_CODE (r
) == TARGET_EXPR
7861 && TREE_CODE (TARGET_EXPR_INITIAL (r
)) == CONSTRUCTOR
)
7862 r
= TARGET_EXPR_INITIAL (r
);
7865 if (!allow_non_constant
)
7866 non_const_var_error (r
);
7867 *non_constant_p
= true;
7877 if (call
&& DECL_CONTEXT (t
) == call
->fundef
->decl
)
7879 if (DECL_ARTIFICIAL (t
) && DECL_CONSTRUCTOR_P (DECL_CONTEXT (t
)))
7881 if (!allow_non_constant
)
7882 sorry ("use of the value of the object being constructed "
7883 "in a constant expression");
7884 *non_constant_p
= true;
7887 r
= lookup_parameter_binding (call
, t
);
7890 /* Defer in case this is only used for its type. */;
7893 if (!allow_non_constant
)
7894 error ("%qE is not a constant expression", t
);
7895 *non_constant_p
= true;
7900 case AGGR_INIT_EXPR
:
7901 r
= cxx_eval_call_expression (call
, t
, allow_non_constant
, addr
,
7902 non_constant_p
, overflow_p
);
7906 if (!literal_type_p (TREE_TYPE (t
)))
7908 if (!allow_non_constant
)
7910 error ("temporary of non-literal type %qT in a "
7911 "constant expression", TREE_TYPE (t
));
7912 explain_non_literal_class (TREE_TYPE (t
));
7914 *non_constant_p
= true;
7917 /* else fall through. */
7919 /* Pass false for 'addr' because these codes indicate
7920 initialization of a temporary. */
7921 r
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 1),
7922 allow_non_constant
, false,
7923 non_constant_p
, overflow_p
);
7924 if (!*non_constant_p
)
7925 /* Adjust the type of the result to the type of the temporary. */
7926 r
= adjust_temp_type (TREE_TYPE (t
), r
);
7930 r
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 1),
7931 allow_non_constant
, addr
,
7932 non_constant_p
, overflow_p
);
7936 case NON_LVALUE_EXPR
:
7937 case TRY_CATCH_EXPR
:
7938 case CLEANUP_POINT_EXPR
:
7939 case MUST_NOT_THROW_EXPR
:
7941 r
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 0),
7942 allow_non_constant
, addr
,
7943 non_constant_p
, overflow_p
);
7946 /* These differ from cxx_eval_unary_expression in that this doesn't
7947 check for a constant operand or result; an address can be
7948 constant without its operand being, and vice versa. */
7950 r
= cxx_eval_indirect_ref (call
, t
, allow_non_constant
, addr
,
7951 non_constant_p
, overflow_p
);
7956 tree oldop
= TREE_OPERAND (t
, 0);
7957 tree op
= cxx_eval_constant_expression (call
, oldop
,
7960 non_constant_p
, overflow_p
);
7961 /* Don't VERIFY_CONSTANT here. */
7962 if (*non_constant_p
)
7964 /* This function does more aggressive folding than fold itself. */
7965 r
= build_fold_addr_expr_with_type (op
, TREE_TYPE (t
));
7966 if (TREE_CODE (r
) == ADDR_EXPR
&& TREE_OPERAND (r
, 0) == oldop
)
7974 case FIX_TRUNC_EXPR
:
7979 case TRUTH_NOT_EXPR
:
7980 case FIXED_CONVERT_EXPR
:
7981 r
= cxx_eval_unary_expression (call
, t
, allow_non_constant
, addr
,
7982 non_constant_p
, overflow_p
);
7986 if (SIZEOF_EXPR_TYPE_P (t
))
7987 r
= cxx_sizeof_or_alignof_type (TREE_TYPE (TREE_OPERAND (t
, 0)),
7988 SIZEOF_EXPR
, false);
7989 else if (TYPE_P (TREE_OPERAND (t
, 0)))
7990 r
= cxx_sizeof_or_alignof_type (TREE_OPERAND (t
, 0), SIZEOF_EXPR
,
7993 r
= cxx_sizeof_or_alignof_expr (TREE_OPERAND (t
, 0), SIZEOF_EXPR
,
7995 if (r
== error_mark_node
)
7997 VERIFY_CONSTANT (r
);
8002 /* check_return_expr sometimes wraps a TARGET_EXPR in a
8003 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
8004 introduced by build_call_a. */
8005 tree op0
= TREE_OPERAND (t
, 0);
8006 tree op1
= TREE_OPERAND (t
, 1);
8008 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
8009 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
8010 r
= cxx_eval_constant_expression (call
, op0
, allow_non_constant
,
8011 addr
, non_constant_p
, overflow_p
);
8014 /* Check that the LHS is constant and then discard it. */
8015 cxx_eval_constant_expression (call
, op0
, allow_non_constant
,
8016 false, non_constant_p
, overflow_p
);
8017 op1
= TREE_OPERAND (t
, 1);
8018 r
= cxx_eval_constant_expression (call
, op1
, allow_non_constant
,
8019 addr
, non_constant_p
, overflow_p
);
8024 case POINTER_PLUS_EXPR
:
8028 case TRUNC_DIV_EXPR
:
8030 case FLOOR_DIV_EXPR
:
8031 case ROUND_DIV_EXPR
:
8032 case TRUNC_MOD_EXPR
:
8034 case ROUND_MOD_EXPR
:
8036 case EXACT_DIV_EXPR
:
8046 case TRUTH_XOR_EXPR
:
8053 case UNORDERED_EXPR
:
8063 r
= cxx_eval_binary_expression (call
, t
, allow_non_constant
, addr
,
8064 non_constant_p
, overflow_p
);
8067 /* fold can introduce non-IF versions of these; still treat them as
8068 short-circuiting. */
8069 case TRUTH_AND_EXPR
:
8070 case TRUTH_ANDIF_EXPR
:
8071 r
= cxx_eval_logical_expression (call
, t
, boolean_false_node
,
8073 allow_non_constant
, addr
,
8074 non_constant_p
, overflow_p
);
8078 case TRUTH_ORIF_EXPR
:
8079 r
= cxx_eval_logical_expression (call
, t
, boolean_true_node
,
8081 allow_non_constant
, addr
,
8082 non_constant_p
, overflow_p
);
8086 r
= cxx_eval_array_reference (call
, t
, allow_non_constant
, addr
,
8087 non_constant_p
, overflow_p
);
8091 r
= cxx_eval_component_reference (call
, t
, allow_non_constant
, addr
,
8092 non_constant_p
, overflow_p
);
8096 r
= cxx_eval_bit_field_ref (call
, t
, allow_non_constant
, addr
,
8097 non_constant_p
, overflow_p
);
8102 r
= cxx_eval_conditional_expression (call
, t
, allow_non_constant
, addr
,
8103 non_constant_p
, overflow_p
);
8107 r
= cxx_eval_bare_aggregate (call
, t
, allow_non_constant
, addr
,
8108 non_constant_p
, overflow_p
);
8112 /* We can get this in a defaulted constructor for a class with a
8113 non-static data member of array type. Either the initializer will
8114 be NULL, meaning default-initialization, or it will be an lvalue
8115 or xvalue of the same type, meaning direct-initialization from the
8116 corresponding member. */
8117 r
= cxx_eval_vec_init (call
, t
, allow_non_constant
, addr
,
8118 non_constant_p
, overflow_p
);
8123 r
= cxx_eval_trinary_expression (call
, t
, allow_non_constant
, addr
,
8124 non_constant_p
, overflow_p
);
8128 case VIEW_CONVERT_EXPR
:
8131 tree oldop
= TREE_OPERAND (t
, 0);
8132 tree op
= cxx_eval_constant_expression (call
, oldop
,
8133 allow_non_constant
, addr
,
8134 non_constant_p
, overflow_p
);
8135 if (*non_constant_p
)
8137 if (POINTER_TYPE_P (TREE_TYPE (t
))
8138 && TREE_CODE (op
) == INTEGER_CST
8139 && !integer_zerop (op
))
8141 if (!allow_non_constant
)
8142 error_at (EXPR_LOC_OR_HERE (t
),
8143 "reinterpret_cast from integer to pointer");
8144 *non_constant_p
= true;
8148 /* We didn't fold at the top so we could check for ptr-int
8151 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), op
);
8152 /* Conversion of an out-of-range value has implementation-defined
8153 behavior; the language considers it different from arithmetic
8154 overflow, which is undefined. */
8155 if (TREE_OVERFLOW_P (r
) && !TREE_OVERFLOW_P (op
))
8156 TREE_OVERFLOW (r
) = false;
8160 case EMPTY_CLASS_EXPR
:
8161 /* This is good enough for a function argument that might not get
8162 used, and they can't do anything with it, so just return it. */
8166 case PREINCREMENT_EXPR
:
8167 case POSTINCREMENT_EXPR
:
8168 case PREDECREMENT_EXPR
:
8169 case POSTDECREMENT_EXPR
:
8173 case VEC_DELETE_EXPR
:
8177 /* GCC internal stuff. */
8180 case WITH_CLEANUP_EXPR
:
8181 case STATEMENT_LIST
:
8183 case NON_DEPENDENT_EXPR
:
8187 if (!allow_non_constant
)
8188 error_at (EXPR_LOC_OR_HERE (t
),
8189 "expression %qE is not a constant-expression", t
);
8190 *non_constant_p
= true;
8194 internal_error ("unexpected expression %qE of kind %s", t
,
8195 tree_code_name
[TREE_CODE (t
)]);
8196 *non_constant_p
= true;
8200 if (r
== error_mark_node
)
8201 *non_constant_p
= true;
8203 if (*non_constant_p
)
8210 cxx_eval_outermost_constant_expr (tree t
, bool allow_non_constant
)
8212 bool non_constant_p
= false;
8213 bool overflow_p
= false;
8214 tree r
= cxx_eval_constant_expression (NULL
, t
, allow_non_constant
,
8215 false, &non_constant_p
, &overflow_p
);
8217 verify_constant (r
, allow_non_constant
, &non_constant_p
, &overflow_p
);
8219 if (TREE_CODE (t
) != CONSTRUCTOR
8220 && cp_has_mutable_p (TREE_TYPE (t
)))
8222 /* We allow a mutable type if the original expression was a
8223 CONSTRUCTOR so that we can do aggregate initialization of
8224 constexpr variables. */
8225 if (!allow_non_constant
)
8226 error ("%qT cannot be the type of a complete constant expression "
8227 "because it has mutable sub-objects", TREE_TYPE (t
));
8228 non_constant_p
= true;
8231 /* Technically we should check this for all subexpressions, but that
8232 runs into problems with our internal representation of pointer
8233 subtraction and the 5.19 rules are still in flux. */
8234 if (CONVERT_EXPR_CODE_P (TREE_CODE (r
))
8235 && ARITHMETIC_TYPE_P (TREE_TYPE (r
))
8236 && TREE_CODE (TREE_OPERAND (r
, 0)) == ADDR_EXPR
)
8238 if (!allow_non_constant
)
8239 error ("conversion from pointer type %qT "
8240 "to arithmetic type %qT in a constant-expression",
8241 TREE_TYPE (TREE_OPERAND (r
, 0)), TREE_TYPE (r
));
8242 non_constant_p
= true;
8245 if (!non_constant_p
&& overflow_p
)
8246 non_constant_p
= true;
8248 if (non_constant_p
&& !allow_non_constant
)
8249 return error_mark_node
;
8250 else if (non_constant_p
&& TREE_CONSTANT (r
))
8252 /* This isn't actually constant, so unset TREE_CONSTANT. */
8255 else if (TREE_CODE (r
) == CONSTRUCTOR
)
8256 r
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (r
), r
);
8258 r
= build_nop (TREE_TYPE (r
), r
);
8259 TREE_CONSTANT (r
) = false;
8261 else if (non_constant_p
|| r
== t
)
8264 if (TREE_CODE (r
) == CONSTRUCTOR
&& CLASS_TYPE_P (TREE_TYPE (r
)))
8266 if (TREE_CODE (t
) == TARGET_EXPR
8267 && TARGET_EXPR_INITIAL (t
) == r
)
8271 r
= get_target_expr (r
);
8272 TREE_CONSTANT (r
) = true;
8280 /* Returns true if T is a valid subexpression of a constant expression,
8281 even if it isn't itself a constant expression. */
8284 is_sub_constant_expr (tree t
)
8286 bool non_constant_p
= false;
8287 bool overflow_p
= false;
8288 cxx_eval_constant_expression (NULL
, t
, true, false, &non_constant_p
,
8290 return !non_constant_p
&& !overflow_p
;
8293 /* If T represents a constant expression returns its reduced value.
8294 Otherwise return error_mark_node. If T is dependent, then
8298 cxx_constant_value (tree t
)
8300 return cxx_eval_outermost_constant_expr (t
, false);
8303 /* If T is a constant expression, returns its reduced value.
8304 Otherwise, if T does not have TREE_CONSTANT set, returns T.
8305 Otherwise, returns a version of T without TREE_CONSTANT. */
8308 maybe_constant_value (tree t
)
8312 if (instantiation_dependent_expression_p (t
)
8313 || type_unknown_p (t
)
8314 || BRACE_ENCLOSED_INITIALIZER_P (t
)
8315 || !potential_constant_expression (t
))
8317 if (TREE_OVERFLOW_P (t
))
8319 t
= build_nop (TREE_TYPE (t
), t
);
8320 TREE_CONSTANT (t
) = false;
8325 r
= cxx_eval_outermost_constant_expr (t
, true);
8326 #ifdef ENABLE_CHECKING
8327 /* cp_tree_equal looks through NOPs, so allow them. */
8329 || CONVERT_EXPR_P (t
)
8330 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
8331 || !cp_tree_equal (r
, t
));
8336 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
8337 than wrapped in a TARGET_EXPR. */
8340 maybe_constant_init (tree t
)
8342 t
= maybe_constant_value (t
);
8343 if (TREE_CODE (t
) == TARGET_EXPR
)
8345 tree init
= TARGET_EXPR_INITIAL (t
);
8346 if (TREE_CODE (init
) == CONSTRUCTOR
)
8353 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
8354 /* Return true if the object referred to by REF has automatic or thread
8357 enum { ck_ok
, ck_bad
, ck_unknown
};
8359 check_automatic_or_tls (tree ref
)
8361 enum machine_mode mode
;
8362 HOST_WIDE_INT bitsize
, bitpos
;
8364 int volatilep
= 0, unsignedp
= 0;
8365 tree decl
= get_inner_reference (ref
, &bitsize
, &bitpos
, &offset
,
8366 &mode
, &unsignedp
, &volatilep
, false);
8369 /* If there isn't a decl in the middle, we don't know the linkage here,
8370 and this isn't a constant expression anyway. */
8373 dk
= decl_storage_duration (decl
);
8374 return (dk
== dk_auto
|| dk
== dk_thread
) ? ck_bad
: ck_ok
;
8378 /* Return true if T denotes a potentially constant expression. Issue
8379 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
8380 an lvalue-rvalue conversion is implied.
8382 C++0x [expr.const] used to say
8384 6 An expression is a potential constant expression if it is
8385 a constant expression where all occurrences of function
8386 parameters are replaced by arbitrary constant expressions
8387 of the appropriate type.
8389 2 A conditional expression is a constant expression unless it
8390 involves one of the following as a potentially evaluated
8391 subexpression (3.2), but subexpressions of logical AND (5.14),
8392 logical OR (5.15), and conditional (5.16) operations that are
8393 not evaluated are not considered. */
8396 potential_constant_expression_1 (tree t
, bool want_rval
, tsubst_flags_t flags
)
8398 enum { any
= false, rval
= true };
8402 if (t
== error_mark_node
)
8406 if (TREE_THIS_VOLATILE (t
))
8408 if (flags
& tf_error
)
8409 error ("expression %qE has side-effects", t
);
8412 if (CONSTANT_CLASS_P (t
))
8415 switch (TREE_CODE (t
))
8421 case TEMPLATE_ID_EXPR
:
8428 case TEMPLATE_PARM_INDEX
:
8430 case IDENTIFIER_NODE
:
8431 case USERDEF_LITERAL
:
8432 /* We can see a FIELD_DECL in a pointer-to-member expression. */
8438 case AGGR_INIT_EXPR
:
8440 /* -- an invocation of a function other than a constexpr function
8441 or a constexpr constructor. */
8443 tree fun
= get_function_named_in_call (t
);
8444 const int nargs
= call_expr_nargs (t
);
8447 if (is_overloaded_fn (fun
))
8449 if (TREE_CODE (fun
) == FUNCTION_DECL
)
8451 if (builtin_valid_in_constant_expr_p (fun
))
8453 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
8454 /* Allow any built-in function; if the expansion
8455 isn't constant, we'll deal with that then. */
8456 && !is_builtin_fn (fun
))
8458 if (flags
& tf_error
)
8460 error_at (EXPR_LOC_OR_HERE (t
),
8461 "call to non-constexpr function %qD", fun
);
8462 explain_invalid_constexpr_fn (fun
);
8466 /* A call to a non-static member function takes the address
8467 of the object as the first argument. But in a constant
8468 expression the address will be folded away, so look
8470 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
8471 && !DECL_CONSTRUCTOR_P (fun
))
8473 tree x
= get_nth_callarg (t
, 0);
8474 if (is_this_parameter (x
))
8476 if (DECL_CONTEXT (x
) == NULL_TREE
8477 || DECL_CONSTRUCTOR_P (DECL_CONTEXT (x
)))
8479 if (flags
& tf_error
)
8480 sorry ("calling a member function of the "
8481 "object being constructed in a constant "
8485 /* Otherwise OK. */;
8487 else if (!potential_constant_expression_1 (x
, rval
, flags
))
8494 if (!potential_constant_expression_1 (fun
, true, flags
))
8496 fun
= get_first_fn (fun
);
8498 /* Skip initial arguments to base constructors. */
8499 if (DECL_BASE_CONSTRUCTOR_P (fun
))
8500 i
= num_artificial_parms_for (fun
);
8501 fun
= DECL_ORIGIN (fun
);
8505 if (potential_constant_expression_1 (fun
, rval
, flags
))
8506 /* Might end up being a constant function pointer. */;
8510 for (; i
< nargs
; ++i
)
8512 tree x
= get_nth_callarg (t
, i
);
8513 if (!potential_constant_expression_1 (x
, rval
, flags
))
8519 case NON_LVALUE_EXPR
:
8520 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
8521 -- an lvalue of integral type that refers to a non-volatile
8522 const variable or static data member initialized with
8523 constant expressions, or
8525 -- an lvalue of literal type that refers to non-volatile
8526 object defined with constexpr, or that refers to a
8527 sub-object of such an object; */
8528 return potential_constant_expression_1 (TREE_OPERAND (t
, 0), rval
, flags
);
8531 if (want_rval
&& !decl_constant_var_p (t
)
8532 && !dependent_type_p (TREE_TYPE (t
)))
8534 if (flags
& tf_error
)
8535 non_const_var_error (t
);
8542 case VIEW_CONVERT_EXPR
:
8543 /* -- a reinterpret_cast. FIXME not implemented, and this rule
8544 may change to something more specific to type-punning (DR 1312). */
8546 tree from
= TREE_OPERAND (t
, 0);
8547 if (POINTER_TYPE_P (TREE_TYPE (t
))
8548 && TREE_CODE (from
) == INTEGER_CST
8549 && !integer_zerop (from
))
8551 if (flags
& tf_error
)
8552 error_at (EXPR_LOC_OR_HERE (t
),
8553 "reinterpret_cast from integer to pointer");
8556 return (potential_constant_expression_1
8557 (from
, TREE_CODE (t
) != VIEW_CONVERT_EXPR
, flags
));
8561 /* -- a unary operator & that is applied to an lvalue that
8562 designates an object with thread or automatic storage
8564 t
= TREE_OPERAND (t
, 0);
8566 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
8567 any checking here, as we might dereference the pointer later. If
8568 we remove this code, also remove check_automatic_or_tls. */
8569 i
= check_automatic_or_tls (t
);
8574 if (flags
& tf_error
)
8575 error ("address-of an object %qE with thread local or "
8576 "automatic storage is not a constant expression", t
);
8580 return potential_constant_expression_1 (t
, any
, flags
);
8586 /* -- a class member access unless its postfix-expression is
8587 of literal type or of pointer to literal type. */
8588 /* This test would be redundant, as it follows from the
8589 postfix-expression being a potential constant expression. */
8590 return potential_constant_expression_1 (TREE_OPERAND (t
, 0),
8593 case EXPR_PACK_EXPANSION
:
8594 return potential_constant_expression_1 (PACK_EXPANSION_PATTERN (t
),
8599 tree x
= TREE_OPERAND (t
, 0);
8601 if (is_this_parameter (x
))
8603 if (DECL_CONTEXT (x
)
8604 && !DECL_DECLARED_CONSTEXPR_P (DECL_CONTEXT (x
)))
8606 if (flags
& tf_error
)
8607 error ("use of %<this%> in a constant expression");
8610 if (want_rval
&& DECL_CONTEXT (x
)
8611 && DECL_CONSTRUCTOR_P (DECL_CONTEXT (x
)))
8613 if (flags
& tf_error
)
8614 sorry ("use of the value of the object being constructed "
8615 "in a constant expression");
8620 return potential_constant_expression_1 (x
, rval
, flags
);
8624 case DYNAMIC_CAST_EXPR
:
8625 case PSEUDO_DTOR_EXPR
:
8626 case PREINCREMENT_EXPR
:
8627 case POSTINCREMENT_EXPR
:
8628 case PREDECREMENT_EXPR
:
8629 case POSTDECREMENT_EXPR
:
8633 case VEC_DELETE_EXPR
:
8638 case OMP_ATOMIC_READ
:
8639 case OMP_ATOMIC_CAPTURE_OLD
:
8640 case OMP_ATOMIC_CAPTURE_NEW
:
8641 /* GCC internal stuff. */
8644 case WITH_CLEANUP_EXPR
:
8645 case CLEANUP_POINT_EXPR
:
8646 case MUST_NOT_THROW_EXPR
:
8647 case TRY_CATCH_EXPR
:
8648 case STATEMENT_LIST
:
8649 /* Don't bother trying to define a subset of statement-expressions to
8650 be constant-expressions, at least for now. */
8654 case TRANSACTION_EXPR
:
8659 if (flags
& tf_error
)
8660 error ("expression %qE is not a constant-expression", t
);
8664 /* -- a typeid expression whose operand is of polymorphic
8667 tree e
= TREE_OPERAND (t
, 0);
8668 if (!TYPE_P (e
) && !type_dependent_expression_p (e
)
8669 && TYPE_POLYMORPHIC_P (TREE_TYPE (e
)))
8671 if (flags
& tf_error
)
8672 error ("typeid-expression is not a constant expression "
8673 "because %qE is of polymorphic type", e
);
8680 /* -- a subtraction where both operands are pointers. */
8681 if (TYPE_PTR_P (TREE_OPERAND (t
, 0))
8682 && TYPE_PTR_P (TREE_OPERAND (t
, 1)))
8684 if (flags
& tf_error
)
8685 error ("difference of two pointer expressions is not "
8686 "a constant expression");
8698 /* -- a relational or equality operator where at least
8699 one of the operands is a pointer. */
8700 if (TYPE_PTR_P (TREE_OPERAND (t
, 0))
8701 || TYPE_PTR_P (TREE_OPERAND (t
, 1)))
8703 if (flags
& tf_error
)
8704 error ("pointer comparison expression is not a "
8705 "constant expression");
8713 if (TYPE_P (TREE_OPERAND (t
, 0)))
8715 /* else fall through. */
8721 case FIX_TRUNC_EXPR
:
8725 case TRUTH_NOT_EXPR
:
8726 case FIXED_CONVERT_EXPR
:
8727 case UNARY_PLUS_EXPR
:
8728 return potential_constant_expression_1 (TREE_OPERAND (t
, 0), rval
,
8732 case CONST_CAST_EXPR
:
8733 case STATIC_CAST_EXPR
:
8734 case REINTERPRET_CAST_EXPR
:
8735 case IMPLICIT_CONV_EXPR
:
8736 if (cxx_dialect
< cxx11
8737 && !dependent_type_p (TREE_TYPE (t
))
8738 && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
)))
8739 /* In C++98, a conversion to non-integral type can't be part of a
8740 constant expression. */
8742 if (flags
& tf_error
)
8743 error ("cast to non-integral type %qT in a constant expression",
8748 return (potential_constant_expression_1
8749 (TREE_OPERAND (t
, 0),
8750 TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
, flags
));
8753 case NON_DEPENDENT_EXPR
:
8754 /* For convenience. */
8756 return potential_constant_expression_1 (TREE_OPERAND (t
, 0),
8760 return potential_constant_expression_1 (TREE_OPERAND (t
, 1),
8764 if (!literal_type_p (TREE_TYPE (t
)))
8766 if (flags
& tf_error
)
8768 error ("temporary of non-literal type %qT in a "
8769 "constant expression", TREE_TYPE (t
));
8770 explain_non_literal_class (TREE_TYPE (t
));
8775 return potential_constant_expression_1 (TREE_OPERAND (t
, 1),
8780 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
8781 constructor_elt
*ce
;
8782 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
8783 if (!potential_constant_expression_1 (ce
->value
, want_rval
, flags
))
8790 gcc_assert (TREE_PURPOSE (t
) == NULL_TREE
8791 || DECL_P (TREE_PURPOSE (t
)));
8792 if (!potential_constant_expression_1 (TREE_VALUE (t
), want_rval
,
8795 if (TREE_CHAIN (t
) == NULL_TREE
)
8797 return potential_constant_expression_1 (TREE_CHAIN (t
), want_rval
,
8801 case TRUNC_DIV_EXPR
:
8803 case FLOOR_DIV_EXPR
:
8804 case ROUND_DIV_EXPR
:
8805 case TRUNC_MOD_EXPR
:
8807 case ROUND_MOD_EXPR
:
8809 tree denom
= TREE_OPERAND (t
, 1);
8810 if (!potential_constant_expression_1 (denom
, rval
, flags
))
8812 /* We can't call cxx_eval_outermost_constant_expr on an expression
8813 that hasn't been through fold_non_dependent_expr yet. */
8814 if (!processing_template_decl
)
8815 denom
= cxx_eval_outermost_constant_expr (denom
, true);
8816 if (integer_zerop (denom
))
8818 if (flags
& tf_error
)
8819 error ("division by zero is not a constant-expression");
8825 return potential_constant_expression_1 (TREE_OPERAND (t
, 0),
8832 /* check_return_expr sometimes wraps a TARGET_EXPR in a
8833 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
8834 introduced by build_call_a. */
8835 tree op0
= TREE_OPERAND (t
, 0);
8836 tree op1
= TREE_OPERAND (t
, 1);
8838 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
8839 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
8840 return potential_constant_expression_1 (op0
, want_rval
, flags
);
8845 /* If the first operand is the non-short-circuit constant, look at
8846 the second operand; otherwise we only care about the first one for
8848 case TRUTH_AND_EXPR
:
8849 case TRUTH_ANDIF_EXPR
:
8850 tmp
= boolean_true_node
;
8853 case TRUTH_ORIF_EXPR
:
8854 tmp
= boolean_false_node
;
8857 tree op
= TREE_OPERAND (t
, 0);
8858 if (!potential_constant_expression_1 (op
, rval
, flags
))
8860 if (!processing_template_decl
)
8861 op
= cxx_eval_outermost_constant_expr (op
, true);
8862 if (tree_int_cst_equal (op
, tmp
))
8863 return potential_constant_expression_1 (TREE_OPERAND (t
, 1), rval
, flags
);
8870 case POINTER_PLUS_EXPR
:
8872 case EXACT_DIV_EXPR
:
8882 case TRUTH_XOR_EXPR
:
8883 case UNORDERED_EXPR
:
8896 case ARRAY_RANGE_REF
:
8900 for (i
= 0; i
< 2; ++i
)
8901 if (!potential_constant_expression_1 (TREE_OPERAND (t
, i
),
8906 case ARRAY_NOTATION_REF
:
8911 for (i
= 0; i
< 3; ++i
)
8912 if (!potential_constant_expression_1 (TREE_OPERAND (t
, i
),
8919 /* If the condition is a known constant, we know which of the legs we
8920 care about; otherwise we only require that the condition and
8921 either of the legs be potentially constant. */
8922 tmp
= TREE_OPERAND (t
, 0);
8923 if (!potential_constant_expression_1 (tmp
, rval
, flags
))
8925 if (!processing_template_decl
)
8926 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
8927 if (integer_zerop (tmp
))
8928 return potential_constant_expression_1 (TREE_OPERAND (t
, 2),
8930 else if (TREE_CODE (tmp
) == INTEGER_CST
)
8931 return potential_constant_expression_1 (TREE_OPERAND (t
, 1),
8933 for (i
= 1; i
< 3; ++i
)
8934 if (potential_constant_expression_1 (TREE_OPERAND (t
, i
),
8935 want_rval
, tf_none
))
8937 if (flags
& tf_error
)
8938 error ("expression %qE is not a constant-expression", t
);
8942 if (VEC_INIT_EXPR_IS_CONSTEXPR (t
))
8944 if (flags
& tf_error
)
8946 error ("non-constant array initialization");
8947 diagnose_non_constexpr_vec_init (t
);
8952 if (objc_is_property_ref (t
))
8955 sorry ("unexpected AST of kind %s", tree_code_name
[TREE_CODE (t
)]);
8961 /* The main entry point to the above. */
8964 potential_constant_expression (tree t
)
8966 return potential_constant_expression_1 (t
, false, tf_none
);
8969 /* As above, but require a constant rvalue. */
8972 potential_rvalue_constant_expression (tree t
)
8974 return potential_constant_expression_1 (t
, true, tf_none
);
8977 /* Like above, but complain about non-constant expressions. */
8980 require_potential_constant_expression (tree t
)
8982 return potential_constant_expression_1 (t
, false, tf_warning_or_error
);
8985 /* Cross product of the above. */
8988 require_potential_rvalue_constant_expression (tree t
)
8990 return potential_constant_expression_1 (t
, true, tf_warning_or_error
);
8993 /* Insert the deduced return type for an auto function. */
8996 apply_deduced_return_type (tree fco
, tree return_type
)
9000 if (return_type
== error_mark_node
)
9003 if (LAMBDA_FUNCTION_P (fco
))
9005 tree lambda
= CLASSTYPE_LAMBDA_EXPR (current_class_type
);
9006 LAMBDA_EXPR_RETURN_TYPE (lambda
) = return_type
;
9009 if (DECL_CONV_FN_P (fco
))
9010 DECL_NAME (fco
) = mangle_conv_op_name_for_type (return_type
);
9012 TREE_TYPE (fco
) = change_return_type (return_type
, TREE_TYPE (fco
));
9014 result
= DECL_RESULT (fco
);
9015 if (result
== NULL_TREE
)
9017 if (TREE_TYPE (result
) == return_type
)
9020 /* We already have a DECL_RESULT from start_preparsed_function.
9021 Now we need to redo the work it and allocate_struct_function
9022 did to reflect the new type. */
9023 gcc_assert (current_function_decl
== fco
);
9024 result
= build_decl (input_location
, RESULT_DECL
, NULL_TREE
,
9025 TYPE_MAIN_VARIANT (return_type
));
9026 DECL_ARTIFICIAL (result
) = 1;
9027 DECL_IGNORED_P (result
) = 1;
9028 cp_apply_type_quals_to_decl (cp_type_quals (return_type
),
9031 DECL_RESULT (fco
) = result
;
9033 if (!processing_template_decl
)
9035 bool aggr
= aggregate_value_p (result
, fco
);
9036 #ifdef PCC_STATIC_STRUCT_RETURN
9037 cfun
->returns_pcc_struct
= aggr
;
9039 cfun
->returns_struct
= aggr
;
9044 /* DECL is a local variable or parameter from the surrounding scope of a
9045 lambda-expression. Returns the decltype for a use of the capture field
9046 for DECL even if it hasn't been captured yet. */
9049 capture_decltype (tree decl
)
9051 tree lam
= CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (current_function_decl
));
9052 /* FIXME do lookup instead of list walk? */
9053 tree cap
= value_member (decl
, LAMBDA_EXPR_CAPTURE_LIST (lam
));
9057 type
= TREE_TYPE (TREE_PURPOSE (cap
));
9059 switch (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lam
))
9062 error ("%qD is not captured", decl
);
9063 return error_mark_node
;
9066 type
= TREE_TYPE (decl
);
9067 if (TREE_CODE (type
) == REFERENCE_TYPE
9068 && TREE_CODE (TREE_TYPE (type
)) != FUNCTION_TYPE
)
9069 type
= TREE_TYPE (type
);
9072 case CPLD_REFERENCE
:
9073 type
= TREE_TYPE (decl
);
9074 if (TREE_CODE (type
) != REFERENCE_TYPE
)
9075 type
= build_reference_type (TREE_TYPE (decl
));
9082 if (TREE_CODE (type
) != REFERENCE_TYPE
)
9084 if (!LAMBDA_EXPR_MUTABLE_P (lam
))
9085 type
= cp_build_qualified_type (type
, (cp_type_quals (type
)
9087 type
= build_reference_type (type
);
9092 #include "gt-cp-semantics.h"