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 /* Resume deferring access checks again after we stopped doing
162 resume_deferring_access_checks (void)
164 if (!deferred_access_no_check
)
165 deferred_access_stack
->last().deferring_access_checks_kind
= dk_deferred
;
168 /* Stop deferring access checks. */
171 stop_deferring_access_checks (void)
173 if (!deferred_access_no_check
)
174 deferred_access_stack
->last().deferring_access_checks_kind
= dk_no_deferred
;
177 /* Discard the current deferred access checks and restore the
181 pop_deferring_access_checks (void)
183 if (deferred_access_no_check
)
184 deferred_access_no_check
--;
186 deferred_access_stack
->pop ();
189 /* Returns a TREE_LIST representing the deferred checks.
190 The TREE_PURPOSE of each node is the type through which the
191 access occurred; the TREE_VALUE is the declaration named.
194 vec
<deferred_access_check
, va_gc
> *
195 get_deferred_access_checks (void)
197 if (deferred_access_no_check
)
200 return (deferred_access_stack
->last().deferred_access_checks
);
203 /* Take current deferred checks and combine with the
204 previous states if we also defer checks previously.
205 Otherwise perform checks now. */
208 pop_to_parent_deferring_access_checks (void)
210 if (deferred_access_no_check
)
211 deferred_access_no_check
--;
214 vec
<deferred_access_check
, va_gc
> *checks
;
215 deferred_access
*ptr
;
217 checks
= (deferred_access_stack
->last ().deferred_access_checks
);
219 deferred_access_stack
->pop ();
220 ptr
= &deferred_access_stack
->last ();
221 if (ptr
->deferring_access_checks_kind
== dk_no_deferred
)
224 perform_access_checks (checks
, tf_warning_or_error
);
228 /* Merge with parent. */
230 deferred_access_check
*chk
, *probe
;
232 FOR_EACH_VEC_SAFE_ELT (checks
, i
, chk
)
234 FOR_EACH_VEC_SAFE_ELT (ptr
->deferred_access_checks
, j
, probe
)
236 if (probe
->binfo
== chk
->binfo
&&
237 probe
->decl
== chk
->decl
&&
238 probe
->diag_decl
== chk
->diag_decl
)
241 /* Insert into parent's checks. */
242 vec_safe_push (ptr
->deferred_access_checks
, *chk
);
249 /* Perform the access checks in CHECKS. The TREE_PURPOSE of each node
250 is the BINFO indicating the qualifying scope used to access the
251 DECL node stored in the TREE_VALUE of the node. If CHECKS is empty
252 or we aren't in SFINAE context or all the checks succeed return TRUE,
256 perform_access_checks (vec
<deferred_access_check
, va_gc
> *checks
,
257 tsubst_flags_t complain
)
260 deferred_access_check
*chk
;
261 location_t loc
= input_location
;
267 FOR_EACH_VEC_SAFE_ELT (checks
, i
, chk
)
269 input_location
= chk
->loc
;
270 ok
&= enforce_access (chk
->binfo
, chk
->decl
, chk
->diag_decl
, complain
);
273 input_location
= loc
;
274 return (complain
& tf_error
) ? true : ok
;
277 /* Perform the deferred access checks.
279 After performing the checks, we still have to keep the list
280 `deferred_access_stack->deferred_access_checks' since we may want
281 to check access for them again later in a different context.
288 A::X A::a, x; // No error for `A::a', error for `x'
290 We have to perform deferred access of `A::X', first with `A::a',
291 next with `x'. Return value like perform_access_checks above. */
294 perform_deferred_access_checks (tsubst_flags_t complain
)
296 return perform_access_checks (get_deferred_access_checks (), complain
);
299 /* Defer checking the accessibility of DECL, when looked up in
300 BINFO. DIAG_DECL is the declaration to use to print diagnostics.
301 Return value like perform_access_checks above. */
304 perform_or_defer_access_check (tree binfo
, tree decl
, tree diag_decl
,
305 tsubst_flags_t complain
)
308 deferred_access
*ptr
;
309 deferred_access_check
*chk
;
312 /* Exit if we are in a context that no access checking is performed.
314 if (deferred_access_no_check
)
317 gcc_assert (TREE_CODE (binfo
) == TREE_BINFO
);
319 ptr
= &deferred_access_stack
->last ();
321 /* If we are not supposed to defer access checks, just check now. */
322 if (ptr
->deferring_access_checks_kind
== dk_no_deferred
)
324 bool ok
= enforce_access (binfo
, decl
, diag_decl
, complain
);
325 return (complain
& tf_error
) ? true : ok
;
328 /* See if we are already going to perform this check. */
329 FOR_EACH_VEC_SAFE_ELT (ptr
->deferred_access_checks
, i
, chk
)
331 if (chk
->decl
== decl
&& chk
->binfo
== binfo
&&
332 chk
->diag_decl
== diag_decl
)
337 /* If not, record the check. */
338 deferred_access_check new_access
= {binfo
, decl
, diag_decl
, input_location
};
339 vec_safe_push (ptr
->deferred_access_checks
, new_access
);
344 /* Returns nonzero if the current statement is a full expression,
345 i.e. temporaries created during that statement should be destroyed
346 at the end of the statement. */
349 stmts_are_full_exprs_p (void)
351 return current_stmt_tree ()->stmts_are_full_exprs_p
;
354 /* T is a statement. Add it to the statement-tree. This is the C++
355 version. The C/ObjC frontends have a slightly different version of
361 enum tree_code code
= TREE_CODE (t
);
363 if (EXPR_P (t
) && code
!= LABEL_EXPR
)
365 if (!EXPR_HAS_LOCATION (t
))
366 SET_EXPR_LOCATION (t
, input_location
);
368 /* When we expand a statement-tree, we must know whether or not the
369 statements are full-expressions. We record that fact here. */
370 STMT_IS_FULL_EXPR_P (t
) = stmts_are_full_exprs_p ();
373 /* Add T to the statement-tree. Non-side-effect statements need to be
374 recorded during statement expressions. */
375 gcc_checking_assert (!stmt_list_stack
->is_empty ());
376 append_to_statement_list_force (t
, &cur_stmt_list
);
381 /* Returns the stmt_tree to which statements are currently being added. */
384 current_stmt_tree (void)
387 ? &cfun
->language
->base
.x_stmt_tree
388 : &scope_chain
->x_stmt_tree
);
391 /* If statements are full expressions, wrap STMT in a CLEANUP_POINT_EXPR. */
394 maybe_cleanup_point_expr (tree expr
)
396 if (!processing_template_decl
&& stmts_are_full_exprs_p ())
397 expr
= fold_build_cleanup_point_expr (TREE_TYPE (expr
), expr
);
401 /* Like maybe_cleanup_point_expr except have the type of the new expression be
402 void so we don't need to create a temporary variable to hold the inner
403 expression. The reason why we do this is because the original type might be
404 an aggregate and we cannot create a temporary variable for that type. */
407 maybe_cleanup_point_expr_void (tree expr
)
409 if (!processing_template_decl
&& stmts_are_full_exprs_p ())
410 expr
= fold_build_cleanup_point_expr (void_type_node
, expr
);
416 /* Create a declaration statement for the declaration given by the DECL. */
419 add_decl_expr (tree decl
)
421 tree r
= build_stmt (input_location
, DECL_EXPR
, decl
);
422 if (DECL_INITIAL (decl
)
423 || (DECL_SIZE (decl
) && TREE_SIDE_EFFECTS (DECL_SIZE (decl
))))
424 r
= maybe_cleanup_point_expr_void (r
);
428 /* Finish a scope. */
431 do_poplevel (tree stmt_list
)
435 if (stmts_are_full_exprs_p ())
436 block
= poplevel (kept_level_p (), 1, 0);
438 stmt_list
= pop_stmt_list (stmt_list
);
440 if (!processing_template_decl
)
442 stmt_list
= c_build_bind_expr (input_location
, block
, stmt_list
);
443 /* ??? See c_end_compound_stmt re statement expressions. */
449 /* Begin a new scope. */
452 do_pushlevel (scope_kind sk
)
454 tree ret
= push_stmt_list ();
455 if (stmts_are_full_exprs_p ())
456 begin_scope (sk
, NULL
);
460 /* Queue a cleanup. CLEANUP is an expression/statement to be executed
461 when the current scope is exited. EH_ONLY is true when this is not
462 meant to apply to normal control flow transfer. */
465 push_cleanup (tree decl
, tree cleanup
, bool eh_only
)
467 tree stmt
= build_stmt (input_location
, CLEANUP_STMT
, NULL
, cleanup
, decl
);
468 CLEANUP_EH_ONLY (stmt
) = eh_only
;
470 CLEANUP_BODY (stmt
) = push_stmt_list ();
473 /* Begin a conditional that might contain a declaration. When generating
474 normal code, we want the declaration to appear before the statement
475 containing the conditional. When generating template code, we want the
476 conditional to be rendered as the raw DECL_EXPR. */
479 begin_cond (tree
*cond_p
)
481 if (processing_template_decl
)
482 *cond_p
= push_stmt_list ();
485 /* Finish such a conditional. */
488 finish_cond (tree
*cond_p
, tree expr
)
490 if (processing_template_decl
)
492 tree cond
= pop_stmt_list (*cond_p
);
494 if (expr
== NULL_TREE
)
495 /* Empty condition in 'for'. */
496 gcc_assert (empty_expr_stmt_p (cond
));
497 else if (check_for_bare_parameter_packs (expr
))
498 expr
= error_mark_node
;
499 else if (!empty_expr_stmt_p (cond
))
500 expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (expr
), cond
, expr
);
505 /* If *COND_P specifies a conditional with a declaration, transform the
508 for (; A x = 42;) { }
510 while (true) { A x = 42; if (!x) break; }
511 for (;;) { A x = 42; if (!x) break; }
512 The statement list for BODY will be empty if the conditional did
513 not declare anything. */
516 simplify_loop_decl_cond (tree
*cond_p
, tree body
)
520 if (!TREE_SIDE_EFFECTS (body
))
524 *cond_p
= boolean_true_node
;
526 if_stmt
= begin_if_stmt ();
527 cond
= cp_build_unary_op (TRUTH_NOT_EXPR
, cond
, 0, tf_warning_or_error
);
528 finish_if_stmt_cond (cond
, if_stmt
);
529 finish_break_stmt ();
530 finish_then_clause (if_stmt
);
531 finish_if_stmt (if_stmt
);
534 /* Finish a goto-statement. */
537 finish_goto_stmt (tree destination
)
539 if (identifier_p (destination
))
540 destination
= lookup_label (destination
);
542 /* We warn about unused labels with -Wunused. That means we have to
543 mark the used labels as used. */
544 if (TREE_CODE (destination
) == LABEL_DECL
)
545 TREE_USED (destination
) = 1;
548 destination
= mark_rvalue_use (destination
);
549 if (!processing_template_decl
)
551 destination
= cp_convert (ptr_type_node
, destination
,
552 tf_warning_or_error
);
553 if (error_operand_p (destination
))
556 = fold_build_cleanup_point_expr (TREE_TYPE (destination
),
561 check_goto (destination
);
563 return add_stmt (build_stmt (input_location
, GOTO_EXPR
, destination
));
566 /* COND is the condition-expression for an if, while, etc.,
567 statement. Convert it to a boolean value, if appropriate.
568 In addition, verify sequence points if -Wsequence-point is enabled. */
571 maybe_convert_cond (tree cond
)
573 /* Empty conditions remain empty. */
577 /* Wait until we instantiate templates before doing conversion. */
578 if (processing_template_decl
)
581 if (warn_sequence_point
)
582 verify_sequence_points (cond
);
584 /* Do the conversion. */
585 cond
= convert_from_reference (cond
);
587 if (TREE_CODE (cond
) == MODIFY_EXPR
588 && !TREE_NO_WARNING (cond
)
591 warning (OPT_Wparentheses
,
592 "suggest parentheses around assignment used as truth value");
593 TREE_NO_WARNING (cond
) = 1;
596 return condition_conversion (cond
);
599 /* Finish an expression-statement, whose EXPRESSION is as indicated. */
602 finish_expr_stmt (tree expr
)
606 if (expr
!= NULL_TREE
)
608 if (!processing_template_decl
)
610 if (warn_sequence_point
)
611 verify_sequence_points (expr
);
612 expr
= convert_to_void (expr
, ICV_STATEMENT
, tf_warning_or_error
);
614 else if (!type_dependent_expression_p (expr
))
615 convert_to_void (build_non_dependent_expr (expr
), ICV_STATEMENT
,
616 tf_warning_or_error
);
618 if (check_for_bare_parameter_packs (expr
))
619 expr
= error_mark_node
;
621 /* Simplification of inner statement expressions, compound exprs,
622 etc can result in us already having an EXPR_STMT. */
623 if (TREE_CODE (expr
) != CLEANUP_POINT_EXPR
)
625 if (TREE_CODE (expr
) != EXPR_STMT
)
626 expr
= build_stmt (input_location
, EXPR_STMT
, expr
);
627 expr
= maybe_cleanup_point_expr_void (expr
);
639 /* Begin an if-statement. Returns a newly created IF_STMT if
646 scope
= do_pushlevel (sk_cond
);
647 r
= build_stmt (input_location
, IF_STMT
, NULL_TREE
,
648 NULL_TREE
, NULL_TREE
, scope
);
649 begin_cond (&IF_COND (r
));
653 /* Process the COND of an if-statement, which may be given by
657 finish_if_stmt_cond (tree cond
, tree if_stmt
)
659 finish_cond (&IF_COND (if_stmt
), maybe_convert_cond (cond
));
661 THEN_CLAUSE (if_stmt
) = push_stmt_list ();
664 /* Finish the then-clause of an if-statement, which may be given by
668 finish_then_clause (tree if_stmt
)
670 THEN_CLAUSE (if_stmt
) = pop_stmt_list (THEN_CLAUSE (if_stmt
));
674 /* Begin the else-clause of an if-statement. */
677 begin_else_clause (tree if_stmt
)
679 ELSE_CLAUSE (if_stmt
) = push_stmt_list ();
682 /* Finish the else-clause of an if-statement, which may be given by
686 finish_else_clause (tree if_stmt
)
688 ELSE_CLAUSE (if_stmt
) = pop_stmt_list (ELSE_CLAUSE (if_stmt
));
691 /* Finish an if-statement. */
694 finish_if_stmt (tree if_stmt
)
696 tree scope
= IF_SCOPE (if_stmt
);
697 IF_SCOPE (if_stmt
) = NULL
;
698 add_stmt (do_poplevel (scope
));
702 /* Begin a while-statement. Returns a newly created WHILE_STMT if
706 begin_while_stmt (void)
709 r
= build_stmt (input_location
, WHILE_STMT
, NULL_TREE
, NULL_TREE
);
711 WHILE_BODY (r
) = do_pushlevel (sk_block
);
712 begin_cond (&WHILE_COND (r
));
716 /* Process the COND of a while-statement, which may be given by
720 finish_while_stmt_cond (tree cond
, tree while_stmt
)
722 finish_cond (&WHILE_COND (while_stmt
), maybe_convert_cond (cond
));
723 simplify_loop_decl_cond (&WHILE_COND (while_stmt
), WHILE_BODY (while_stmt
));
726 /* Finish a while-statement, which may be given by WHILE_STMT. */
729 finish_while_stmt (tree while_stmt
)
731 WHILE_BODY (while_stmt
) = do_poplevel (WHILE_BODY (while_stmt
));
735 /* Begin a do-statement. Returns a newly created DO_STMT if
741 tree r
= build_stmt (input_location
, DO_STMT
, NULL_TREE
, NULL_TREE
);
743 DO_BODY (r
) = push_stmt_list ();
747 /* Finish the body of a do-statement, which may be given by DO_STMT. */
750 finish_do_body (tree do_stmt
)
752 tree body
= DO_BODY (do_stmt
) = pop_stmt_list (DO_BODY (do_stmt
));
754 if (TREE_CODE (body
) == STATEMENT_LIST
&& STATEMENT_LIST_TAIL (body
))
755 body
= STATEMENT_LIST_TAIL (body
)->stmt
;
757 if (IS_EMPTY_STMT (body
))
758 warning (OPT_Wempty_body
,
759 "suggest explicit braces around empty body in %<do%> statement");
762 /* Finish a do-statement, which may be given by DO_STMT, and whose
763 COND is as indicated. */
766 finish_do_stmt (tree cond
, tree do_stmt
)
768 cond
= maybe_convert_cond (cond
);
769 DO_COND (do_stmt
) = cond
;
773 /* Finish a return-statement. The EXPRESSION returned, if any, is as
777 finish_return_stmt (tree expr
)
782 expr
= check_return_expr (expr
, &no_warning
);
784 if (flag_openmp
&& !check_omp_return ())
785 return error_mark_node
;
786 if (!processing_template_decl
)
788 if (warn_sequence_point
)
789 verify_sequence_points (expr
);
791 if (DECL_DESTRUCTOR_P (current_function_decl
)
792 || (DECL_CONSTRUCTOR_P (current_function_decl
)
793 && targetm
.cxx
.cdtor_returns_this ()))
795 /* Similarly, all destructors must run destructors for
796 base-classes before returning. So, all returns in a
797 destructor get sent to the DTOR_LABEL; finish_function emits
798 code to return a value there. */
799 return finish_goto_stmt (cdtor_label
);
803 r
= build_stmt (input_location
, RETURN_EXPR
, expr
);
804 TREE_NO_WARNING (r
) |= no_warning
;
805 r
= maybe_cleanup_point_expr_void (r
);
812 /* Begin the scope of a for-statement or a range-for-statement.
813 Both the returned trees are to be used in a call to
814 begin_for_stmt or begin_range_for_stmt. */
817 begin_for_scope (tree
*init
)
819 tree scope
= NULL_TREE
;
820 if (flag_new_for_scope
> 0)
821 scope
= do_pushlevel (sk_for
);
823 if (processing_template_decl
)
824 *init
= push_stmt_list ();
831 /* Begin a for-statement. Returns a new FOR_STMT.
832 SCOPE and INIT should be the return of begin_for_scope,
836 begin_for_stmt (tree scope
, tree init
)
840 r
= build_stmt (input_location
, FOR_STMT
, NULL_TREE
, NULL_TREE
,
841 NULL_TREE
, NULL_TREE
, NULL_TREE
);
843 if (scope
== NULL_TREE
)
845 gcc_assert (!init
|| !(flag_new_for_scope
> 0));
847 scope
= begin_for_scope (&init
);
849 FOR_INIT_STMT (r
) = init
;
850 FOR_SCOPE (r
) = scope
;
855 /* Finish the for-init-statement of a for-statement, which may be
856 given by FOR_STMT. */
859 finish_for_init_stmt (tree for_stmt
)
861 if (processing_template_decl
)
862 FOR_INIT_STMT (for_stmt
) = pop_stmt_list (FOR_INIT_STMT (for_stmt
));
864 FOR_BODY (for_stmt
) = do_pushlevel (sk_block
);
865 begin_cond (&FOR_COND (for_stmt
));
868 /* Finish the COND of a for-statement, which may be given by
872 finish_for_cond (tree cond
, tree for_stmt
)
874 finish_cond (&FOR_COND (for_stmt
), maybe_convert_cond (cond
));
875 simplify_loop_decl_cond (&FOR_COND (for_stmt
), FOR_BODY (for_stmt
));
878 /* Finish the increment-EXPRESSION in a for-statement, which may be
879 given by FOR_STMT. */
882 finish_for_expr (tree expr
, tree for_stmt
)
886 /* If EXPR is an overloaded function, issue an error; there is no
887 context available to use to perform overload resolution. */
888 if (type_unknown_p (expr
))
890 cxx_incomplete_type_error (expr
, TREE_TYPE (expr
));
891 expr
= error_mark_node
;
893 if (!processing_template_decl
)
895 if (warn_sequence_point
)
896 verify_sequence_points (expr
);
897 expr
= convert_to_void (expr
, ICV_THIRD_IN_FOR
,
898 tf_warning_or_error
);
900 else if (!type_dependent_expression_p (expr
))
901 convert_to_void (build_non_dependent_expr (expr
), ICV_THIRD_IN_FOR
,
902 tf_warning_or_error
);
903 expr
= maybe_cleanup_point_expr_void (expr
);
904 if (check_for_bare_parameter_packs (expr
))
905 expr
= error_mark_node
;
906 FOR_EXPR (for_stmt
) = expr
;
909 /* Finish the body of a for-statement, which may be given by
910 FOR_STMT. The increment-EXPR for the loop must be
912 It can also finish RANGE_FOR_STMT. */
915 finish_for_stmt (tree for_stmt
)
917 if (TREE_CODE (for_stmt
) == RANGE_FOR_STMT
)
918 RANGE_FOR_BODY (for_stmt
) = do_poplevel (RANGE_FOR_BODY (for_stmt
));
920 FOR_BODY (for_stmt
) = do_poplevel (FOR_BODY (for_stmt
));
922 /* Pop the scope for the body of the loop. */
923 if (flag_new_for_scope
> 0)
926 tree
*scope_ptr
= (TREE_CODE (for_stmt
) == RANGE_FOR_STMT
927 ? &RANGE_FOR_SCOPE (for_stmt
)
928 : &FOR_SCOPE (for_stmt
));
931 add_stmt (do_poplevel (scope
));
937 /* Begin a range-for-statement. Returns a new RANGE_FOR_STMT.
938 SCOPE and INIT should be the return of begin_for_scope,
940 To finish it call finish_for_stmt(). */
943 begin_range_for_stmt (tree scope
, tree init
)
947 r
= build_stmt (input_location
, RANGE_FOR_STMT
,
948 NULL_TREE
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
950 if (scope
== NULL_TREE
)
952 gcc_assert (!init
|| !(flag_new_for_scope
> 0));
954 scope
= begin_for_scope (&init
);
957 /* RANGE_FOR_STMTs do not use nor save the init tree, so we
960 pop_stmt_list (init
);
961 RANGE_FOR_SCOPE (r
) = scope
;
966 /* Finish the head of a range-based for statement, which may
967 be given by RANGE_FOR_STMT. DECL must be the declaration
968 and EXPR must be the loop expression. */
971 finish_range_for_decl (tree range_for_stmt
, tree decl
, tree expr
)
973 RANGE_FOR_DECL (range_for_stmt
) = decl
;
974 RANGE_FOR_EXPR (range_for_stmt
) = expr
;
975 add_stmt (range_for_stmt
);
976 RANGE_FOR_BODY (range_for_stmt
) = do_pushlevel (sk_block
);
979 /* Finish a break-statement. */
982 finish_break_stmt (void)
984 /* In switch statements break is sometimes stylistically used after
985 a return statement. This can lead to spurious warnings about
986 control reaching the end of a non-void function when it is
987 inlined. Note that we are calling block_may_fallthru with
988 language specific tree nodes; this works because
989 block_may_fallthru returns true when given something it does not
991 if (!block_may_fallthru (cur_stmt_list
))
992 return void_zero_node
;
993 return add_stmt (build_stmt (input_location
, BREAK_STMT
));
996 /* Finish a continue-statement. */
999 finish_continue_stmt (void)
1001 return add_stmt (build_stmt (input_location
, CONTINUE_STMT
));
1004 /* Begin a switch-statement. Returns a new SWITCH_STMT if
1008 begin_switch_stmt (void)
1012 scope
= do_pushlevel (sk_cond
);
1013 r
= build_stmt (input_location
, SWITCH_STMT
, NULL_TREE
, NULL_TREE
, NULL_TREE
, scope
);
1015 begin_cond (&SWITCH_STMT_COND (r
));
1020 /* Finish the cond of a switch-statement. */
1023 finish_switch_cond (tree cond
, tree switch_stmt
)
1025 tree orig_type
= NULL
;
1026 if (!processing_template_decl
)
1028 /* Convert the condition to an integer or enumeration type. */
1029 cond
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
, cond
, true);
1030 if (cond
== NULL_TREE
)
1032 error ("switch quantity not an integer");
1033 cond
= error_mark_node
;
1035 orig_type
= TREE_TYPE (cond
);
1036 if (cond
!= error_mark_node
)
1040 Integral promotions are performed. */
1041 cond
= perform_integral_promotions (cond
);
1042 cond
= maybe_cleanup_point_expr (cond
);
1045 if (check_for_bare_parameter_packs (cond
))
1046 cond
= error_mark_node
;
1047 else if (!processing_template_decl
&& warn_sequence_point
)
1048 verify_sequence_points (cond
);
1050 finish_cond (&SWITCH_STMT_COND (switch_stmt
), cond
);
1051 SWITCH_STMT_TYPE (switch_stmt
) = orig_type
;
1052 add_stmt (switch_stmt
);
1053 push_switch (switch_stmt
);
1054 SWITCH_STMT_BODY (switch_stmt
) = push_stmt_list ();
1057 /* Finish the body of a switch-statement, which may be given by
1058 SWITCH_STMT. The COND to switch on is indicated. */
1061 finish_switch_stmt (tree switch_stmt
)
1065 SWITCH_STMT_BODY (switch_stmt
) =
1066 pop_stmt_list (SWITCH_STMT_BODY (switch_stmt
));
1070 scope
= SWITCH_STMT_SCOPE (switch_stmt
);
1071 SWITCH_STMT_SCOPE (switch_stmt
) = NULL
;
1072 add_stmt (do_poplevel (scope
));
1075 /* Begin a try-block. Returns a newly-created TRY_BLOCK if
1079 begin_try_block (void)
1081 tree r
= build_stmt (input_location
, TRY_BLOCK
, NULL_TREE
, NULL_TREE
);
1083 TRY_STMTS (r
) = push_stmt_list ();
1087 /* Likewise, for a function-try-block. The block returned in
1088 *COMPOUND_STMT is an artificial outer scope, containing the
1089 function-try-block. */
1092 begin_function_try_block (tree
*compound_stmt
)
1095 /* This outer scope does not exist in the C++ standard, but we need
1096 a place to put __FUNCTION__ and similar variables. */
1097 *compound_stmt
= begin_compound_stmt (0);
1098 r
= begin_try_block ();
1099 FN_TRY_BLOCK_P (r
) = 1;
1103 /* Finish a try-block, which may be given by TRY_BLOCK. */
1106 finish_try_block (tree try_block
)
1108 TRY_STMTS (try_block
) = pop_stmt_list (TRY_STMTS (try_block
));
1109 TRY_HANDLERS (try_block
) = push_stmt_list ();
1112 /* Finish the body of a cleanup try-block, which may be given by
1116 finish_cleanup_try_block (tree try_block
)
1118 TRY_STMTS (try_block
) = pop_stmt_list (TRY_STMTS (try_block
));
1121 /* Finish an implicitly generated try-block, with a cleanup is given
1125 finish_cleanup (tree cleanup
, tree try_block
)
1127 TRY_HANDLERS (try_block
) = cleanup
;
1128 CLEANUP_P (try_block
) = 1;
1131 /* Likewise, for a function-try-block. */
1134 finish_function_try_block (tree try_block
)
1136 finish_try_block (try_block
);
1137 /* FIXME : something queer about CTOR_INITIALIZER somehow following
1138 the try block, but moving it inside. */
1139 in_function_try_handler
= 1;
1142 /* Finish a handler-sequence for a try-block, which may be given by
1146 finish_handler_sequence (tree try_block
)
1148 TRY_HANDLERS (try_block
) = pop_stmt_list (TRY_HANDLERS (try_block
));
1149 check_handlers (TRY_HANDLERS (try_block
));
1152 /* Finish the handler-seq for a function-try-block, given by
1153 TRY_BLOCK. COMPOUND_STMT is the outer block created by
1154 begin_function_try_block. */
1157 finish_function_handler_sequence (tree try_block
, tree compound_stmt
)
1159 in_function_try_handler
= 0;
1160 finish_handler_sequence (try_block
);
1161 finish_compound_stmt (compound_stmt
);
1164 /* Begin a handler. Returns a HANDLER if appropriate. */
1167 begin_handler (void)
1171 r
= build_stmt (input_location
, HANDLER
, NULL_TREE
, NULL_TREE
);
1174 /* Create a binding level for the eh_info and the exception object
1176 HANDLER_BODY (r
) = do_pushlevel (sk_catch
);
1181 /* Finish the handler-parameters for a handler, which may be given by
1182 HANDLER. DECL is the declaration for the catch parameter, or NULL
1183 if this is a `catch (...)' clause. */
1186 finish_handler_parms (tree decl
, tree handler
)
1188 tree type
= NULL_TREE
;
1189 if (processing_template_decl
)
1193 decl
= pushdecl (decl
);
1194 decl
= push_template_decl (decl
);
1195 HANDLER_PARMS (handler
) = decl
;
1196 type
= TREE_TYPE (decl
);
1200 type
= expand_start_catch_block (decl
);
1201 HANDLER_TYPE (handler
) = type
;
1202 if (!processing_template_decl
&& type
)
1203 mark_used (eh_type_info (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. */
1295 /* Finish an asm-statement, whose components are a STRING, some
1296 OUTPUT_OPERANDS, some INPUT_OPERANDS, some CLOBBERS and some
1297 LABELS. Also note whether the asm-statement should be
1298 considered volatile. */
1301 finish_asm_stmt (int volatile_p
, tree string
, tree output_operands
,
1302 tree input_operands
, tree clobbers
, tree labels
)
1306 int ninputs
= list_length (input_operands
);
1307 int noutputs
= list_length (output_operands
);
1309 if (!processing_template_decl
)
1311 const char *constraint
;
1312 const char **oconstraints
;
1313 bool allows_mem
, allows_reg
, is_inout
;
1317 oconstraints
= XALLOCAVEC (const char *, noutputs
);
1319 string
= resolve_asm_operand_names (string
, output_operands
,
1320 input_operands
, labels
);
1322 for (i
= 0, t
= output_operands
; t
; t
= TREE_CHAIN (t
), ++i
)
1324 operand
= TREE_VALUE (t
);
1326 /* ??? Really, this should not be here. Users should be using a
1327 proper lvalue, dammit. But there's a long history of using
1328 casts in the output operands. In cases like longlong.h, this
1329 becomes a primitive form of typechecking -- if the cast can be
1330 removed, then the output operand had a type of the proper width;
1331 otherwise we'll get an error. Gross, but ... */
1332 STRIP_NOPS (operand
);
1334 operand
= mark_lvalue_use (operand
);
1336 if (!lvalue_or_else (operand
, lv_asm
, tf_warning_or_error
))
1337 operand
= error_mark_node
;
1339 if (operand
!= error_mark_node
1340 && (TREE_READONLY (operand
)
1341 || CP_TYPE_CONST_P (TREE_TYPE (operand
))
1342 /* Functions are not modifiable, even though they are
1344 || TREE_CODE (TREE_TYPE (operand
)) == FUNCTION_TYPE
1345 || TREE_CODE (TREE_TYPE (operand
)) == METHOD_TYPE
1346 /* If it's an aggregate and any field is const, then it is
1347 effectively const. */
1348 || (CLASS_TYPE_P (TREE_TYPE (operand
))
1349 && C_TYPE_FIELDS_READONLY (TREE_TYPE (operand
)))))
1350 cxx_readonly_error (operand
, lv_asm
);
1352 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
1353 oconstraints
[i
] = constraint
;
1355 if (parse_output_constraint (&constraint
, i
, ninputs
, noutputs
,
1356 &allows_mem
, &allows_reg
, &is_inout
))
1358 /* If the operand is going to end up in memory,
1359 mark it addressable. */
1360 if (!allows_reg
&& !cxx_mark_addressable (operand
))
1361 operand
= error_mark_node
;
1364 operand
= error_mark_node
;
1366 TREE_VALUE (t
) = operand
;
1369 for (i
= 0, t
= input_operands
; t
; ++i
, t
= TREE_CHAIN (t
))
1371 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
1372 bool constraint_parsed
1373 = parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, 0,
1374 oconstraints
, &allows_mem
, &allows_reg
);
1375 /* If the operand is going to end up in memory, don't call
1376 decay_conversion. */
1377 if (constraint_parsed
&& !allows_reg
&& allows_mem
)
1378 operand
= mark_lvalue_use (TREE_VALUE (t
));
1380 operand
= decay_conversion (TREE_VALUE (t
), tf_warning_or_error
);
1382 /* If the type of the operand hasn't been determined (e.g.,
1383 because it involves an overloaded function), then issue
1384 an error message. There's no context available to
1385 resolve the overloading. */
1386 if (TREE_TYPE (operand
) == unknown_type_node
)
1388 error ("type of asm operand %qE could not be determined",
1390 operand
= error_mark_node
;
1393 if (constraint_parsed
)
1395 /* If the operand is going to end up in memory,
1396 mark it addressable. */
1397 if (!allows_reg
&& allows_mem
)
1399 /* Strip the nops as we allow this case. FIXME, this really
1400 should be rejected or made deprecated. */
1401 STRIP_NOPS (operand
);
1402 if (!cxx_mark_addressable (operand
))
1403 operand
= error_mark_node
;
1405 else if (!allows_reg
&& !allows_mem
)
1407 /* If constraint allows neither register nor memory,
1408 try harder to get a constant. */
1409 tree constop
= maybe_constant_value (operand
);
1410 if (TREE_CONSTANT (constop
))
1415 operand
= error_mark_node
;
1417 TREE_VALUE (t
) = operand
;
1421 r
= build_stmt (input_location
, ASM_EXPR
, string
,
1422 output_operands
, input_operands
,
1424 ASM_VOLATILE_P (r
) = volatile_p
|| noutputs
== 0;
1425 r
= maybe_cleanup_point_expr_void (r
);
1426 return add_stmt (r
);
1429 /* Finish a label with the indicated NAME. Returns the new label. */
1432 finish_label_stmt (tree name
)
1434 tree decl
= define_label (input_location
, name
);
1436 if (decl
== error_mark_node
)
1437 return error_mark_node
;
1439 add_stmt (build_stmt (input_location
, LABEL_EXPR
, decl
));
1444 /* Finish a series of declarations for local labels. G++ allows users
1445 to declare "local" labels, i.e., labels with scope. This extension
1446 is useful when writing code involving statement-expressions. */
1449 finish_label_decl (tree name
)
1451 if (!at_function_scope_p ())
1453 error ("__label__ declarations are only allowed in function scopes");
1457 add_decl_expr (declare_local_label (name
));
1460 /* When DECL goes out of scope, make sure that CLEANUP is executed. */
1463 finish_decl_cleanup (tree decl
, tree cleanup
)
1465 push_cleanup (decl
, cleanup
, false);
1468 /* If the current scope exits with an exception, run CLEANUP. */
1471 finish_eh_cleanup (tree cleanup
)
1473 push_cleanup (NULL
, cleanup
, true);
1476 /* The MEM_INITS is a list of mem-initializers, in reverse of the
1477 order they were written by the user. Each node is as for
1478 emit_mem_initializers. */
1481 finish_mem_initializers (tree mem_inits
)
1483 /* Reorder the MEM_INITS so that they are in the order they appeared
1484 in the source program. */
1485 mem_inits
= nreverse (mem_inits
);
1487 if (processing_template_decl
)
1491 for (mem
= mem_inits
; mem
; mem
= TREE_CHAIN (mem
))
1493 /* If the TREE_PURPOSE is a TYPE_PACK_EXPANSION, skip the
1494 check for bare parameter packs in the TREE_VALUE, because
1495 any parameter packs in the TREE_VALUE have already been
1496 bound as part of the TREE_PURPOSE. See
1497 make_pack_expansion for more information. */
1498 if (TREE_CODE (TREE_PURPOSE (mem
)) != TYPE_PACK_EXPANSION
1499 && check_for_bare_parameter_packs (TREE_VALUE (mem
)))
1500 TREE_VALUE (mem
) = error_mark_node
;
1503 add_stmt (build_min_nt_loc (UNKNOWN_LOCATION
,
1504 CTOR_INITIALIZER
, mem_inits
));
1507 emit_mem_initializers (mem_inits
);
1510 /* Finish a parenthesized expression EXPR. */
1513 finish_parenthesized_expr (tree expr
)
1516 /* This inhibits warnings in c_common_truthvalue_conversion. */
1517 TREE_NO_WARNING (expr
) = 1;
1519 if (TREE_CODE (expr
) == OFFSET_REF
1520 || TREE_CODE (expr
) == SCOPE_REF
)
1521 /* [expr.unary.op]/3 The qualified id of a pointer-to-member must not be
1522 enclosed in parentheses. */
1523 PTRMEM_OK_P (expr
) = 0;
1525 if (TREE_CODE (expr
) == STRING_CST
)
1526 PAREN_STRING_LITERAL_P (expr
) = 1;
1531 /* Finish a reference to a non-static data member (DECL) that is not
1532 preceded by `.' or `->'. */
1535 finish_non_static_data_member (tree decl
, tree object
, tree qualifying_scope
)
1537 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
);
1541 tree scope
= qualifying_scope
;
1542 if (scope
== NULL_TREE
)
1543 scope
= context_for_name_lookup (decl
);
1544 object
= maybe_dummy_object (scope
, NULL
);
1547 object
= maybe_resolve_dummy (object
);
1548 if (object
== error_mark_node
)
1549 return error_mark_node
;
1551 /* DR 613: Can use non-static data members without an associated
1552 object in sizeof/decltype/alignof. */
1553 if (is_dummy_object (object
) && cp_unevaluated_operand
== 0
1554 && (!processing_template_decl
|| !current_class_ref
))
1556 if (current_function_decl
1557 && DECL_STATIC_FUNCTION_P (current_function_decl
))
1558 error ("invalid use of member %q+D in static member function", decl
);
1560 error ("invalid use of non-static data member %q+D", decl
);
1561 error ("from this location");
1563 return error_mark_node
;
1566 if (current_class_ptr
)
1567 TREE_USED (current_class_ptr
) = 1;
1568 if (processing_template_decl
&& !qualifying_scope
)
1570 tree type
= TREE_TYPE (decl
);
1572 if (TREE_CODE (type
) == REFERENCE_TYPE
)
1573 /* Quals on the object don't matter. */;
1576 /* Set the cv qualifiers. */
1577 int quals
= cp_type_quals (TREE_TYPE (object
));
1579 if (DECL_MUTABLE_P (decl
))
1580 quals
&= ~TYPE_QUAL_CONST
;
1582 quals
|= cp_type_quals (TREE_TYPE (decl
));
1583 type
= cp_build_qualified_type (type
, quals
);
1586 return (convert_from_reference
1587 (build_min (COMPONENT_REF
, type
, object
, decl
, NULL_TREE
)));
1589 /* If PROCESSING_TEMPLATE_DECL is nonzero here, then
1590 QUALIFYING_SCOPE is also non-null. Wrap this in a SCOPE_REF
1592 else if (processing_template_decl
)
1593 return build_qualified_name (TREE_TYPE (decl
),
1596 /*template_p=*/false);
1599 tree access_type
= TREE_TYPE (object
);
1601 perform_or_defer_access_check (TYPE_BINFO (access_type
), decl
,
1602 decl
, tf_warning_or_error
);
1604 /* If the data member was named `C::M', convert `*this' to `C'
1606 if (qualifying_scope
)
1608 tree binfo
= NULL_TREE
;
1609 object
= build_scoped_ref (object
, qualifying_scope
,
1613 return build_class_member_access_expr (object
, decl
,
1614 /*access_path=*/NULL_TREE
,
1615 /*preserve_reference=*/false,
1616 tf_warning_or_error
);
1620 /* If we are currently parsing a template and we encountered a typedef
1621 TYPEDEF_DECL that is being accessed though CONTEXT, this function
1622 adds the typedef to a list tied to the current template.
1623 At template instantiation time, that list is walked and access check
1624 performed for each typedef.
1625 LOCATION is the location of the usage point of TYPEDEF_DECL. */
1628 add_typedef_to_current_template_for_access_check (tree typedef_decl
,
1630 location_t location
)
1632 tree template_info
= NULL
;
1633 tree cs
= current_scope ();
1635 if (!is_typedef_decl (typedef_decl
)
1637 || !CLASS_TYPE_P (context
)
1641 if (CLASS_TYPE_P (cs
) || TREE_CODE (cs
) == FUNCTION_DECL
)
1642 template_info
= get_template_info (cs
);
1645 && TI_TEMPLATE (template_info
)
1646 && !currently_open_class (context
))
1647 append_type_to_template_for_access_check (cs
, typedef_decl
,
1651 /* DECL was the declaration to which a qualified-id resolved. Issue
1652 an error message if it is not accessible. If OBJECT_TYPE is
1653 non-NULL, we have just seen `x->' or `x.' and OBJECT_TYPE is the
1654 type of `*x', or `x', respectively. If the DECL was named as
1655 `A::B' then NESTED_NAME_SPECIFIER is `A'. */
1658 check_accessibility_of_qualified_id (tree decl
,
1660 tree nested_name_specifier
)
1663 tree qualifying_type
= NULL_TREE
;
1665 /* If we are parsing a template declaration and if decl is a typedef,
1666 add it to a list tied to the template.
1667 At template instantiation time, that list will be walked and
1668 access check performed. */
1669 add_typedef_to_current_template_for_access_check (decl
,
1670 nested_name_specifier
1671 ? nested_name_specifier
1672 : DECL_CONTEXT (decl
),
1675 /* If we're not checking, return immediately. */
1676 if (deferred_access_no_check
)
1679 /* Determine the SCOPE of DECL. */
1680 scope
= context_for_name_lookup (decl
);
1681 /* If the SCOPE is not a type, then DECL is not a member. */
1682 if (!TYPE_P (scope
))
1684 /* Compute the scope through which DECL is being accessed. */
1686 /* OBJECT_TYPE might not be a class type; consider:
1688 class A { typedef int I; };
1692 In this case, we will have "A::I" as the DECL, but "I" as the
1694 && CLASS_TYPE_P (object_type
)
1695 && DERIVED_FROM_P (scope
, object_type
))
1696 /* If we are processing a `->' or `.' expression, use the type of the
1698 qualifying_type
= object_type
;
1699 else if (nested_name_specifier
)
1701 /* If the reference is to a non-static member of the
1702 current class, treat it as if it were referenced through
1704 if (DECL_NONSTATIC_MEMBER_P (decl
)
1705 && current_class_ptr
1706 && DERIVED_FROM_P (scope
, current_class_type
))
1707 qualifying_type
= current_class_type
;
1708 /* Otherwise, use the type indicated by the
1709 nested-name-specifier. */
1711 qualifying_type
= nested_name_specifier
;
1714 /* Otherwise, the name must be from the current class or one of
1716 qualifying_type
= currently_open_derived_class (scope
);
1719 /* It is possible for qualifying type to be a TEMPLATE_TYPE_PARM
1720 or similar in a default argument value. */
1721 && CLASS_TYPE_P (qualifying_type
)
1722 && !dependent_type_p (qualifying_type
))
1723 perform_or_defer_access_check (TYPE_BINFO (qualifying_type
), decl
,
1724 decl
, tf_warning_or_error
);
1727 /* EXPR is the result of a qualified-id. The QUALIFYING_CLASS was the
1728 class named to the left of the "::" operator. DONE is true if this
1729 expression is a complete postfix-expression; it is false if this
1730 expression is followed by '->', '[', '(', etc. ADDRESS_P is true
1731 iff this expression is the operand of '&'. TEMPLATE_P is true iff
1732 the qualified-id was of the form "A::template B". TEMPLATE_ARG_P
1733 is true iff this qualified name appears as a template argument. */
1736 finish_qualified_id_expr (tree qualifying_class
,
1741 bool template_arg_p
)
1743 gcc_assert (TYPE_P (qualifying_class
));
1745 if (error_operand_p (expr
))
1746 return error_mark_node
;
1748 if (DECL_P (expr
) || BASELINK_P (expr
))
1752 check_template_keyword (expr
);
1754 /* If EXPR occurs as the operand of '&', use special handling that
1755 permits a pointer-to-member. */
1756 if (address_p
&& done
)
1758 if (TREE_CODE (expr
) == SCOPE_REF
)
1759 expr
= TREE_OPERAND (expr
, 1);
1760 expr
= build_offset_ref (qualifying_class
, expr
,
1761 /*address_p=*/true);
1765 /* Within the scope of a class, turn references to non-static
1766 members into expression of the form "this->...". */
1768 /* But, within a template argument, we do not want make the
1769 transformation, as there is no "this" pointer. */
1771 else if (TREE_CODE (expr
) == FIELD_DECL
)
1773 push_deferring_access_checks (dk_no_check
);
1774 expr
= finish_non_static_data_member (expr
, NULL_TREE
,
1776 pop_deferring_access_checks ();
1778 else if (BASELINK_P (expr
) && !processing_template_decl
)
1780 /* See if any of the functions are non-static members. */
1781 /* If so, the expression may be relative to 'this'. */
1782 if (!shared_member_p (expr
)
1783 && current_class_ptr
1784 && DERIVED_FROM_P (qualifying_class
,
1785 current_nonlambda_class_type ()))
1786 expr
= (build_class_member_access_expr
1787 (maybe_dummy_object (qualifying_class
, NULL
),
1789 BASELINK_ACCESS_BINFO (expr
),
1790 /*preserve_reference=*/false,
1791 tf_warning_or_error
));
1793 /* The expression is a qualified name whose address is not
1795 expr
= build_offset_ref (qualifying_class
, expr
, /*address_p=*/false);
1797 else if (BASELINK_P (expr
))
1801 /* In a template, return a SCOPE_REF for most qualified-ids
1802 so that we can check access at instantiation time. But if
1803 we're looking at a member of the current instantiation, we
1804 know we have access and building up the SCOPE_REF confuses
1805 non-type template argument handling. */
1806 if (processing_template_decl
1807 && !currently_open_class (qualifying_class
))
1808 expr
= build_qualified_name (TREE_TYPE (expr
),
1809 qualifying_class
, expr
,
1812 expr
= convert_from_reference (expr
);
1818 /* Begin a statement-expression. The value returned must be passed to
1819 finish_stmt_expr. */
1822 begin_stmt_expr (void)
1824 return push_stmt_list ();
1827 /* Process the final expression of a statement expression. EXPR can be
1828 NULL, if the final expression is empty. Return a STATEMENT_LIST
1829 containing all the statements in the statement-expression, or
1830 ERROR_MARK_NODE if there was an error. */
1833 finish_stmt_expr_expr (tree expr
, tree stmt_expr
)
1835 if (error_operand_p (expr
))
1837 /* The type of the statement-expression is the type of the last
1839 TREE_TYPE (stmt_expr
) = error_mark_node
;
1840 return error_mark_node
;
1843 /* If the last statement does not have "void" type, then the value
1844 of the last statement is the value of the entire expression. */
1847 tree type
= TREE_TYPE (expr
);
1849 if (processing_template_decl
)
1851 expr
= build_stmt (input_location
, EXPR_STMT
, expr
);
1852 expr
= add_stmt (expr
);
1853 /* Mark the last statement so that we can recognize it as such at
1854 template-instantiation time. */
1855 EXPR_STMT_STMT_EXPR_RESULT (expr
) = 1;
1857 else if (VOID_TYPE_P (type
))
1859 /* Just treat this like an ordinary statement. */
1860 expr
= finish_expr_stmt (expr
);
1864 /* It actually has a value we need to deal with. First, force it
1865 to be an rvalue so that we won't need to build up a copy
1866 constructor call later when we try to assign it to something. */
1867 expr
= force_rvalue (expr
, tf_warning_or_error
);
1868 if (error_operand_p (expr
))
1869 return error_mark_node
;
1871 /* Update for array-to-pointer decay. */
1872 type
= TREE_TYPE (expr
);
1874 /* Wrap it in a CLEANUP_POINT_EXPR and add it to the list like a
1875 normal statement, but don't convert to void or actually add
1877 if (TREE_CODE (expr
) != CLEANUP_POINT_EXPR
)
1878 expr
= maybe_cleanup_point_expr (expr
);
1882 /* The type of the statement-expression is the type of the last
1884 TREE_TYPE (stmt_expr
) = type
;
1890 /* Finish a statement-expression. EXPR should be the value returned
1891 by the previous begin_stmt_expr. Returns an expression
1892 representing the statement-expression. */
1895 finish_stmt_expr (tree stmt_expr
, bool has_no_scope
)
1900 if (error_operand_p (stmt_expr
))
1902 pop_stmt_list (stmt_expr
);
1903 return error_mark_node
;
1906 gcc_assert (TREE_CODE (stmt_expr
) == STATEMENT_LIST
);
1908 type
= TREE_TYPE (stmt_expr
);
1909 result
= pop_stmt_list (stmt_expr
);
1910 TREE_TYPE (result
) = type
;
1912 if (processing_template_decl
)
1914 result
= build_min (STMT_EXPR
, type
, result
);
1915 TREE_SIDE_EFFECTS (result
) = 1;
1916 STMT_EXPR_NO_SCOPE (result
) = has_no_scope
;
1918 else if (CLASS_TYPE_P (type
))
1920 /* Wrap the statement-expression in a TARGET_EXPR so that the
1921 temporary object created by the final expression is destroyed at
1922 the end of the full-expression containing the
1923 statement-expression. */
1924 result
= force_target_expr (type
, result
, tf_warning_or_error
);
1930 /* Returns the expression which provides the value of STMT_EXPR. */
1933 stmt_expr_value_expr (tree stmt_expr
)
1935 tree t
= STMT_EXPR_STMT (stmt_expr
);
1937 if (TREE_CODE (t
) == BIND_EXPR
)
1938 t
= BIND_EXPR_BODY (t
);
1940 if (TREE_CODE (t
) == STATEMENT_LIST
&& STATEMENT_LIST_TAIL (t
))
1941 t
= STATEMENT_LIST_TAIL (t
)->stmt
;
1943 if (TREE_CODE (t
) == EXPR_STMT
)
1944 t
= EXPR_STMT_EXPR (t
);
1949 /* Return TRUE iff EXPR_STMT is an empty list of
1950 expression statements. */
1953 empty_expr_stmt_p (tree expr_stmt
)
1955 tree body
= NULL_TREE
;
1957 if (expr_stmt
== void_zero_node
)
1962 if (TREE_CODE (expr_stmt
) == EXPR_STMT
)
1963 body
= EXPR_STMT_EXPR (expr_stmt
);
1964 else if (TREE_CODE (expr_stmt
) == STATEMENT_LIST
)
1970 if (TREE_CODE (body
) == STATEMENT_LIST
)
1971 return tsi_end_p (tsi_start (body
));
1973 return empty_expr_stmt_p (body
);
1978 /* Perform Koenig lookup. FN is the postfix-expression representing
1979 the function (or functions) to call; ARGS are the arguments to the
1980 call; if INCLUDE_STD then the `std' namespace is automatically
1981 considered an associated namespace (used in range-based for loops).
1982 Returns the functions to be considered by overload resolution. */
1985 perform_koenig_lookup (tree fn
, vec
<tree
, va_gc
> *args
, bool include_std
,
1986 tsubst_flags_t complain
)
1988 tree identifier
= NULL_TREE
;
1989 tree functions
= NULL_TREE
;
1990 tree tmpl_args
= NULL_TREE
;
1991 bool template_id
= false;
1993 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
1995 /* Use a separate flag to handle null args. */
1997 tmpl_args
= TREE_OPERAND (fn
, 1);
1998 fn
= TREE_OPERAND (fn
, 0);
2001 /* Find the name of the overloaded function. */
2002 if (identifier_p (fn
))
2004 else if (is_overloaded_fn (fn
))
2007 identifier
= DECL_NAME (get_first_fn (functions
));
2009 else if (DECL_P (fn
))
2012 identifier
= DECL_NAME (fn
);
2015 /* A call to a namespace-scope function using an unqualified name.
2017 Do Koenig lookup -- unless any of the arguments are
2019 if (!any_type_dependent_arguments_p (args
)
2020 && !any_dependent_template_arguments_p (tmpl_args
))
2022 fn
= lookup_arg_dependent (identifier
, functions
, args
, include_std
);
2025 /* The unqualified name could not be resolved. */
2027 fn
= unqualified_fn_lookup_error (identifier
);
2033 if (fn
&& template_id
)
2034 fn
= build2 (TEMPLATE_ID_EXPR
, unknown_type_node
, fn
, tmpl_args
);
2039 /* Generate an expression for `FN (ARGS)'. This may change the
2042 If DISALLOW_VIRTUAL is true, the call to FN will be not generated
2043 as a virtual call, even if FN is virtual. (This flag is set when
2044 encountering an expression where the function name is explicitly
2045 qualified. For example a call to `X::f' never generates a virtual
2048 Returns code for the call. */
2051 finish_call_expr (tree fn
, vec
<tree
, va_gc
> **args
, bool disallow_virtual
,
2052 bool koenig_p
, tsubst_flags_t complain
)
2056 vec
<tree
, va_gc
> *orig_args
= NULL
;
2058 if (fn
== error_mark_node
)
2059 return error_mark_node
;
2061 gcc_assert (!TYPE_P (fn
));
2065 if (processing_template_decl
)
2067 /* If the call expression is dependent, build a CALL_EXPR node
2068 with no type; type_dependent_expression_p recognizes
2069 expressions with no type as being dependent. */
2070 if (type_dependent_expression_p (fn
)
2071 || any_type_dependent_arguments_p (*args
)
2072 /* For a non-static member function that doesn't have an
2073 explicit object argument, we need to specifically
2074 test the type dependency of the "this" pointer because it
2075 is not included in *ARGS even though it is considered to
2076 be part of the list of arguments. Note that this is
2077 related to CWG issues 515 and 1005. */
2078 || (TREE_CODE (fn
) != COMPONENT_REF
2079 && non_static_member_function_p (fn
)
2080 && current_class_ref
2081 && type_dependent_expression_p (current_class_ref
)))
2083 result
= build_nt_call_vec (fn
, *args
);
2084 SET_EXPR_LOCATION (result
, EXPR_LOC_OR_HERE (fn
));
2085 KOENIG_LOOKUP_P (result
) = koenig_p
;
2090 tree fndecl
= OVL_CURRENT (fn
);
2091 if (TREE_CODE (fndecl
) != FUNCTION_DECL
2092 || !TREE_THIS_VOLATILE (fndecl
))
2098 current_function_returns_abnormally
= 1;
2102 orig_args
= make_tree_vector_copy (*args
);
2103 if (!BASELINK_P (fn
)
2104 && TREE_CODE (fn
) != PSEUDO_DTOR_EXPR
2105 && TREE_TYPE (fn
) != unknown_type_node
)
2106 fn
= build_non_dependent_expr (fn
);
2107 make_args_non_dependent (*args
);
2110 if (TREE_CODE (fn
) == COMPONENT_REF
)
2112 tree member
= TREE_OPERAND (fn
, 1);
2113 if (BASELINK_P (member
))
2115 tree object
= TREE_OPERAND (fn
, 0);
2116 return build_new_method_call (object
, member
,
2119 ? LOOKUP_NORMAL
| LOOKUP_NONVIRTUAL
2126 if (is_overloaded_fn (fn
))
2127 fn
= baselink_for_fns (fn
);
2130 if (BASELINK_P (fn
))
2134 /* A call to a member function. From [over.call.func]:
2136 If the keyword this is in scope and refers to the class of
2137 that member function, or a derived class thereof, then the
2138 function call is transformed into a qualified function call
2139 using (*this) as the postfix-expression to the left of the
2140 . operator.... [Otherwise] a contrived object of type T
2141 becomes the implied object argument.
2145 struct A { void f(); };
2146 struct B : public A {};
2147 struct C : public A { void g() { B::f(); }};
2149 "the class of that member function" refers to `A'. But 11.2
2150 [class.access.base] says that we need to convert 'this' to B* as
2151 part of the access, so we pass 'B' to maybe_dummy_object. */
2153 object
= maybe_dummy_object (BINFO_TYPE (BASELINK_ACCESS_BINFO (fn
)),
2156 if (processing_template_decl
)
2158 if (type_dependent_expression_p (object
))
2160 tree ret
= build_nt_call_vec (orig_fn
, orig_args
);
2161 release_tree_vector (orig_args
);
2164 object
= build_non_dependent_expr (object
);
2167 result
= build_new_method_call (object
, fn
, args
, NULL_TREE
,
2169 ? LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
2174 else if (is_overloaded_fn (fn
))
2176 /* If the function is an overloaded builtin, resolve it. */
2177 if (TREE_CODE (fn
) == FUNCTION_DECL
2178 && (DECL_BUILT_IN_CLASS (fn
) == BUILT_IN_NORMAL
2179 || DECL_BUILT_IN_CLASS (fn
) == BUILT_IN_MD
))
2180 result
= resolve_overloaded_builtin (input_location
, fn
, *args
);
2184 if (warn_sizeof_pointer_memaccess
2185 && !vec_safe_is_empty (*args
)
2186 && !processing_template_decl
)
2188 location_t sizeof_arg_loc
[3];
2191 for (i
= 0; i
< 3; i
++)
2195 sizeof_arg_loc
[i
] = UNKNOWN_LOCATION
;
2196 sizeof_arg
[i
] = NULL_TREE
;
2197 if (i
>= (*args
)->length ())
2200 if (TREE_CODE (t
) != SIZEOF_EXPR
)
2202 if (SIZEOF_EXPR_TYPE_P (t
))
2203 sizeof_arg
[i
] = TREE_TYPE (TREE_OPERAND (t
, 0));
2205 sizeof_arg
[i
] = TREE_OPERAND (t
, 0);
2206 sizeof_arg_loc
[i
] = EXPR_LOCATION (t
);
2208 sizeof_pointer_memaccess_warning
2209 (sizeof_arg_loc
, fn
, *args
,
2210 sizeof_arg
, same_type_ignoring_top_level_qualifiers_p
);
2213 /* A call to a namespace-scope function. */
2214 result
= build_new_function_call (fn
, args
, koenig_p
, complain
);
2217 else if (TREE_CODE (fn
) == PSEUDO_DTOR_EXPR
)
2219 if (!vec_safe_is_empty (*args
))
2220 error ("arguments to destructor are not allowed");
2221 /* Mark the pseudo-destructor call as having side-effects so
2222 that we do not issue warnings about its use. */
2223 result
= build1 (NOP_EXPR
,
2225 TREE_OPERAND (fn
, 0));
2226 TREE_SIDE_EFFECTS (result
) = 1;
2228 else if (CLASS_TYPE_P (TREE_TYPE (fn
)))
2229 /* If the "function" is really an object of class type, it might
2230 have an overloaded `operator ()'. */
2231 result
= build_op_call (fn
, args
, complain
);
2234 /* A call where the function is unknown. */
2235 result
= cp_build_function_call_vec (fn
, args
, complain
);
2237 if (processing_template_decl
&& result
!= error_mark_node
)
2239 if (TREE_CODE (result
) == INDIRECT_REF
)
2240 result
= TREE_OPERAND (result
, 0);
2241 result
= build_call_vec (TREE_TYPE (result
), orig_fn
, orig_args
);
2242 SET_EXPR_LOCATION (result
, input_location
);
2243 KOENIG_LOOKUP_P (result
) = koenig_p
;
2244 release_tree_vector (orig_args
);
2245 result
= convert_from_reference (result
);
2250 /* Free garbage OVERLOADs from arg-dependent lookup. */
2251 tree next
= NULL_TREE
;
2253 fn
&& TREE_CODE (fn
) == OVERLOAD
&& OVL_ARG_DEPENDENT (fn
);
2256 if (processing_template_decl
)
2257 /* In a template, we'll re-use them at instantiation time. */
2258 OVL_ARG_DEPENDENT (fn
) = false;
2261 next
= OVL_CHAIN (fn
);
2270 /* Finish a call to a postfix increment or decrement or EXPR. (Which
2271 is indicated by CODE, which should be POSTINCREMENT_EXPR or
2272 POSTDECREMENT_EXPR.) */
2275 finish_increment_expr (tree expr
, enum tree_code code
)
2277 return build_x_unary_op (input_location
, code
, expr
, tf_warning_or_error
);
2280 /* Finish a use of `this'. Returns an expression for `this'. */
2283 finish_this_expr (void)
2287 if (current_class_ptr
)
2289 tree type
= TREE_TYPE (current_class_ref
);
2291 /* In a lambda expression, 'this' refers to the captured 'this'. */
2292 if (LAMBDA_TYPE_P (type
))
2293 result
= lambda_expr_this_capture (CLASSTYPE_LAMBDA_EXPR (type
));
2295 result
= current_class_ptr
;
2298 else if (current_function_decl
2299 && DECL_STATIC_FUNCTION_P (current_function_decl
))
2301 error ("%<this%> is unavailable for static member functions");
2302 result
= error_mark_node
;
2306 if (current_function_decl
)
2307 error ("invalid use of %<this%> in non-member function");
2309 error ("invalid use of %<this%> at top level");
2310 result
= error_mark_node
;
2316 /* Finish a pseudo-destructor expression. If SCOPE is NULL, the
2317 expression was of the form `OBJECT.~DESTRUCTOR' where DESTRUCTOR is
2318 the TYPE for the type given. If SCOPE is non-NULL, the expression
2319 was of the form `OBJECT.SCOPE::~DESTRUCTOR'. */
2322 finish_pseudo_destructor_expr (tree object
, tree scope
, tree destructor
)
2324 if (object
== error_mark_node
|| destructor
== error_mark_node
)
2325 return error_mark_node
;
2327 gcc_assert (TYPE_P (destructor
));
2329 if (!processing_template_decl
)
2331 if (scope
== error_mark_node
)
2333 error ("invalid qualifying scope in pseudo-destructor name");
2334 return error_mark_node
;
2336 if (scope
&& TYPE_P (scope
) && !check_dtor_name (scope
, destructor
))
2338 error ("qualified type %qT does not match destructor name ~%qT",
2340 return error_mark_node
;
2344 /* [expr.pseudo] says both:
2346 The type designated by the pseudo-destructor-name shall be
2347 the same as the object type.
2351 The cv-unqualified versions of the object type and of the
2352 type designated by the pseudo-destructor-name shall be the
2355 We implement the more generous second sentence, since that is
2356 what most other compilers do. */
2357 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (object
),
2360 error ("%qE is not of type %qT", object
, destructor
);
2361 return error_mark_node
;
2365 return build3 (PSEUDO_DTOR_EXPR
, void_type_node
, object
, scope
, destructor
);
2368 /* Finish an expression of the form CODE EXPR. */
2371 finish_unary_op_expr (location_t loc
, enum tree_code code
, tree expr
)
2373 tree result
= build_x_unary_op (loc
, code
, expr
, tf_warning_or_error
);
2374 if (TREE_OVERFLOW_P (result
) && !TREE_OVERFLOW_P (expr
))
2375 overflow_warning (input_location
, result
);
2380 /* Finish a compound-literal expression. TYPE is the type to which
2381 the CONSTRUCTOR in COMPOUND_LITERAL is being cast. */
2384 finish_compound_literal (tree type
, tree compound_literal
,
2385 tsubst_flags_t complain
)
2387 if (type
== error_mark_node
)
2388 return error_mark_node
;
2390 if (TREE_CODE (type
) == REFERENCE_TYPE
)
2393 = finish_compound_literal (TREE_TYPE (type
), compound_literal
,
2395 return cp_build_c_cast (type
, compound_literal
, complain
);
2398 if (!TYPE_OBJ_P (type
))
2400 if (complain
& tf_error
)
2401 error ("compound literal of non-object type %qT", type
);
2402 return error_mark_node
;
2405 if (processing_template_decl
)
2407 TREE_TYPE (compound_literal
) = type
;
2408 /* Mark the expression as a compound literal. */
2409 TREE_HAS_CONSTRUCTOR (compound_literal
) = 1;
2410 return compound_literal
;
2413 type
= complete_type (type
);
2415 if (TYPE_NON_AGGREGATE_CLASS (type
))
2417 /* Trying to deal with a CONSTRUCTOR instead of a TREE_LIST
2418 everywhere that deals with function arguments would be a pain, so
2419 just wrap it in a TREE_LIST. The parser set a flag so we know
2420 that it came from T{} rather than T({}). */
2421 CONSTRUCTOR_IS_DIRECT_INIT (compound_literal
) = 1;
2422 compound_literal
= build_tree_list (NULL_TREE
, compound_literal
);
2423 return build_functional_cast (type
, compound_literal
, complain
);
2426 if (TREE_CODE (type
) == ARRAY_TYPE
2427 && check_array_initializer (NULL_TREE
, type
, compound_literal
))
2428 return error_mark_node
;
2429 compound_literal
= reshape_init (type
, compound_literal
, complain
);
2430 if (SCALAR_TYPE_P (type
)
2431 && !BRACE_ENCLOSED_INITIALIZER_P (compound_literal
)
2432 && (complain
& tf_warning_or_error
))
2433 check_narrowing (type
, compound_literal
);
2434 if (TREE_CODE (type
) == ARRAY_TYPE
2435 && TYPE_DOMAIN (type
) == NULL_TREE
)
2437 cp_complete_array_type_or_error (&type
, compound_literal
,
2439 if (type
== error_mark_node
)
2440 return error_mark_node
;
2442 compound_literal
= digest_init (type
, compound_literal
, complain
);
2443 if (TREE_CODE (compound_literal
) == CONSTRUCTOR
)
2444 TREE_HAS_CONSTRUCTOR (compound_literal
) = true;
2445 /* Put static/constant array temporaries in static variables, but always
2446 represent class temporaries with TARGET_EXPR so we elide copies. */
2447 if ((!at_function_scope_p () || CP_TYPE_CONST_P (type
))
2448 && TREE_CODE (type
) == ARRAY_TYPE
2449 && !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
2450 && initializer_constant_valid_p (compound_literal
, type
))
2452 tree decl
= create_temporary_var (type
);
2453 DECL_INITIAL (decl
) = compound_literal
;
2454 TREE_STATIC (decl
) = 1;
2455 if (literal_type_p (type
) && CP_TYPE_CONST_NON_VOLATILE_P (type
))
2457 /* 5.19 says that a constant expression can include an
2458 lvalue-rvalue conversion applied to "a glvalue of literal type
2459 that refers to a non-volatile temporary object initialized
2460 with a constant expression". Rather than try to communicate
2461 that this VAR_DECL is a temporary, just mark it constexpr. */
2462 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
2463 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = true;
2464 TREE_CONSTANT (decl
) = true;
2466 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
2467 decl
= pushdecl_top_level (decl
);
2468 DECL_NAME (decl
) = make_anon_name ();
2469 SET_DECL_ASSEMBLER_NAME (decl
, DECL_NAME (decl
));
2473 return get_target_expr_sfinae (compound_literal
, complain
);
2476 /* Return the declaration for the function-name variable indicated by
2480 finish_fname (tree id
)
2484 decl
= fname_decl (input_location
, C_RID_CODE (id
), id
);
2485 if (processing_template_decl
&& current_function_decl
)
2486 decl
= DECL_NAME (decl
);
2490 /* Finish a translation unit. */
2493 finish_translation_unit (void)
2495 /* In case there were missing closebraces,
2496 get us back to the global binding level. */
2498 while (current_namespace
!= global_namespace
)
2501 /* Do file scope __FUNCTION__ et al. */
2502 finish_fname_decls ();
2505 /* Finish a template type parameter, specified as AGGR IDENTIFIER.
2506 Returns the parameter. */
2509 finish_template_type_parm (tree aggr
, tree identifier
)
2511 if (aggr
!= class_type_node
)
2513 permerror (input_location
, "template type parameters must use the keyword %<class%> or %<typename%>");
2514 aggr
= class_type_node
;
2517 return build_tree_list (aggr
, identifier
);
2520 /* Finish a template template parameter, specified as AGGR IDENTIFIER.
2521 Returns the parameter. */
2524 finish_template_template_parm (tree aggr
, tree identifier
)
2526 tree decl
= build_decl (input_location
,
2527 TYPE_DECL
, identifier
, NULL_TREE
);
2528 tree tmpl
= build_lang_decl (TEMPLATE_DECL
, identifier
, NULL_TREE
);
2529 DECL_TEMPLATE_PARMS (tmpl
) = current_template_parms
;
2530 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
2531 DECL_ARTIFICIAL (decl
) = 1;
2532 end_template_decl ();
2534 gcc_assert (DECL_TEMPLATE_PARMS (tmpl
));
2536 check_default_tmpl_args (decl
, DECL_TEMPLATE_PARMS (tmpl
),
2537 /*is_primary=*/true, /*is_partial=*/false,
2540 return finish_template_type_parm (aggr
, tmpl
);
2543 /* ARGUMENT is the default-argument value for a template template
2544 parameter. If ARGUMENT is invalid, issue error messages and return
2545 the ERROR_MARK_NODE. Otherwise, ARGUMENT itself is returned. */
2548 check_template_template_default_arg (tree argument
)
2550 if (TREE_CODE (argument
) != TEMPLATE_DECL
2551 && TREE_CODE (argument
) != TEMPLATE_TEMPLATE_PARM
2552 && TREE_CODE (argument
) != UNBOUND_CLASS_TEMPLATE
)
2554 if (TREE_CODE (argument
) == TYPE_DECL
)
2555 error ("invalid use of type %qT as a default value for a template "
2556 "template-parameter", TREE_TYPE (argument
));
2558 error ("invalid default argument for a template template parameter");
2559 return error_mark_node
;
2565 /* Begin a class definition, as indicated by T. */
2568 begin_class_definition (tree t
)
2570 if (error_operand_p (t
) || error_operand_p (TYPE_MAIN_DECL (t
)))
2571 return error_mark_node
;
2573 if (processing_template_parmlist
)
2575 error ("definition of %q#T inside template parameter list", t
);
2576 return error_mark_node
;
2579 /* According to the C++ ABI, decimal classes defined in ISO/IEC TR 24733
2580 are passed the same as decimal scalar types. */
2581 if (TREE_CODE (t
) == RECORD_TYPE
2582 && !processing_template_decl
)
2584 tree ns
= TYPE_CONTEXT (t
);
2585 if (ns
&& TREE_CODE (ns
) == NAMESPACE_DECL
2586 && DECL_CONTEXT (ns
) == std_node
2588 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (ns
)), "decimal"))
2590 const char *n
= TYPE_NAME_STRING (t
);
2591 if ((strcmp (n
, "decimal32") == 0)
2592 || (strcmp (n
, "decimal64") == 0)
2593 || (strcmp (n
, "decimal128") == 0))
2594 TYPE_TRANSPARENT_AGGR (t
) = 1;
2598 /* A non-implicit typename comes from code like:
2600 template <typename T> struct A {
2601 template <typename U> struct A<T>::B ...
2603 This is erroneous. */
2604 else if (TREE_CODE (t
) == TYPENAME_TYPE
)
2606 error ("invalid definition of qualified type %qT", t
);
2607 t
= error_mark_node
;
2610 if (t
== error_mark_node
|| ! MAYBE_CLASS_TYPE_P (t
))
2612 t
= make_class_type (RECORD_TYPE
);
2613 pushtag (make_anon_name (), t
, /*tag_scope=*/ts_current
);
2616 if (TYPE_BEING_DEFINED (t
))
2618 t
= make_class_type (TREE_CODE (t
));
2619 pushtag (TYPE_IDENTIFIER (t
), t
, /*tag_scope=*/ts_current
);
2621 maybe_process_partial_specialization (t
);
2623 TYPE_BEING_DEFINED (t
) = 1;
2625 if (flag_pack_struct
)
2628 TYPE_PACKED (t
) = 1;
2629 /* Even though the type is being defined for the first time
2630 here, there might have been a forward declaration, so there
2631 might be cv-qualified variants of T. */
2632 for (v
= TYPE_NEXT_VARIANT (t
); v
; v
= TYPE_NEXT_VARIANT (v
))
2633 TYPE_PACKED (v
) = 1;
2635 /* Reset the interface data, at the earliest possible
2636 moment, as it might have been set via a class foo;
2638 if (! TYPE_ANONYMOUS_P (t
))
2640 struct c_fileinfo
*finfo
= get_fileinfo (input_filename
);
2641 CLASSTYPE_INTERFACE_ONLY (t
) = finfo
->interface_only
;
2642 SET_CLASSTYPE_INTERFACE_UNKNOWN_X
2643 (t
, finfo
->interface_unknown
);
2645 reset_specialization();
2647 /* Make a declaration for this class in its own scope. */
2648 build_self_reference ();
2653 /* Finish the member declaration given by DECL. */
2656 finish_member_declaration (tree decl
)
2658 if (decl
== error_mark_node
|| decl
== NULL_TREE
)
2661 if (decl
== void_type_node
)
2662 /* The COMPONENT was a friend, not a member, and so there's
2663 nothing for us to do. */
2666 /* We should see only one DECL at a time. */
2667 gcc_assert (DECL_CHAIN (decl
) == NULL_TREE
);
2669 /* Set up access control for DECL. */
2671 = (current_access_specifier
== access_private_node
);
2672 TREE_PROTECTED (decl
)
2673 = (current_access_specifier
== access_protected_node
);
2674 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
2676 TREE_PRIVATE (DECL_TEMPLATE_RESULT (decl
)) = TREE_PRIVATE (decl
);
2677 TREE_PROTECTED (DECL_TEMPLATE_RESULT (decl
)) = TREE_PROTECTED (decl
);
2680 /* Mark the DECL as a member of the current class, unless it's
2681 a member of an enumeration. */
2682 if (TREE_CODE (decl
) != CONST_DECL
)
2683 DECL_CONTEXT (decl
) = current_class_type
;
2685 /* Check for bare parameter packs in the member variable declaration. */
2686 if (TREE_CODE (decl
) == FIELD_DECL
)
2688 if (check_for_bare_parameter_packs (TREE_TYPE (decl
)))
2689 TREE_TYPE (decl
) = error_mark_node
;
2690 if (check_for_bare_parameter_packs (DECL_ATTRIBUTES (decl
)))
2691 DECL_ATTRIBUTES (decl
) = NULL_TREE
;
2696 A C language linkage is ignored for the names of class members
2697 and the member function type of class member functions. */
2698 if (DECL_LANG_SPECIFIC (decl
) && DECL_LANGUAGE (decl
) == lang_c
)
2699 SET_DECL_LANGUAGE (decl
, lang_cplusplus
);
2701 /* Put functions on the TYPE_METHODS list and everything else on the
2702 TYPE_FIELDS list. Note that these are built up in reverse order.
2703 We reverse them (to obtain declaration order) in finish_struct. */
2704 if (TREE_CODE (decl
) == FUNCTION_DECL
2705 || DECL_FUNCTION_TEMPLATE_P (decl
))
2707 /* We also need to add this function to the
2708 CLASSTYPE_METHOD_VEC. */
2709 if (add_method (current_class_type
, decl
, NULL_TREE
))
2711 DECL_CHAIN (decl
) = TYPE_METHODS (current_class_type
);
2712 TYPE_METHODS (current_class_type
) = decl
;
2714 maybe_add_class_template_decl_list (current_class_type
, decl
,
2718 /* Enter the DECL into the scope of the class. */
2719 else if (pushdecl_class_level (decl
))
2721 if (TREE_CODE (decl
) == USING_DECL
)
2723 /* For now, ignore class-scope USING_DECLS, so that
2724 debugging backends do not see them. */
2725 DECL_IGNORED_P (decl
) = 1;
2728 /* All TYPE_DECLs go at the end of TYPE_FIELDS. Ordinary fields
2729 go at the beginning. The reason is that lookup_field_1
2730 searches the list in order, and we want a field name to
2731 override a type name so that the "struct stat hack" will
2732 work. In particular:
2734 struct S { enum E { }; int E } s;
2737 is valid. In addition, the FIELD_DECLs must be maintained in
2738 declaration order so that class layout works as expected.
2739 However, we don't need that order until class layout, so we
2740 save a little time by putting FIELD_DECLs on in reverse order
2741 here, and then reversing them in finish_struct_1. (We could
2742 also keep a pointer to the correct insertion points in the
2745 if (TREE_CODE (decl
) == TYPE_DECL
)
2746 TYPE_FIELDS (current_class_type
)
2747 = chainon (TYPE_FIELDS (current_class_type
), decl
);
2750 DECL_CHAIN (decl
) = TYPE_FIELDS (current_class_type
);
2751 TYPE_FIELDS (current_class_type
) = decl
;
2754 maybe_add_class_template_decl_list (current_class_type
, decl
,
2759 note_decl_for_pch (decl
);
2762 /* DECL has been declared while we are building a PCH file. Perform
2763 actions that we might normally undertake lazily, but which can be
2764 performed now so that they do not have to be performed in
2765 translation units which include the PCH file. */
2768 note_decl_for_pch (tree decl
)
2770 gcc_assert (pch_file
);
2772 /* There's a good chance that we'll have to mangle names at some
2773 point, even if only for emission in debugging information. */
2774 if (VAR_OR_FUNCTION_DECL_P (decl
)
2775 && !processing_template_decl
)
2779 /* Finish processing a complete template declaration. The PARMS are
2780 the template parameters. */
2783 finish_template_decl (tree parms
)
2786 end_template_decl ();
2788 end_specialization ();
2791 /* Finish processing a template-id (which names a type) of the form
2792 NAME < ARGS >. Return the TYPE_DECL for the type named by the
2793 template-id. If ENTERING_SCOPE is nonzero we are about to enter
2794 the scope of template-id indicated. */
2797 finish_template_type (tree name
, tree args
, int entering_scope
)
2801 type
= lookup_template_class (name
, args
,
2802 NULL_TREE
, NULL_TREE
, entering_scope
,
2803 tf_warning_or_error
| tf_user
);
2804 if (type
== error_mark_node
)
2806 else if (CLASS_TYPE_P (type
) && !alias_type_or_template_p (type
))
2807 return TYPE_STUB_DECL (type
);
2809 return TYPE_NAME (type
);
2812 /* Finish processing a BASE_CLASS with the indicated ACCESS_SPECIFIER.
2813 Return a TREE_LIST containing the ACCESS_SPECIFIER and the
2814 BASE_CLASS, or NULL_TREE if an error occurred. The
2815 ACCESS_SPECIFIER is one of
2816 access_{default,public,protected_private}_node. For a virtual base
2817 we set TREE_TYPE. */
2820 finish_base_specifier (tree base
, tree access
, bool virtual_p
)
2824 if (base
== error_mark_node
)
2826 error ("invalid base-class specification");
2829 else if (! MAYBE_CLASS_TYPE_P (base
))
2831 error ("%qT is not a class type", base
);
2836 if (cp_type_quals (base
) != 0)
2838 /* DR 484: Can a base-specifier name a cv-qualified
2840 base
= TYPE_MAIN_VARIANT (base
);
2842 result
= build_tree_list (access
, base
);
2844 TREE_TYPE (result
) = integer_type_node
;
2850 /* If FNS is a member function, a set of member functions, or a
2851 template-id referring to one or more member functions, return a
2852 BASELINK for FNS, incorporating the current access context.
2853 Otherwise, return FNS unchanged. */
2856 baselink_for_fns (tree fns
)
2861 if (BASELINK_P (fns
)
2862 || error_operand_p (fns
))
2865 scope
= ovl_scope (fns
);
2866 if (!CLASS_TYPE_P (scope
))
2869 cl
= currently_open_derived_class (scope
);
2872 cl
= TYPE_BINFO (cl
);
2873 return build_baselink (cl
, cl
, fns
, /*optype=*/NULL_TREE
);
2876 /* Returns true iff DECL is a variable from a function outside
2880 outer_var_p (tree decl
)
2882 return ((TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == PARM_DECL
)
2883 && DECL_FUNCTION_SCOPE_P (decl
)
2884 && (DECL_CONTEXT (decl
) != current_function_decl
2885 || parsing_nsdmi ()));
2888 /* As above, but also checks that DECL is automatic. */
2891 outer_automatic_var_p (tree decl
)
2893 return (outer_var_p (decl
)
2894 && !TREE_STATIC (decl
));
2897 /* ID_EXPRESSION is a representation of parsed, but unprocessed,
2898 id-expression. (See cp_parser_id_expression for details.) SCOPE,
2899 if non-NULL, is the type or namespace used to explicitly qualify
2900 ID_EXPRESSION. DECL is the entity to which that name has been
2903 *CONSTANT_EXPRESSION_P is true if we are presently parsing a
2904 constant-expression. In that case, *NON_CONSTANT_EXPRESSION_P will
2905 be set to true if this expression isn't permitted in a
2906 constant-expression, but it is otherwise not set by this function.
2907 *ALLOW_NON_CONSTANT_EXPRESSION_P is true if we are parsing a
2908 constant-expression, but a non-constant expression is also
2911 DONE is true if this expression is a complete postfix-expression;
2912 it is false if this expression is followed by '->', '[', '(', etc.
2913 ADDRESS_P is true iff this expression is the operand of '&'.
2914 TEMPLATE_P is true iff the qualified-id was of the form
2915 "A::template B". TEMPLATE_ARG_P is true iff this qualified name
2916 appears as a template argument.
2918 If an error occurs, and it is the kind of error that might cause
2919 the parser to abort a tentative parse, *ERROR_MSG is filled in. It
2920 is the caller's responsibility to issue the message. *ERROR_MSG
2921 will be a string with static storage duration, so the caller need
2924 Return an expression for the entity, after issuing appropriate
2925 diagnostics. This function is also responsible for transforming a
2926 reference to a non-static member into a COMPONENT_REF that makes
2927 the use of "this" explicit.
2929 Upon return, *IDK will be filled in appropriately. */
2931 finish_id_expression (tree id_expression
,
2935 bool integral_constant_expression_p
,
2936 bool allow_non_integral_constant_expression_p
,
2937 bool *non_integral_constant_expression_p
,
2941 bool template_arg_p
,
2942 const char **error_msg
,
2943 location_t location
)
2945 decl
= strip_using_decl (decl
);
2947 /* Initialize the output parameters. */
2948 *idk
= CP_ID_KIND_NONE
;
2951 if (id_expression
== error_mark_node
)
2952 return error_mark_node
;
2953 /* If we have a template-id, then no further lookup is
2954 required. If the template-id was for a template-class, we
2955 will sometimes have a TYPE_DECL at this point. */
2956 else if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
2957 || TREE_CODE (decl
) == TYPE_DECL
)
2959 /* Look up the name. */
2962 if (decl
== error_mark_node
)
2964 /* Name lookup failed. */
2967 || (!dependent_type_p (scope
)
2968 && !(identifier_p (id_expression
)
2969 && IDENTIFIER_TYPENAME_P (id_expression
)
2970 && dependent_type_p (TREE_TYPE (id_expression
))))))
2972 /* If the qualifying type is non-dependent (and the name
2973 does not name a conversion operator to a dependent
2974 type), issue an error. */
2975 qualified_name_lookup_error (scope
, id_expression
, decl
, location
);
2976 return error_mark_node
;
2980 /* It may be resolved via Koenig lookup. */
2981 *idk
= CP_ID_KIND_UNQUALIFIED
;
2982 return id_expression
;
2985 decl
= id_expression
;
2987 /* If DECL is a variable that would be out of scope under
2988 ANSI/ISO rules, but in scope in the ARM, name lookup
2989 will succeed. Issue a diagnostic here. */
2991 decl
= check_for_out_of_scope_variable (decl
);
2993 /* Remember that the name was used in the definition of
2994 the current class so that we can check later to see if
2995 the meaning would have been different after the class
2996 was entirely defined. */
2997 if (!scope
&& decl
!= error_mark_node
&& identifier_p (id_expression
))
2998 maybe_note_name_used_in_class (id_expression
, decl
);
3000 /* Disallow uses of local variables from containing functions, except
3001 within lambda-expressions. */
3002 if (!outer_var_p (decl
)
3003 /* It's not a use (3.2) if we're in an unevaluated context. */
3004 || cp_unevaluated_operand
)
3006 else if (TREE_STATIC (decl
))
3008 if (processing_template_decl
)
3009 /* For a use of an outer static var, return the identifier so
3010 that we'll look it up again in the instantiation. */
3011 return id_expression
;
3015 tree context
= DECL_CONTEXT (decl
);
3016 tree containing_function
= current_function_decl
;
3017 tree lambda_stack
= NULL_TREE
;
3018 tree lambda_expr
= NULL_TREE
;
3019 tree initializer
= convert_from_reference (decl
);
3021 /* Mark it as used now even if the use is ill-formed. */
3024 /* Core issue 696: "[At the July 2009 meeting] the CWG expressed
3025 support for an approach in which a reference to a local
3026 [constant] automatic variable in a nested class or lambda body
3027 would enter the expression as an rvalue, which would reduce
3028 the complexity of the problem"
3030 FIXME update for final resolution of core issue 696. */
3031 if (decl_constant_var_p (decl
))
3033 if (processing_template_decl
)
3034 /* In a template, the constant value may not be in a usable
3035 form, so look it up again at instantiation time. */
3036 return id_expression
;
3038 return integral_constant_value (decl
);
3041 if (parsing_nsdmi ())
3042 containing_function
= NULL_TREE
;
3043 /* If we are in a lambda function, we can move out until we hit
3045 2. a non-lambda function, or
3046 3. a non-default capturing lambda function. */
3047 else while (context
!= containing_function
3048 && LAMBDA_FUNCTION_P (containing_function
))
3050 lambda_expr
= CLASSTYPE_LAMBDA_EXPR
3051 (DECL_CONTEXT (containing_function
));
3053 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr
)
3057 lambda_stack
= tree_cons (NULL_TREE
,
3062 = decl_function_context (containing_function
);
3065 if (context
== containing_function
)
3067 decl
= add_default_capture (lambda_stack
,
3068 /*id=*/DECL_NAME (decl
),
3071 else if (lambda_expr
)
3073 error ("%qD is not captured", decl
);
3074 return error_mark_node
;
3078 error (TREE_CODE (decl
) == VAR_DECL
3079 ? G_("use of local variable with automatic storage from containing function")
3080 : G_("use of parameter from containing function"));
3081 error (" %q+#D declared here", decl
);
3082 return error_mark_node
;
3086 /* Also disallow uses of function parameters outside the function
3087 body, except inside an unevaluated context (i.e. decltype). */
3088 if (TREE_CODE (decl
) == PARM_DECL
3089 && DECL_CONTEXT (decl
) == NULL_TREE
3090 && !cp_unevaluated_operand
)
3092 error ("use of parameter %qD outside function body", decl
);
3093 return error_mark_node
;
3097 /* If we didn't find anything, or what we found was a type,
3098 then this wasn't really an id-expression. */
3099 if (TREE_CODE (decl
) == TEMPLATE_DECL
3100 && !DECL_FUNCTION_TEMPLATE_P (decl
))
3102 *error_msg
= "missing template arguments";
3103 return error_mark_node
;
3105 else if (TREE_CODE (decl
) == TYPE_DECL
3106 || TREE_CODE (decl
) == NAMESPACE_DECL
)
3108 *error_msg
= "expected primary-expression";
3109 return error_mark_node
;
3112 /* If the name resolved to a template parameter, there is no
3113 need to look it up again later. */
3114 if ((TREE_CODE (decl
) == CONST_DECL
&& DECL_TEMPLATE_PARM_P (decl
))
3115 || TREE_CODE (decl
) == TEMPLATE_PARM_INDEX
)
3119 *idk
= CP_ID_KIND_NONE
;
3120 if (TREE_CODE (decl
) == TEMPLATE_PARM_INDEX
)
3121 decl
= TEMPLATE_PARM_DECL (decl
);
3122 r
= convert_from_reference (DECL_INITIAL (decl
));
3124 if (integral_constant_expression_p
3125 && !dependent_type_p (TREE_TYPE (decl
))
3126 && !(INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (r
))))
3128 if (!allow_non_integral_constant_expression_p
)
3129 error ("template parameter %qD of type %qT is not allowed in "
3130 "an integral constant expression because it is not of "
3131 "integral or enumeration type", decl
, TREE_TYPE (decl
));
3132 *non_integral_constant_expression_p
= true;
3140 /* If the declaration was explicitly qualified indicate
3141 that. The semantics of `A::f(3)' are different than
3142 `f(3)' if `f' is virtual. */
3144 ? CP_ID_KIND_QUALIFIED
3145 : (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
3146 ? CP_ID_KIND_TEMPLATE_ID
3147 : CP_ID_KIND_UNQUALIFIED
));
3152 An id-expression is type-dependent if it contains an
3153 identifier that was declared with a dependent type.
3155 The standard is not very specific about an id-expression that
3156 names a set of overloaded functions. What if some of them
3157 have dependent types and some of them do not? Presumably,
3158 such a name should be treated as a dependent name. */
3159 /* Assume the name is not dependent. */
3160 dependent_p
= false;
3161 if (!processing_template_decl
)
3162 /* No names are dependent outside a template. */
3164 else if (TREE_CODE (decl
) == CONST_DECL
)
3165 /* We don't want to treat enumerators as dependent. */
3167 /* A template-id where the name of the template was not resolved
3168 is definitely dependent. */
3169 else if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
3170 && (identifier_p (TREE_OPERAND (decl
, 0))))
3172 /* For anything except an overloaded function, just check its
3174 else if (!is_overloaded_fn (decl
))
3176 = dependent_type_p (TREE_TYPE (decl
));
3177 /* For a set of overloaded functions, check each of the
3183 if (BASELINK_P (fns
))
3184 fns
= BASELINK_FUNCTIONS (fns
);
3186 /* For a template-id, check to see if the template
3187 arguments are dependent. */
3188 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
3190 tree args
= TREE_OPERAND (fns
, 1);
3191 dependent_p
= any_dependent_template_arguments_p (args
);
3192 /* The functions are those referred to by the
3194 fns
= TREE_OPERAND (fns
, 0);
3197 /* If there are no dependent template arguments, go through
3198 the overloaded functions. */
3199 while (fns
&& !dependent_p
)
3201 tree fn
= OVL_CURRENT (fns
);
3203 /* Member functions of dependent classes are
3205 if (TREE_CODE (fn
) == FUNCTION_DECL
3206 && type_dependent_expression_p (fn
))
3208 else if (TREE_CODE (fn
) == TEMPLATE_DECL
3209 && dependent_template_p (fn
))
3212 fns
= OVL_NEXT (fns
);
3216 /* If the name was dependent on a template parameter, we will
3217 resolve the name at instantiation time. */
3220 /* Create a SCOPE_REF for qualified names, if the scope is
3226 if (address_p
&& done
)
3227 decl
= finish_qualified_id_expr (scope
, decl
,
3233 tree type
= NULL_TREE
;
3234 if (DECL_P (decl
) && !dependent_scope_p (scope
))
3235 type
= TREE_TYPE (decl
);
3236 decl
= build_qualified_name (type
,
3242 if (TREE_TYPE (decl
))
3243 decl
= convert_from_reference (decl
);
3246 /* A TEMPLATE_ID already contains all the information we
3248 if (TREE_CODE (id_expression
) == TEMPLATE_ID_EXPR
)
3249 return id_expression
;
3250 *idk
= CP_ID_KIND_UNQUALIFIED_DEPENDENT
;
3251 /* If we found a variable, then name lookup during the
3252 instantiation will always resolve to the same VAR_DECL
3253 (or an instantiation thereof). */
3254 if (TREE_CODE (decl
) == VAR_DECL
3255 || TREE_CODE (decl
) == PARM_DECL
)
3258 return convert_from_reference (decl
);
3260 /* The same is true for FIELD_DECL, but we also need to
3261 make sure that the syntax is correct. */
3262 else if (TREE_CODE (decl
) == FIELD_DECL
)
3264 /* Since SCOPE is NULL here, this is an unqualified name.
3265 Access checking has been performed during name lookup
3266 already. Turn off checking to avoid duplicate errors. */
3267 push_deferring_access_checks (dk_no_check
);
3268 decl
= finish_non_static_data_member
3270 /*qualifying_scope=*/NULL_TREE
);
3271 pop_deferring_access_checks ();
3274 return id_expression
;
3277 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
3279 error ("use of namespace %qD as expression", decl
);
3280 return error_mark_node
;
3282 else if (DECL_CLASS_TEMPLATE_P (decl
))
3284 error ("use of class template %qT as expression", decl
);
3285 return error_mark_node
;
3287 else if (TREE_CODE (decl
) == TREE_LIST
)
3289 /* Ambiguous reference to base members. */
3290 error ("request for member %qD is ambiguous in "
3291 "multiple inheritance lattice", id_expression
);
3292 print_candidates (decl
);
3293 return error_mark_node
;
3296 /* Mark variable-like entities as used. Functions are similarly
3297 marked either below or after overload resolution. */
3298 if ((TREE_CODE (decl
) == VAR_DECL
3299 || TREE_CODE (decl
) == PARM_DECL
3300 || TREE_CODE (decl
) == CONST_DECL
3301 || TREE_CODE (decl
) == RESULT_DECL
)
3302 && !mark_used (decl
))
3303 return error_mark_node
;
3305 /* Only certain kinds of names are allowed in constant
3306 expression. Template parameters have already
3307 been handled above. */
3308 if (! error_operand_p (decl
)
3309 && integral_constant_expression_p
3310 && ! decl_constant_var_p (decl
)
3311 && TREE_CODE (decl
) != CONST_DECL
3312 && ! builtin_valid_in_constant_expr_p (decl
))
3314 if (!allow_non_integral_constant_expression_p
)
3316 error ("%qD cannot appear in a constant-expression", decl
);
3317 return error_mark_node
;
3319 *non_integral_constant_expression_p
= true;
3323 if (TREE_CODE (decl
) == VAR_DECL
3324 && !cp_unevaluated_operand
3325 && DECL_THREAD_LOCAL_P (decl
)
3326 && (wrap
= get_tls_wrapper_fn (decl
)))
3328 /* Replace an evaluated use of the thread_local variable with
3329 a call to its wrapper. */
3330 decl
= build_cxx_call (wrap
, 0, NULL
, tf_warning_or_error
);
3334 decl
= (adjust_result_of_qualified_name_lookup
3335 (decl
, scope
, current_nonlambda_class_type()));
3337 if (TREE_CODE (decl
) == FUNCTION_DECL
)
3341 decl
= finish_qualified_id_expr (scope
,
3348 decl
= convert_from_reference (decl
);
3350 else if (TREE_CODE (decl
) == FIELD_DECL
)
3352 /* Since SCOPE is NULL here, this is an unqualified name.
3353 Access checking has been performed during name lookup
3354 already. Turn off checking to avoid duplicate errors. */
3355 push_deferring_access_checks (dk_no_check
);
3356 decl
= finish_non_static_data_member (decl
, NULL_TREE
,
3357 /*qualifying_scope=*/NULL_TREE
);
3358 pop_deferring_access_checks ();
3360 else if (is_overloaded_fn (decl
))
3364 first_fn
= get_first_fn (decl
);
3365 if (TREE_CODE (first_fn
) == TEMPLATE_DECL
)
3366 first_fn
= DECL_TEMPLATE_RESULT (first_fn
);
3368 if (!really_overloaded_fn (decl
)
3369 && !mark_used (first_fn
))
3370 return error_mark_node
;
3373 && TREE_CODE (first_fn
) == FUNCTION_DECL
3374 && DECL_FUNCTION_MEMBER_P (first_fn
)
3375 && !shared_member_p (decl
))
3377 /* A set of member functions. */
3378 decl
= maybe_dummy_object (DECL_CONTEXT (first_fn
), 0);
3379 return finish_class_member_access_expr (decl
, id_expression
,
3380 /*template_p=*/false,
3381 tf_warning_or_error
);
3384 decl
= baselink_for_fns (decl
);
3388 if (DECL_P (decl
) && DECL_NONLOCAL (decl
)
3389 && DECL_CLASS_SCOPE_P (decl
))
3391 tree context
= context_for_name_lookup (decl
);
3392 if (context
!= current_class_type
)
3394 tree path
= currently_open_derived_class (context
);
3395 perform_or_defer_access_check (TYPE_BINFO (path
),
3397 tf_warning_or_error
);
3401 decl
= convert_from_reference (decl
);
3405 if (TREE_DEPRECATED (decl
))
3406 warn_deprecated_use (decl
, NULL_TREE
);
3411 /* Implement the __typeof keyword: Return the type of EXPR, suitable for
3412 use as a type-specifier. */
3415 finish_typeof (tree expr
)
3419 if (type_dependent_expression_p (expr
))
3421 type
= cxx_make_type (TYPEOF_TYPE
);
3422 TYPEOF_TYPE_EXPR (type
) = expr
;
3423 SET_TYPE_STRUCTURAL_EQUALITY (type
);
3428 expr
= mark_type_use (expr
);
3430 type
= unlowered_expr_type (expr
);
3432 if (!type
|| type
== unknown_type_node
)
3434 error ("type of %qE is unknown", expr
);
3435 return error_mark_node
;
3441 /* Implement the __underlying_type keyword: Return the underlying
3442 type of TYPE, suitable for use as a type-specifier. */
3445 finish_underlying_type (tree type
)
3447 tree underlying_type
;
3449 if (processing_template_decl
)
3451 underlying_type
= cxx_make_type (UNDERLYING_TYPE
);
3452 UNDERLYING_TYPE_TYPE (underlying_type
) = type
;
3453 SET_TYPE_STRUCTURAL_EQUALITY (underlying_type
);
3455 return underlying_type
;
3458 complete_type (type
);
3460 if (TREE_CODE (type
) != ENUMERAL_TYPE
)
3462 error ("%qT is not an enumeration type", type
);
3463 return error_mark_node
;
3466 underlying_type
= ENUM_UNDERLYING_TYPE (type
);
3468 /* Fixup necessary in this case because ENUM_UNDERLYING_TYPE
3469 includes TYPE_MIN_VALUE and TYPE_MAX_VALUE information.
3470 See finish_enum_value_list for details. */
3471 if (!ENUM_FIXED_UNDERLYING_TYPE_P (type
))
3473 = c_common_type_for_mode (TYPE_MODE (underlying_type
),
3474 TYPE_UNSIGNED (underlying_type
));
3476 return underlying_type
;
3479 /* Implement the __direct_bases keyword: Return the direct base classes
3483 calculate_direct_bases (tree type
)
3485 vec
<tree
, va_gc
> *vector
= make_tree_vector();
3486 tree bases_vec
= NULL_TREE
;
3487 vec
<tree
, va_gc
> *base_binfos
;
3491 complete_type (type
);
3493 if (!NON_UNION_CLASS_TYPE_P (type
))
3494 return make_tree_vec (0);
3496 base_binfos
= BINFO_BASE_BINFOS (TYPE_BINFO (type
));
3498 /* Virtual bases are initialized first */
3499 for (i
= 0; base_binfos
->iterate (i
, &binfo
); i
++)
3501 if (BINFO_VIRTUAL_P (binfo
))
3503 vec_safe_push (vector
, binfo
);
3507 /* Now non-virtuals */
3508 for (i
= 0; base_binfos
->iterate (i
, &binfo
); i
++)
3510 if (!BINFO_VIRTUAL_P (binfo
))
3512 vec_safe_push (vector
, binfo
);
3517 bases_vec
= make_tree_vec (vector
->length ());
3519 for (i
= 0; i
< vector
->length (); ++i
)
3521 TREE_VEC_ELT (bases_vec
, i
) = BINFO_TYPE ((*vector
)[i
]);
3526 /* Implement the __bases keyword: Return the base classes
3529 /* Find morally non-virtual base classes by walking binfo hierarchy */
3530 /* Virtual base classes are handled separately in finish_bases */
3533 dfs_calculate_bases_pre (tree binfo
, void * /*data_*/)
3535 /* Don't walk bases of virtual bases */
3536 return BINFO_VIRTUAL_P (binfo
) ? dfs_skip_bases
: NULL_TREE
;
3540 dfs_calculate_bases_post (tree binfo
, void *data_
)
3542 vec
<tree
, va_gc
> **data
= ((vec
<tree
, va_gc
> **) data_
);
3543 if (!BINFO_VIRTUAL_P (binfo
))
3545 vec_safe_push (*data
, BINFO_TYPE (binfo
));
3550 /* Calculates the morally non-virtual base classes of a class */
3551 static vec
<tree
, va_gc
> *
3552 calculate_bases_helper (tree type
)
3554 vec
<tree
, va_gc
> *vector
= make_tree_vector();
3556 /* Now add non-virtual base classes in order of construction */
3557 dfs_walk_all (TYPE_BINFO (type
),
3558 dfs_calculate_bases_pre
, dfs_calculate_bases_post
, &vector
);
3563 calculate_bases (tree type
)
3565 vec
<tree
, va_gc
> *vector
= make_tree_vector();
3566 tree bases_vec
= NULL_TREE
;
3568 vec
<tree
, va_gc
> *vbases
;
3569 vec
<tree
, va_gc
> *nonvbases
;
3572 complete_type (type
);
3574 if (!NON_UNION_CLASS_TYPE_P (type
))
3575 return make_tree_vec (0);
3577 /* First go through virtual base classes */
3578 for (vbases
= CLASSTYPE_VBASECLASSES (type
), i
= 0;
3579 vec_safe_iterate (vbases
, i
, &binfo
); i
++)
3581 vec
<tree
, va_gc
> *vbase_bases
;
3582 vbase_bases
= calculate_bases_helper (BINFO_TYPE (binfo
));
3583 vec_safe_splice (vector
, vbase_bases
);
3584 release_tree_vector (vbase_bases
);
3587 /* Now for the non-virtual bases */
3588 nonvbases
= calculate_bases_helper (type
);
3589 vec_safe_splice (vector
, nonvbases
);
3590 release_tree_vector (nonvbases
);
3592 /* Last element is entire class, so don't copy */
3593 bases_vec
= make_tree_vec (vector
->length () - 1);
3595 for (i
= 0; i
< vector
->length () - 1; ++i
)
3597 TREE_VEC_ELT (bases_vec
, i
) = (*vector
)[i
];
3599 release_tree_vector (vector
);
3604 finish_bases (tree type
, bool direct
)
3606 tree bases
= NULL_TREE
;
3608 if (!processing_template_decl
)
3610 /* Parameter packs can only be used in templates */
3611 error ("Parameter pack __bases only valid in template declaration");
3612 return error_mark_node
;
3615 bases
= cxx_make_type (BASES
);
3616 BASES_TYPE (bases
) = type
;
3617 BASES_DIRECT (bases
) = direct
;
3618 SET_TYPE_STRUCTURAL_EQUALITY (bases
);
3623 /* Perform C++-specific checks for __builtin_offsetof before calling
3627 finish_offsetof (tree expr
)
3629 if (TREE_CODE (expr
) == PSEUDO_DTOR_EXPR
)
3631 error ("cannot apply %<offsetof%> to destructor %<~%T%>",
3632 TREE_OPERAND (expr
, 2));
3633 return error_mark_node
;
3635 if (TREE_CODE (TREE_TYPE (expr
)) == FUNCTION_TYPE
3636 || TREE_CODE (TREE_TYPE (expr
)) == METHOD_TYPE
3637 || TREE_TYPE (expr
) == unknown_type_node
)
3639 if (TREE_CODE (expr
) == COMPONENT_REF
3640 || TREE_CODE (expr
) == COMPOUND_EXPR
)
3641 expr
= TREE_OPERAND (expr
, 1);
3642 error ("cannot apply %<offsetof%> to member function %qD", expr
);
3643 return error_mark_node
;
3645 if (REFERENCE_REF_P (expr
))
3646 expr
= TREE_OPERAND (expr
, 0);
3647 if (TREE_CODE (expr
) == COMPONENT_REF
)
3649 tree object
= TREE_OPERAND (expr
, 0);
3650 if (!complete_type_or_else (TREE_TYPE (object
), object
))
3651 return error_mark_node
;
3653 return fold_offsetof (expr
);
3656 /* Replace the AGGR_INIT_EXPR at *TP with an equivalent CALL_EXPR. This
3657 function is broken out from the above for the benefit of the tree-ssa
3661 simplify_aggr_init_expr (tree
*tp
)
3663 tree aggr_init_expr
= *tp
;
3665 /* Form an appropriate CALL_EXPR. */
3666 tree fn
= AGGR_INIT_EXPR_FN (aggr_init_expr
);
3667 tree slot
= AGGR_INIT_EXPR_SLOT (aggr_init_expr
);
3668 tree type
= TREE_TYPE (slot
);
3671 enum style_t
{ ctor
, arg
, pcc
} style
;
3673 if (AGGR_INIT_VIA_CTOR_P (aggr_init_expr
))
3675 #ifdef PCC_STATIC_STRUCT_RETURN
3681 gcc_assert (TREE_ADDRESSABLE (type
));
3685 call_expr
= build_call_array_loc (input_location
,
3686 TREE_TYPE (TREE_TYPE (TREE_TYPE (fn
))),
3688 aggr_init_expr_nargs (aggr_init_expr
),
3689 AGGR_INIT_EXPR_ARGP (aggr_init_expr
));
3690 TREE_NOTHROW (call_expr
) = TREE_NOTHROW (aggr_init_expr
);
3694 /* Replace the first argument to the ctor with the address of the
3696 cxx_mark_addressable (slot
);
3697 CALL_EXPR_ARG (call_expr
, 0) =
3698 build1 (ADDR_EXPR
, build_pointer_type (type
), slot
);
3700 else if (style
== arg
)
3702 /* Just mark it addressable here, and leave the rest to
3703 expand_call{,_inline}. */
3704 cxx_mark_addressable (slot
);
3705 CALL_EXPR_RETURN_SLOT_OPT (call_expr
) = true;
3706 call_expr
= build2 (INIT_EXPR
, TREE_TYPE (call_expr
), slot
, call_expr
);
3708 else if (style
== pcc
)
3710 /* If we're using the non-reentrant PCC calling convention, then we
3711 need to copy the returned value out of the static buffer into the
3713 push_deferring_access_checks (dk_no_check
);
3714 call_expr
= build_aggr_init (slot
, call_expr
,
3715 DIRECT_BIND
| LOOKUP_ONLYCONVERTING
,
3716 tf_warning_or_error
);
3717 pop_deferring_access_checks ();
3718 call_expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (slot
), call_expr
, slot
);
3721 if (AGGR_INIT_ZERO_FIRST (aggr_init_expr
))
3723 tree init
= build_zero_init (type
, NULL_TREE
,
3724 /*static_storage_p=*/false);
3725 init
= build2 (INIT_EXPR
, void_type_node
, slot
, init
);
3726 call_expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (call_expr
),
3733 /* Emit all thunks to FN that should be emitted when FN is emitted. */
3736 emit_associated_thunks (tree fn
)
3738 /* When we use vcall offsets, we emit thunks with the virtual
3739 functions to which they thunk. The whole point of vcall offsets
3740 is so that you can know statically the entire set of thunks that
3741 will ever be needed for a given virtual function, thereby
3742 enabling you to output all the thunks with the function itself. */
3743 if (DECL_VIRTUAL_P (fn
)
3744 /* Do not emit thunks for extern template instantiations. */
3745 && ! DECL_REALLY_EXTERN (fn
))
3749 for (thunk
= DECL_THUNKS (fn
); thunk
; thunk
= DECL_CHAIN (thunk
))
3751 if (!THUNK_ALIAS (thunk
))
3753 use_thunk (thunk
, /*emit_p=*/1);
3754 if (DECL_RESULT_THUNK_P (thunk
))
3758 for (probe
= DECL_THUNKS (thunk
);
3759 probe
; probe
= DECL_CHAIN (probe
))
3760 use_thunk (probe
, /*emit_p=*/1);
3764 gcc_assert (!DECL_THUNKS (thunk
));
3769 /* Returns true iff FUN is an instantiation of a constexpr function
3773 is_instantiation_of_constexpr (tree fun
)
3775 return (DECL_TEMPLOID_INSTANTIATION (fun
)
3776 && DECL_DECLARED_CONSTEXPR_P (DECL_TEMPLATE_RESULT
3777 (DECL_TI_TEMPLATE (fun
))));
3780 /* Generate RTL for FN. */
3783 expand_or_defer_fn_1 (tree fn
)
3785 /* When the parser calls us after finishing the body of a template
3786 function, we don't really want to expand the body. */
3787 if (processing_template_decl
)
3789 /* Normally, collection only occurs in rest_of_compilation. So,
3790 if we don't collect here, we never collect junk generated
3791 during the processing of templates until we hit a
3792 non-template function. It's not safe to do this inside a
3793 nested class, though, as the parser may have local state that
3794 is not a GC root. */
3795 if (!function_depth
)
3800 gcc_assert (DECL_SAVED_TREE (fn
));
3802 /* If this is a constructor or destructor body, we have to clone
3804 if (maybe_clone_body (fn
))
3806 /* We don't want to process FN again, so pretend we've written
3807 it out, even though we haven't. */
3808 TREE_ASM_WRITTEN (fn
) = 1;
3809 /* If this is an instantiation of a constexpr function, keep
3810 DECL_SAVED_TREE for explain_invalid_constexpr_fn. */
3811 if (!is_instantiation_of_constexpr (fn
))
3812 DECL_SAVED_TREE (fn
) = NULL_TREE
;
3816 /* We make a decision about linkage for these functions at the end
3817 of the compilation. Until that point, we do not want the back
3818 end to output them -- but we do want it to see the bodies of
3819 these functions so that it can inline them as appropriate. */
3820 if (DECL_DECLARED_INLINE_P (fn
) || DECL_IMPLICIT_INSTANTIATION (fn
))
3822 if (DECL_INTERFACE_KNOWN (fn
))
3823 /* We've already made a decision as to how this function will
3827 DECL_EXTERNAL (fn
) = 1;
3828 DECL_NOT_REALLY_EXTERN (fn
) = 1;
3829 note_vague_linkage_fn (fn
);
3830 /* A non-template inline function with external linkage will
3831 always be COMDAT. As we must eventually determine the
3832 linkage of all functions, and as that causes writes to
3833 the data mapped in from the PCH file, it's advantageous
3834 to mark the functions at this point. */
3835 if (!DECL_IMPLICIT_INSTANTIATION (fn
))
3837 /* This function must have external linkage, as
3838 otherwise DECL_INTERFACE_KNOWN would have been
3840 gcc_assert (TREE_PUBLIC (fn
));
3841 comdat_linkage (fn
);
3842 DECL_INTERFACE_KNOWN (fn
) = 1;
3846 import_export_decl (fn
);
3848 /* If the user wants us to keep all inline functions, then mark
3849 this function as needed so that finish_file will make sure to
3850 output it later. Similarly, all dllexport'd functions must
3851 be emitted; there may be callers in other DLLs. */
3852 if ((flag_keep_inline_functions
3853 && DECL_DECLARED_INLINE_P (fn
)
3854 && !DECL_REALLY_EXTERN (fn
))
3855 || (flag_keep_inline_dllexport
3856 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (fn
))))
3859 DECL_EXTERNAL (fn
) = 0;
3863 /* There's no reason to do any of the work here if we're only doing
3864 semantic analysis; this code just generates RTL. */
3865 if (flag_syntax_only
)
3872 expand_or_defer_fn (tree fn
)
3874 if (expand_or_defer_fn_1 (fn
))
3878 /* Expand or defer, at the whim of the compilation unit manager. */
3879 cgraph_finalize_function (fn
, function_depth
> 1);
3880 emit_associated_thunks (fn
);
3890 hash_table
<pointer_hash
<tree_node
> > visited
;
3893 /* Helper function for walk_tree, used by finalize_nrv below. */
3896 finalize_nrv_r (tree
* tp
, int* walk_subtrees
, void* data
)
3898 struct nrv_data
*dp
= (struct nrv_data
*)data
;
3901 /* No need to walk into types. There wouldn't be any need to walk into
3902 non-statements, except that we have to consider STMT_EXPRs. */
3905 /* Change all returns to just refer to the RESULT_DECL; this is a nop,
3906 but differs from using NULL_TREE in that it indicates that we care
3907 about the value of the RESULT_DECL. */
3908 else if (TREE_CODE (*tp
) == RETURN_EXPR
)
3909 TREE_OPERAND (*tp
, 0) = dp
->result
;
3910 /* Change all cleanups for the NRV to only run when an exception is
3912 else if (TREE_CODE (*tp
) == CLEANUP_STMT
3913 && CLEANUP_DECL (*tp
) == dp
->var
)
3914 CLEANUP_EH_ONLY (*tp
) = 1;
3915 /* Replace the DECL_EXPR for the NRV with an initialization of the
3916 RESULT_DECL, if needed. */
3917 else if (TREE_CODE (*tp
) == DECL_EXPR
3918 && DECL_EXPR_DECL (*tp
) == dp
->var
)
3921 if (DECL_INITIAL (dp
->var
)
3922 && DECL_INITIAL (dp
->var
) != error_mark_node
)
3923 init
= build2 (INIT_EXPR
, void_type_node
, dp
->result
,
3924 DECL_INITIAL (dp
->var
));
3926 init
= build_empty_stmt (EXPR_LOCATION (*tp
));
3927 DECL_INITIAL (dp
->var
) = NULL_TREE
;
3928 SET_EXPR_LOCATION (init
, EXPR_LOCATION (*tp
));
3931 /* And replace all uses of the NRV with the RESULT_DECL. */
3932 else if (*tp
== dp
->var
)
3935 /* Avoid walking into the same tree more than once. Unfortunately, we
3936 can't just use walk_tree_without duplicates because it would only call
3937 us for the first occurrence of dp->var in the function body. */
3938 slot
= dp
->visited
.find_slot (*tp
, INSERT
);
3944 /* Keep iterating. */
3948 /* Called from finish_function to implement the named return value
3949 optimization by overriding all the RETURN_EXPRs and pertinent
3950 CLEANUP_STMTs and replacing all occurrences of VAR with RESULT, the
3951 RESULT_DECL for the function. */
3954 finalize_nrv (tree
*tp
, tree var
, tree result
)
3956 struct nrv_data data
;
3958 /* Copy name from VAR to RESULT. */
3959 DECL_NAME (result
) = DECL_NAME (var
);
3960 /* Don't forget that we take its address. */
3961 TREE_ADDRESSABLE (result
) = TREE_ADDRESSABLE (var
);
3962 /* Finally set DECL_VALUE_EXPR to avoid assigning
3963 a stack slot at -O0 for the original var and debug info
3964 uses RESULT location for VAR. */
3965 SET_DECL_VALUE_EXPR (var
, result
);
3966 DECL_HAS_VALUE_EXPR_P (var
) = 1;
3969 data
.result
= result
;
3970 data
.visited
.create (37);
3971 cp_walk_tree (tp
, finalize_nrv_r
, &data
, 0);
3972 data
.visited
.dispose ();
3975 /* Create CP_OMP_CLAUSE_INFO for clause C. Returns true if it is invalid. */
3978 cxx_omp_create_clause_info (tree c
, tree type
, bool need_default_ctor
,
3979 bool need_copy_ctor
, bool need_copy_assignment
)
3981 int save_errorcount
= errorcount
;
3984 /* Always allocate 3 elements for simplicity. These are the
3985 function decls for the ctor, dtor, and assignment op.
3986 This layout is known to the three lang hooks,
3987 cxx_omp_clause_default_init, cxx_omp_clause_copy_init,
3988 and cxx_omp_clause_assign_op. */
3989 info
= make_tree_vec (3);
3990 CP_OMP_CLAUSE_INFO (c
) = info
;
3992 if (need_default_ctor
|| need_copy_ctor
)
3994 if (need_default_ctor
)
3995 t
= get_default_ctor (type
);
3997 t
= get_copy_ctor (type
, tf_warning_or_error
);
3999 if (t
&& !trivial_fn_p (t
))
4000 TREE_VEC_ELT (info
, 0) = t
;
4003 if ((need_default_ctor
|| need_copy_ctor
)
4004 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
4005 TREE_VEC_ELT (info
, 1) = get_dtor (type
, tf_warning_or_error
);
4007 if (need_copy_assignment
)
4009 t
= get_copy_assign (type
);
4011 if (t
&& !trivial_fn_p (t
))
4012 TREE_VEC_ELT (info
, 2) = t
;
4015 return errorcount
!= save_errorcount
;
4018 /* For all elements of CLAUSES, validate them vs OpenMP constraints.
4019 Remove any elements from the list that are invalid. */
4022 finish_omp_clauses (tree clauses
)
4024 bitmap_head generic_head
, firstprivate_head
, lastprivate_head
;
4025 tree c
, t
, *pc
= &clauses
;
4028 bitmap_obstack_initialize (NULL
);
4029 bitmap_initialize (&generic_head
, &bitmap_default_obstack
);
4030 bitmap_initialize (&firstprivate_head
, &bitmap_default_obstack
);
4031 bitmap_initialize (&lastprivate_head
, &bitmap_default_obstack
);
4033 for (pc
= &clauses
, c
= clauses
; c
; c
= *pc
)
4035 bool remove
= false;
4037 switch (OMP_CLAUSE_CODE (c
))
4039 case OMP_CLAUSE_SHARED
:
4041 goto check_dup_generic
;
4042 case OMP_CLAUSE_PRIVATE
:
4044 goto check_dup_generic
;
4045 case OMP_CLAUSE_REDUCTION
:
4047 goto check_dup_generic
;
4048 case OMP_CLAUSE_COPYPRIVATE
:
4049 name
= "copyprivate";
4050 goto check_dup_generic
;
4051 case OMP_CLAUSE_COPYIN
:
4053 goto check_dup_generic
;
4055 t
= OMP_CLAUSE_DECL (c
);
4056 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
4058 if (processing_template_decl
)
4061 error ("%qD is not a variable in clause %qs", t
, name
);
4063 error ("%qE is not a variable in clause %qs", t
, name
);
4066 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
4067 || bitmap_bit_p (&firstprivate_head
, DECL_UID (t
))
4068 || bitmap_bit_p (&lastprivate_head
, DECL_UID (t
)))
4070 error ("%qD appears more than once in data clauses", t
);
4074 bitmap_set_bit (&generic_head
, DECL_UID (t
));
4077 case OMP_CLAUSE_FIRSTPRIVATE
:
4078 t
= OMP_CLAUSE_DECL (c
);
4079 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
4081 if (processing_template_decl
)
4084 error ("%qD is not a variable in clause %<firstprivate%>", t
);
4086 error ("%qE is not a variable in clause %<firstprivate%>", t
);
4089 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
4090 || bitmap_bit_p (&firstprivate_head
, DECL_UID (t
)))
4092 error ("%qD appears more than once in data clauses", t
);
4096 bitmap_set_bit (&firstprivate_head
, DECL_UID (t
));
4099 case OMP_CLAUSE_LASTPRIVATE
:
4100 t
= OMP_CLAUSE_DECL (c
);
4101 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
4103 if (processing_template_decl
)
4106 error ("%qD is not a variable in clause %<lastprivate%>", t
);
4108 error ("%qE is not a variable in clause %<lastprivate%>", t
);
4111 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
4112 || bitmap_bit_p (&lastprivate_head
, DECL_UID (t
)))
4114 error ("%qD appears more than once in data clauses", t
);
4118 bitmap_set_bit (&lastprivate_head
, DECL_UID (t
));
4122 t
= OMP_CLAUSE_IF_EXPR (c
);
4123 t
= maybe_convert_cond (t
);
4124 if (t
== error_mark_node
)
4126 else if (!processing_template_decl
)
4127 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4128 OMP_CLAUSE_IF_EXPR (c
) = t
;
4131 case OMP_CLAUSE_FINAL
:
4132 t
= OMP_CLAUSE_FINAL_EXPR (c
);
4133 t
= maybe_convert_cond (t
);
4134 if (t
== error_mark_node
)
4136 else if (!processing_template_decl
)
4137 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4138 OMP_CLAUSE_FINAL_EXPR (c
) = t
;
4141 case OMP_CLAUSE_NUM_THREADS
:
4142 t
= OMP_CLAUSE_NUM_THREADS_EXPR (c
);
4143 if (t
== error_mark_node
)
4145 else if (!type_dependent_expression_p (t
)
4146 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
4148 error ("num_threads expression must be integral");
4153 t
= mark_rvalue_use (t
);
4154 if (!processing_template_decl
)
4155 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4156 OMP_CLAUSE_NUM_THREADS_EXPR (c
) = t
;
4160 case OMP_CLAUSE_SCHEDULE
:
4161 t
= OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c
);
4164 else if (t
== error_mark_node
)
4166 else if (!type_dependent_expression_p (t
)
4167 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
4169 error ("schedule chunk size expression must be integral");
4174 t
= mark_rvalue_use (t
);
4175 if (!processing_template_decl
)
4176 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4177 OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c
) = t
;
4181 case OMP_CLAUSE_NOWAIT
:
4182 case OMP_CLAUSE_ORDERED
:
4183 case OMP_CLAUSE_DEFAULT
:
4184 case OMP_CLAUSE_UNTIED
:
4185 case OMP_CLAUSE_COLLAPSE
:
4186 case OMP_CLAUSE_MERGEABLE
:
4194 *pc
= OMP_CLAUSE_CHAIN (c
);
4196 pc
= &OMP_CLAUSE_CHAIN (c
);
4199 for (pc
= &clauses
, c
= clauses
; c
; c
= *pc
)
4201 enum omp_clause_code c_kind
= OMP_CLAUSE_CODE (c
);
4202 bool remove
= false;
4203 bool need_complete_non_reference
= false;
4204 bool need_default_ctor
= false;
4205 bool need_copy_ctor
= false;
4206 bool need_copy_assignment
= false;
4207 bool need_implicitly_determined
= false;
4208 tree type
, inner_type
;
4212 case OMP_CLAUSE_SHARED
:
4214 need_implicitly_determined
= true;
4216 case OMP_CLAUSE_PRIVATE
:
4218 need_complete_non_reference
= true;
4219 need_default_ctor
= true;
4220 need_implicitly_determined
= true;
4222 case OMP_CLAUSE_FIRSTPRIVATE
:
4223 name
= "firstprivate";
4224 need_complete_non_reference
= true;
4225 need_copy_ctor
= true;
4226 need_implicitly_determined
= true;
4228 case OMP_CLAUSE_LASTPRIVATE
:
4229 name
= "lastprivate";
4230 need_complete_non_reference
= true;
4231 need_copy_assignment
= true;
4232 need_implicitly_determined
= true;
4234 case OMP_CLAUSE_REDUCTION
:
4236 need_implicitly_determined
= true;
4238 case OMP_CLAUSE_COPYPRIVATE
:
4239 name
= "copyprivate";
4240 need_copy_assignment
= true;
4242 case OMP_CLAUSE_COPYIN
:
4244 need_copy_assignment
= true;
4247 pc
= &OMP_CLAUSE_CHAIN (c
);
4251 t
= OMP_CLAUSE_DECL (c
);
4252 if (processing_template_decl
4253 && TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
4255 pc
= &OMP_CLAUSE_CHAIN (c
);
4261 case OMP_CLAUSE_LASTPRIVATE
:
4262 if (!bitmap_bit_p (&firstprivate_head
, DECL_UID (t
)))
4263 need_default_ctor
= true;
4266 case OMP_CLAUSE_REDUCTION
:
4267 if (AGGREGATE_TYPE_P (TREE_TYPE (t
))
4268 || POINTER_TYPE_P (TREE_TYPE (t
)))
4270 error ("%qE has invalid type for %<reduction%>", t
);
4273 else if (FLOAT_TYPE_P (TREE_TYPE (t
)))
4275 enum tree_code r_code
= OMP_CLAUSE_REDUCTION_CODE (c
);
4285 error ("%qE has invalid type for %<reduction(%s)%>",
4286 t
, operator_name_info
[r_code
].name
);
4292 case OMP_CLAUSE_COPYIN
:
4293 if (TREE_CODE (t
) != VAR_DECL
|| !DECL_THREAD_LOCAL_P (t
))
4295 error ("%qE must be %<threadprivate%> for %<copyin%>", t
);
4304 if (need_complete_non_reference
|| need_copy_assignment
)
4306 t
= require_complete_type (t
);
4307 if (t
== error_mark_node
)
4309 else if (TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
4310 && need_complete_non_reference
)
4312 error ("%qE has reference type for %qs", t
, name
);
4316 if (need_implicitly_determined
)
4318 const char *share_name
= NULL
;
4320 if (TREE_CODE (t
) == VAR_DECL
&& DECL_THREAD_LOCAL_P (t
))
4321 share_name
= "threadprivate";
4322 else switch (cxx_omp_predetermined_sharing (t
))
4324 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
4326 case OMP_CLAUSE_DEFAULT_SHARED
:
4327 /* const vars may be specified in firstprivate clause. */
4328 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
4329 && cxx_omp_const_qual_no_mutable (t
))
4331 share_name
= "shared";
4333 case OMP_CLAUSE_DEFAULT_PRIVATE
:
4334 share_name
= "private";
4341 error ("%qE is predetermined %qs for %qs",
4342 t
, share_name
, name
);
4347 /* We're interested in the base element, not arrays. */
4348 inner_type
= type
= TREE_TYPE (t
);
4349 while (TREE_CODE (inner_type
) == ARRAY_TYPE
)
4350 inner_type
= TREE_TYPE (inner_type
);
4352 /* Check for special function availability by building a call to one.
4353 Save the results, because later we won't be in the right context
4354 for making these queries. */
4355 if (CLASS_TYPE_P (inner_type
)
4356 && COMPLETE_TYPE_P (inner_type
)
4357 && (need_default_ctor
|| need_copy_ctor
|| need_copy_assignment
)
4358 && !type_dependent_expression_p (t
)
4359 && cxx_omp_create_clause_info (c
, inner_type
, need_default_ctor
,
4360 need_copy_ctor
, need_copy_assignment
))
4364 *pc
= OMP_CLAUSE_CHAIN (c
);
4366 pc
= &OMP_CLAUSE_CHAIN (c
);
4369 bitmap_obstack_release (NULL
);
4373 /* For all variables in the tree_list VARS, mark them as thread local. */
4376 finish_omp_threadprivate (tree vars
)
4380 /* Mark every variable in VARS to be assigned thread local storage. */
4381 for (t
= vars
; t
; t
= TREE_CHAIN (t
))
4383 tree v
= TREE_PURPOSE (t
);
4385 if (error_operand_p (v
))
4387 else if (TREE_CODE (v
) != VAR_DECL
)
4388 error ("%<threadprivate%> %qD is not file, namespace "
4389 "or block scope variable", v
);
4390 /* If V had already been marked threadprivate, it doesn't matter
4391 whether it had been used prior to this point. */
4392 else if (TREE_USED (v
)
4393 && (DECL_LANG_SPECIFIC (v
) == NULL
4394 || !CP_DECL_THREADPRIVATE_P (v
)))
4395 error ("%qE declared %<threadprivate%> after first use", v
);
4396 else if (! TREE_STATIC (v
) && ! DECL_EXTERNAL (v
))
4397 error ("automatic variable %qE cannot be %<threadprivate%>", v
);
4398 else if (! COMPLETE_TYPE_P (complete_type (TREE_TYPE (v
))))
4399 error ("%<threadprivate%> %qE has incomplete type", v
);
4400 else if (TREE_STATIC (v
) && TYPE_P (CP_DECL_CONTEXT (v
))
4401 && CP_DECL_CONTEXT (v
) != current_class_type
)
4402 error ("%<threadprivate%> %qE directive not "
4403 "in %qT definition", v
, CP_DECL_CONTEXT (v
));
4406 /* Allocate a LANG_SPECIFIC structure for V, if needed. */
4407 if (DECL_LANG_SPECIFIC (v
) == NULL
)
4409 retrofit_lang_decl (v
);
4411 /* Make sure that DECL_DISCRIMINATOR_P continues to be true
4412 after the allocation of the lang_decl structure. */
4413 if (DECL_DISCRIMINATOR_P (v
))
4414 DECL_LANG_SPECIFIC (v
)->u
.base
.u2sel
= 1;
4417 if (! DECL_THREAD_LOCAL_P (v
))
4419 DECL_TLS_MODEL (v
) = decl_default_tls_model (v
);
4420 /* If rtl has been already set for this var, call
4421 make_decl_rtl once again, so that encode_section_info
4422 has a chance to look at the new decl flags. */
4423 if (DECL_RTL_SET_P (v
))
4426 CP_DECL_THREADPRIVATE_P (v
) = 1;
4431 /* Build an OpenMP structured block. */
4434 begin_omp_structured_block (void)
4436 return do_pushlevel (sk_omp
);
4440 finish_omp_structured_block (tree block
)
4442 return do_poplevel (block
);
4445 /* Similarly, except force the retention of the BLOCK. */
4448 begin_omp_parallel (void)
4450 keep_next_level (true);
4451 return begin_omp_structured_block ();
4455 finish_omp_parallel (tree clauses
, tree body
)
4459 body
= finish_omp_structured_block (body
);
4461 stmt
= make_node (OMP_PARALLEL
);
4462 TREE_TYPE (stmt
) = void_type_node
;
4463 OMP_PARALLEL_CLAUSES (stmt
) = clauses
;
4464 OMP_PARALLEL_BODY (stmt
) = body
;
4466 return add_stmt (stmt
);
4470 begin_omp_task (void)
4472 keep_next_level (true);
4473 return begin_omp_structured_block ();
4477 finish_omp_task (tree clauses
, tree body
)
4481 body
= finish_omp_structured_block (body
);
4483 stmt
= make_node (OMP_TASK
);
4484 TREE_TYPE (stmt
) = void_type_node
;
4485 OMP_TASK_CLAUSES (stmt
) = clauses
;
4486 OMP_TASK_BODY (stmt
) = body
;
4488 return add_stmt (stmt
);
4491 /* Helper function for finish_omp_for. Convert Ith random access iterator
4492 into integral iterator. Return FALSE if successful. */
4495 handle_omp_for_class_iterator (int i
, location_t locus
, tree declv
, tree initv
,
4496 tree condv
, tree incrv
, tree
*body
,
4497 tree
*pre_body
, tree clauses
)
4499 tree diff
, iter_init
, iter_incr
= NULL
, last
;
4500 tree incr_var
= NULL
, orig_pre_body
, orig_body
, c
;
4501 tree decl
= TREE_VEC_ELT (declv
, i
);
4502 tree init
= TREE_VEC_ELT (initv
, i
);
4503 tree cond
= TREE_VEC_ELT (condv
, i
);
4504 tree incr
= TREE_VEC_ELT (incrv
, i
);
4506 location_t elocus
= locus
;
4508 if (init
&& EXPR_HAS_LOCATION (init
))
4509 elocus
= EXPR_LOCATION (init
);
4511 switch (TREE_CODE (cond
))
4517 if (TREE_OPERAND (cond
, 1) == iter
)
4518 cond
= build2 (swap_tree_comparison (TREE_CODE (cond
)),
4519 TREE_TYPE (cond
), iter
, TREE_OPERAND (cond
, 0));
4520 if (TREE_OPERAND (cond
, 0) != iter
)
4521 cond
= error_mark_node
;
4524 tree tem
= build_x_binary_op (EXPR_LOCATION (cond
),
4527 TREE_OPERAND (cond
, 1), ERROR_MARK
,
4528 NULL
, tf_warning_or_error
);
4529 if (error_operand_p (tem
))
4534 cond
= error_mark_node
;
4537 if (cond
== error_mark_node
)
4539 error_at (elocus
, "invalid controlling predicate");
4542 diff
= build_x_binary_op (elocus
, MINUS_EXPR
, TREE_OPERAND (cond
, 1),
4543 ERROR_MARK
, iter
, ERROR_MARK
, NULL
,
4544 tf_warning_or_error
);
4545 if (error_operand_p (diff
))
4547 if (TREE_CODE (TREE_TYPE (diff
)) != INTEGER_TYPE
)
4549 error_at (elocus
, "difference between %qE and %qD does not have integer type",
4550 TREE_OPERAND (cond
, 1), iter
);
4554 switch (TREE_CODE (incr
))
4556 case PREINCREMENT_EXPR
:
4557 case PREDECREMENT_EXPR
:
4558 case POSTINCREMENT_EXPR
:
4559 case POSTDECREMENT_EXPR
:
4560 if (TREE_OPERAND (incr
, 0) != iter
)
4562 incr
= error_mark_node
;
4565 iter_incr
= build_x_unary_op (EXPR_LOCATION (incr
),
4566 TREE_CODE (incr
), iter
,
4567 tf_warning_or_error
);
4568 if (error_operand_p (iter_incr
))
4570 else if (TREE_CODE (incr
) == PREINCREMENT_EXPR
4571 || TREE_CODE (incr
) == POSTINCREMENT_EXPR
)
4572 incr
= integer_one_node
;
4574 incr
= integer_minus_one_node
;
4577 if (TREE_OPERAND (incr
, 0) != iter
)
4578 incr
= error_mark_node
;
4579 else if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
4580 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
4582 tree rhs
= TREE_OPERAND (incr
, 1);
4583 if (TREE_OPERAND (rhs
, 0) == iter
)
4585 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs
, 1)))
4587 incr
= error_mark_node
;
4590 iter_incr
= build_x_modify_expr (EXPR_LOCATION (rhs
),
4591 iter
, TREE_CODE (rhs
),
4592 TREE_OPERAND (rhs
, 1),
4593 tf_warning_or_error
);
4594 if (error_operand_p (iter_incr
))
4596 incr
= TREE_OPERAND (rhs
, 1);
4597 incr
= cp_convert (TREE_TYPE (diff
), incr
,
4598 tf_warning_or_error
);
4599 if (TREE_CODE (rhs
) == MINUS_EXPR
)
4601 incr
= build1 (NEGATE_EXPR
, TREE_TYPE (diff
), incr
);
4602 incr
= fold_if_not_in_template (incr
);
4604 if (TREE_CODE (incr
) != INTEGER_CST
4605 && (TREE_CODE (incr
) != NOP_EXPR
4606 || (TREE_CODE (TREE_OPERAND (incr
, 0))
4611 else if (TREE_OPERAND (rhs
, 1) == iter
)
4613 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs
, 0))) != INTEGER_TYPE
4614 || TREE_CODE (rhs
) != PLUS_EXPR
)
4615 incr
= error_mark_node
;
4618 iter_incr
= build_x_binary_op (EXPR_LOCATION (rhs
),
4620 TREE_OPERAND (rhs
, 0),
4623 tf_warning_or_error
);
4624 if (error_operand_p (iter_incr
))
4626 iter_incr
= build_x_modify_expr (EXPR_LOCATION (rhs
),
4629 tf_warning_or_error
);
4630 if (error_operand_p (iter_incr
))
4632 incr
= TREE_OPERAND (rhs
, 0);
4637 incr
= error_mark_node
;
4640 incr
= error_mark_node
;
4643 incr
= error_mark_node
;
4647 if (incr
== error_mark_node
)
4649 error_at (elocus
, "invalid increment expression");
4653 incr
= cp_convert (TREE_TYPE (diff
), incr
, tf_warning_or_error
);
4654 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
4655 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
4656 && OMP_CLAUSE_DECL (c
) == iter
)
4659 decl
= create_temporary_var (TREE_TYPE (diff
));
4661 add_decl_expr (decl
);
4662 last
= create_temporary_var (TREE_TYPE (diff
));
4664 add_decl_expr (last
);
4665 if (c
&& iter_incr
== NULL
)
4667 incr_var
= create_temporary_var (TREE_TYPE (diff
));
4668 pushdecl (incr_var
);
4669 add_decl_expr (incr_var
);
4671 gcc_assert (stmts_are_full_exprs_p ());
4673 orig_pre_body
= *pre_body
;
4674 *pre_body
= push_stmt_list ();
4676 add_stmt (orig_pre_body
);
4678 finish_expr_stmt (build_x_modify_expr (elocus
,
4679 iter
, NOP_EXPR
, init
,
4680 tf_warning_or_error
));
4681 init
= build_int_cst (TREE_TYPE (diff
), 0);
4682 if (c
&& iter_incr
== NULL
)
4684 finish_expr_stmt (build_x_modify_expr (elocus
,
4686 incr
, tf_warning_or_error
));
4688 iter_incr
= build_x_modify_expr (elocus
,
4689 iter
, PLUS_EXPR
, incr
,
4690 tf_warning_or_error
);
4692 finish_expr_stmt (build_x_modify_expr (elocus
,
4693 last
, NOP_EXPR
, init
,
4694 tf_warning_or_error
));
4695 *pre_body
= pop_stmt_list (*pre_body
);
4697 cond
= cp_build_binary_op (elocus
,
4698 TREE_CODE (cond
), decl
, diff
,
4699 tf_warning_or_error
);
4700 incr
= build_modify_expr (elocus
, decl
, NULL_TREE
, PLUS_EXPR
,
4701 elocus
, incr
, NULL_TREE
);
4704 *body
= push_stmt_list ();
4705 iter_init
= build2 (MINUS_EXPR
, TREE_TYPE (diff
), decl
, last
);
4706 iter_init
= build_x_modify_expr (elocus
,
4707 iter
, PLUS_EXPR
, iter_init
,
4708 tf_warning_or_error
);
4709 iter_init
= build1 (NOP_EXPR
, void_type_node
, iter_init
);
4710 finish_expr_stmt (iter_init
);
4711 finish_expr_stmt (build_x_modify_expr (elocus
,
4712 last
, NOP_EXPR
, decl
,
4713 tf_warning_or_error
));
4714 add_stmt (orig_body
);
4715 *body
= pop_stmt_list (*body
);
4719 OMP_CLAUSE_LASTPRIVATE_STMT (c
) = push_stmt_list ();
4720 finish_expr_stmt (iter_incr
);
4721 OMP_CLAUSE_LASTPRIVATE_STMT (c
)
4722 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (c
));
4725 TREE_VEC_ELT (declv
, i
) = decl
;
4726 TREE_VEC_ELT (initv
, i
) = init
;
4727 TREE_VEC_ELT (condv
, i
) = cond
;
4728 TREE_VEC_ELT (incrv
, i
) = incr
;
4733 /* Build and validate an OMP_FOR statement. CLAUSES, BODY, COND, INCR
4734 are directly for their associated operands in the statement. DECL
4735 and INIT are a combo; if DECL is NULL then INIT ought to be a
4736 MODIFY_EXPR, and the DECL should be extracted. PRE_BODY are
4737 optional statements that need to go before the loop into its
4741 finish_omp_for (location_t locus
, tree declv
, tree initv
, tree condv
,
4742 tree incrv
, tree body
, tree pre_body
, tree clauses
)
4744 tree omp_for
= NULL
, orig_incr
= NULL
;
4745 tree decl
, init
, cond
, incr
;
4749 gcc_assert (TREE_VEC_LENGTH (declv
) == TREE_VEC_LENGTH (initv
));
4750 gcc_assert (TREE_VEC_LENGTH (declv
) == TREE_VEC_LENGTH (condv
));
4751 gcc_assert (TREE_VEC_LENGTH (declv
) == TREE_VEC_LENGTH (incrv
));
4752 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
4754 decl
= TREE_VEC_ELT (declv
, i
);
4755 init
= TREE_VEC_ELT (initv
, i
);
4756 cond
= TREE_VEC_ELT (condv
, i
);
4757 incr
= TREE_VEC_ELT (incrv
, i
);
4763 switch (TREE_CODE (init
))
4766 decl
= TREE_OPERAND (init
, 0);
4767 init
= TREE_OPERAND (init
, 1);
4770 if (TREE_CODE (TREE_OPERAND (init
, 1)) == NOP_EXPR
)
4772 decl
= TREE_OPERAND (init
, 0);
4773 init
= TREE_OPERAND (init
, 2);
4783 "expected iteration declaration or initialization");
4788 if (init
&& EXPR_HAS_LOCATION (init
))
4789 elocus
= EXPR_LOCATION (init
);
4793 error_at (elocus
, "missing controlling predicate");
4799 error_at (elocus
, "missing increment expression");
4803 TREE_VEC_ELT (declv
, i
) = decl
;
4804 TREE_VEC_ELT (initv
, i
) = init
;
4807 if (dependent_omp_for_p (declv
, initv
, condv
, incrv
))
4811 stmt
= make_node (OMP_FOR
);
4813 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
4815 /* This is really just a place-holder. We'll be decomposing this
4816 again and going through the cp_build_modify_expr path below when
4817 we instantiate the thing. */
4818 TREE_VEC_ELT (initv
, i
)
4819 = build2 (MODIFY_EXPR
, void_type_node
, TREE_VEC_ELT (declv
, i
),
4820 TREE_VEC_ELT (initv
, i
));
4823 TREE_TYPE (stmt
) = void_type_node
;
4824 OMP_FOR_INIT (stmt
) = initv
;
4825 OMP_FOR_COND (stmt
) = condv
;
4826 OMP_FOR_INCR (stmt
) = incrv
;
4827 OMP_FOR_BODY (stmt
) = body
;
4828 OMP_FOR_PRE_BODY (stmt
) = pre_body
;
4829 OMP_FOR_CLAUSES (stmt
) = clauses
;
4831 SET_EXPR_LOCATION (stmt
, locus
);
4832 return add_stmt (stmt
);
4835 if (processing_template_decl
)
4836 orig_incr
= make_tree_vec (TREE_VEC_LENGTH (incrv
));
4838 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); )
4840 decl
= TREE_VEC_ELT (declv
, i
);
4841 init
= TREE_VEC_ELT (initv
, i
);
4842 cond
= TREE_VEC_ELT (condv
, i
);
4843 incr
= TREE_VEC_ELT (incrv
, i
);
4845 TREE_VEC_ELT (orig_incr
, i
) = incr
;
4848 if (init
&& EXPR_HAS_LOCATION (init
))
4849 elocus
= EXPR_LOCATION (init
);
4853 error_at (elocus
, "expected iteration declaration or initialization");
4857 if (incr
&& TREE_CODE (incr
) == MODOP_EXPR
)
4860 TREE_VEC_ELT (orig_incr
, i
) = incr
;
4861 incr
= cp_build_modify_expr (TREE_OPERAND (incr
, 0),
4862 TREE_CODE (TREE_OPERAND (incr
, 1)),
4863 TREE_OPERAND (incr
, 2),
4864 tf_warning_or_error
);
4867 if (CLASS_TYPE_P (TREE_TYPE (decl
)))
4869 if (handle_omp_for_class_iterator (i
, locus
, declv
, initv
, condv
,
4870 incrv
, &body
, &pre_body
, clauses
))
4875 if (!INTEGRAL_TYPE_P (TREE_TYPE (decl
))
4876 && TREE_CODE (TREE_TYPE (decl
)) != POINTER_TYPE
)
4878 error_at (elocus
, "invalid type for iteration variable %qE", decl
);
4882 if (!processing_template_decl
)
4884 init
= fold_build_cleanup_point_expr (TREE_TYPE (init
), init
);
4885 init
= cp_build_modify_expr (decl
, NOP_EXPR
, init
, tf_warning_or_error
);
4888 init
= build2 (MODIFY_EXPR
, void_type_node
, decl
, init
);
4890 && TREE_SIDE_EFFECTS (cond
)
4891 && COMPARISON_CLASS_P (cond
)
4892 && !processing_template_decl
)
4894 tree t
= TREE_OPERAND (cond
, 0);
4895 if (TREE_SIDE_EFFECTS (t
)
4897 && (TREE_CODE (t
) != NOP_EXPR
4898 || TREE_OPERAND (t
, 0) != decl
))
4899 TREE_OPERAND (cond
, 0)
4900 = fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4902 t
= TREE_OPERAND (cond
, 1);
4903 if (TREE_SIDE_EFFECTS (t
)
4905 && (TREE_CODE (t
) != NOP_EXPR
4906 || TREE_OPERAND (t
, 0) != decl
))
4907 TREE_OPERAND (cond
, 1)
4908 = fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4910 if (decl
== error_mark_node
|| init
== error_mark_node
)
4913 TREE_VEC_ELT (declv
, i
) = decl
;
4914 TREE_VEC_ELT (initv
, i
) = init
;
4915 TREE_VEC_ELT (condv
, i
) = cond
;
4916 TREE_VEC_ELT (incrv
, i
) = incr
;
4920 if (IS_EMPTY_STMT (pre_body
))
4923 omp_for
= c_finish_omp_for (locus
, declv
, initv
, condv
, incrv
,
4926 if (omp_for
== NULL
)
4929 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INCR (omp_for
)); i
++)
4931 decl
= TREE_OPERAND (TREE_VEC_ELT (OMP_FOR_INIT (omp_for
), i
), 0);
4932 incr
= TREE_VEC_ELT (OMP_FOR_INCR (omp_for
), i
);
4934 if (TREE_CODE (incr
) != MODIFY_EXPR
)
4937 if (TREE_SIDE_EFFECTS (TREE_OPERAND (incr
, 1))
4938 && BINARY_CLASS_P (TREE_OPERAND (incr
, 1))
4939 && !processing_template_decl
)
4941 tree t
= TREE_OPERAND (TREE_OPERAND (incr
, 1), 0);
4942 if (TREE_SIDE_EFFECTS (t
)
4944 && (TREE_CODE (t
) != NOP_EXPR
4945 || TREE_OPERAND (t
, 0) != decl
))
4946 TREE_OPERAND (TREE_OPERAND (incr
, 1), 0)
4947 = fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4949 t
= TREE_OPERAND (TREE_OPERAND (incr
, 1), 1);
4950 if (TREE_SIDE_EFFECTS (t
)
4952 && (TREE_CODE (t
) != NOP_EXPR
4953 || TREE_OPERAND (t
, 0) != decl
))
4954 TREE_OPERAND (TREE_OPERAND (incr
, 1), 1)
4955 = fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4959 TREE_VEC_ELT (OMP_FOR_INCR (omp_for
), i
) = TREE_VEC_ELT (orig_incr
, i
);
4961 if (omp_for
!= NULL
)
4962 OMP_FOR_CLAUSES (omp_for
) = clauses
;
4967 finish_omp_atomic (enum tree_code code
, enum tree_code opcode
, tree lhs
,
4968 tree rhs
, tree v
, tree lhs1
, tree rhs1
)
4983 dependent_p
= false;
4986 /* Even in a template, we can detect invalid uses of the atomic
4987 pragma if neither LHS nor RHS is type-dependent. */
4988 if (processing_template_decl
)
4990 dependent_p
= (type_dependent_expression_p (lhs
)
4991 || (rhs
&& type_dependent_expression_p (rhs
))
4992 || (v
&& type_dependent_expression_p (v
))
4993 || (lhs1
&& type_dependent_expression_p (lhs1
))
4994 || (rhs1
&& type_dependent_expression_p (rhs1
)));
4997 lhs
= build_non_dependent_expr (lhs
);
4999 rhs
= build_non_dependent_expr (rhs
);
5001 v
= build_non_dependent_expr (v
);
5003 lhs1
= build_non_dependent_expr (lhs1
);
5005 rhs1
= build_non_dependent_expr (rhs1
);
5010 stmt
= c_finish_omp_atomic (input_location
, code
, opcode
, lhs
, rhs
,
5012 if (stmt
== error_mark_node
)
5015 if (processing_template_decl
)
5017 if (code
== OMP_ATOMIC_READ
)
5019 stmt
= build_min_nt_loc (EXPR_LOCATION (orig_lhs
),
5020 OMP_ATOMIC_READ
, orig_lhs
);
5021 stmt
= build2 (MODIFY_EXPR
, void_type_node
, orig_v
, stmt
);
5025 if (opcode
== NOP_EXPR
)
5026 stmt
= build2 (MODIFY_EXPR
, void_type_node
, orig_lhs
, orig_rhs
);
5028 stmt
= build2 (opcode
, void_type_node
, orig_lhs
, orig_rhs
);
5030 stmt
= build_min_nt_loc (EXPR_LOCATION (orig_rhs1
),
5031 COMPOUND_EXPR
, orig_rhs1
, stmt
);
5032 if (code
!= OMP_ATOMIC
)
5034 stmt
= build_min_nt_loc (EXPR_LOCATION (orig_lhs1
),
5035 code
, orig_lhs1
, stmt
);
5036 stmt
= build2 (MODIFY_EXPR
, void_type_node
, orig_v
, stmt
);
5039 stmt
= build2 (OMP_ATOMIC
, void_type_node
, integer_zero_node
, stmt
);
5045 finish_omp_barrier (void)
5047 tree fn
= builtin_decl_explicit (BUILT_IN_GOMP_BARRIER
);
5048 vec
<tree
, va_gc
> *vec
= make_tree_vector ();
5049 tree stmt
= finish_call_expr (fn
, &vec
, false, false, tf_warning_or_error
);
5050 release_tree_vector (vec
);
5051 finish_expr_stmt (stmt
);
5055 finish_omp_flush (void)
5057 tree fn
= builtin_decl_explicit (BUILT_IN_SYNC_SYNCHRONIZE
);
5058 vec
<tree
, va_gc
> *vec
= make_tree_vector ();
5059 tree stmt
= finish_call_expr (fn
, &vec
, false, false, tf_warning_or_error
);
5060 release_tree_vector (vec
);
5061 finish_expr_stmt (stmt
);
5065 finish_omp_taskwait (void)
5067 tree fn
= builtin_decl_explicit (BUILT_IN_GOMP_TASKWAIT
);
5068 vec
<tree
, va_gc
> *vec
= make_tree_vector ();
5069 tree stmt
= finish_call_expr (fn
, &vec
, false, false, tf_warning_or_error
);
5070 release_tree_vector (vec
);
5071 finish_expr_stmt (stmt
);
5075 finish_omp_taskyield (void)
5077 tree fn
= builtin_decl_explicit (BUILT_IN_GOMP_TASKYIELD
);
5078 vec
<tree
, va_gc
> *vec
= make_tree_vector ();
5079 tree stmt
= finish_call_expr (fn
, &vec
, false, false, tf_warning_or_error
);
5080 release_tree_vector (vec
);
5081 finish_expr_stmt (stmt
);
5084 /* Begin a __transaction_atomic or __transaction_relaxed statement.
5085 If PCOMPOUND is non-null, this is for a function-transaction-block, and we
5086 should create an extra compound stmt. */
5089 begin_transaction_stmt (location_t loc
, tree
*pcompound
, int flags
)
5094 *pcompound
= begin_compound_stmt (0);
5096 r
= build_stmt (loc
, TRANSACTION_EXPR
, NULL_TREE
);
5098 /* Only add the statement to the function if support enabled. */
5102 error_at (loc
, ((flags
& TM_STMT_ATTR_RELAXED
) != 0
5103 ? G_("%<__transaction_relaxed%> without "
5104 "transactional memory support enabled")
5105 : G_("%<__transaction_atomic%> without "
5106 "transactional memory support enabled")));
5108 TRANSACTION_EXPR_BODY (r
) = push_stmt_list ();
5109 TREE_SIDE_EFFECTS (r
) = 1;
5113 /* End a __transaction_atomic or __transaction_relaxed statement.
5114 If COMPOUND_STMT is non-null, this is for a function-transaction-block,
5115 and we should end the compound. If NOEX is non-NULL, we wrap the body in
5116 a MUST_NOT_THROW_EXPR with NOEX as condition. */
5119 finish_transaction_stmt (tree stmt
, tree compound_stmt
, int flags
, tree noex
)
5121 TRANSACTION_EXPR_BODY (stmt
) = pop_stmt_list (TRANSACTION_EXPR_BODY (stmt
));
5122 TRANSACTION_EXPR_OUTER (stmt
) = (flags
& TM_STMT_ATTR_OUTER
) != 0;
5123 TRANSACTION_EXPR_RELAXED (stmt
) = (flags
& TM_STMT_ATTR_RELAXED
) != 0;
5124 TRANSACTION_EXPR_IS_STMT (stmt
) = 1;
5126 /* noexcept specifications are not allowed for function transactions. */
5127 gcc_assert (!(noex
&& compound_stmt
));
5130 tree body
= build_must_not_throw_expr (TRANSACTION_EXPR_BODY (stmt
),
5132 SET_EXPR_LOCATION (body
, EXPR_LOCATION (TRANSACTION_EXPR_BODY (stmt
)));
5133 TREE_SIDE_EFFECTS (body
) = 1;
5134 TRANSACTION_EXPR_BODY (stmt
) = body
;
5138 finish_compound_stmt (compound_stmt
);
5142 /* Build a __transaction_atomic or __transaction_relaxed expression. If
5143 NOEX is non-NULL, we wrap the body in a MUST_NOT_THROW_EXPR with NOEX as
5147 build_transaction_expr (location_t loc
, tree expr
, int flags
, tree noex
)
5152 expr
= build_must_not_throw_expr (expr
, noex
);
5153 SET_EXPR_LOCATION (expr
, loc
);
5154 TREE_SIDE_EFFECTS (expr
) = 1;
5156 ret
= build1 (TRANSACTION_EXPR
, TREE_TYPE (expr
), expr
);
5157 if (flags
& TM_STMT_ATTR_RELAXED
)
5158 TRANSACTION_EXPR_RELAXED (ret
) = 1;
5159 TREE_SIDE_EFFECTS (ret
) = 1;
5160 SET_EXPR_LOCATION (ret
, loc
);
5165 init_cp_semantics (void)
5169 /* Build a STATIC_ASSERT for a static assertion with the condition
5170 CONDITION and the message text MESSAGE. LOCATION is the location
5171 of the static assertion in the source code. When MEMBER_P, this
5172 static assertion is a member of a class. */
5174 finish_static_assert (tree condition
, tree message
, location_t location
,
5177 if (message
== NULL_TREE
5178 || message
== error_mark_node
5179 || condition
== NULL_TREE
5180 || condition
== error_mark_node
)
5183 if (check_for_bare_parameter_packs (condition
))
5184 condition
= error_mark_node
;
5186 if (type_dependent_expression_p (condition
)
5187 || value_dependent_expression_p (condition
))
5189 /* We're in a template; build a STATIC_ASSERT and put it in
5193 assertion
= make_node (STATIC_ASSERT
);
5194 STATIC_ASSERT_CONDITION (assertion
) = condition
;
5195 STATIC_ASSERT_MESSAGE (assertion
) = message
;
5196 STATIC_ASSERT_SOURCE_LOCATION (assertion
) = location
;
5199 maybe_add_class_template_decl_list (current_class_type
,
5203 add_stmt (assertion
);
5208 /* Fold the expression and convert it to a boolean value. */
5209 condition
= fold_non_dependent_expr (condition
);
5210 condition
= cp_convert (boolean_type_node
, condition
, tf_warning_or_error
);
5211 condition
= maybe_constant_value (condition
);
5213 if (TREE_CODE (condition
) == INTEGER_CST
&& !integer_zerop (condition
))
5214 /* Do nothing; the condition is satisfied. */
5218 location_t saved_loc
= input_location
;
5220 input_location
= location
;
5221 if (TREE_CODE (condition
) == INTEGER_CST
5222 && integer_zerop (condition
))
5223 /* Report the error. */
5224 error ("static assertion failed: %s", TREE_STRING_POINTER (message
));
5225 else if (condition
&& condition
!= error_mark_node
)
5227 error ("non-constant condition for static assertion");
5228 cxx_constant_value (condition
);
5230 input_location
= saved_loc
;
5234 /* Implements the C++0x decltype keyword. Returns the type of EXPR,
5235 suitable for use as a type-specifier.
5237 ID_EXPRESSION_OR_MEMBER_ACCESS_P is true when EXPR was parsed as an
5238 id-expression or a class member access, FALSE when it was parsed as
5239 a full expression. */
5242 finish_decltype_type (tree expr
, bool id_expression_or_member_access_p
,
5243 tsubst_flags_t complain
)
5245 tree type
= NULL_TREE
;
5247 if (!expr
|| error_operand_p (expr
))
5248 return error_mark_node
;
5251 || TREE_CODE (expr
) == TYPE_DECL
5252 || (TREE_CODE (expr
) == BIT_NOT_EXPR
5253 && TYPE_P (TREE_OPERAND (expr
, 0))))
5255 if (complain
& tf_error
)
5256 error ("argument to decltype must be an expression");
5257 return error_mark_node
;
5260 /* Depending on the resolution of DR 1172, we may later need to distinguish
5261 instantiation-dependent but not type-dependent expressions so that, say,
5262 A<decltype(sizeof(T))>::U doesn't require 'typename'. */
5263 if (instantiation_dependent_expression_p (expr
))
5265 type
= cxx_make_type (DECLTYPE_TYPE
);
5266 DECLTYPE_TYPE_EXPR (type
) = expr
;
5267 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type
)
5268 = id_expression_or_member_access_p
;
5269 SET_TYPE_STRUCTURAL_EQUALITY (type
);
5274 /* The type denoted by decltype(e) is defined as follows: */
5276 expr
= resolve_nondeduced_context (expr
);
5278 if (type_unknown_p (expr
))
5280 if (complain
& tf_error
)
5281 error ("decltype cannot resolve address of overloaded function");
5282 return error_mark_node
;
5285 if (invalid_nonstatic_memfn_p (expr
, complain
))
5286 return error_mark_node
;
5288 /* To get the size of a static data member declared as an array of
5289 unknown bound, we need to instantiate it. */
5290 if (TREE_CODE (expr
) == VAR_DECL
5291 && VAR_HAD_UNKNOWN_BOUND (expr
)
5292 && DECL_TEMPLATE_INSTANTIATION (expr
))
5293 instantiate_decl (expr
, /*defer_ok*/true, /*expl_inst_mem*/false);
5295 if (id_expression_or_member_access_p
)
5297 /* If e is an id-expression or a class member access (5.2.5
5298 [expr.ref]), decltype(e) is defined as the type of the entity
5299 named by e. If there is no such entity, or e names a set of
5300 overloaded functions, the program is ill-formed. */
5301 if (identifier_p (expr
))
5302 expr
= lookup_name (expr
);
5304 if (TREE_CODE (expr
) == INDIRECT_REF
)
5305 /* This can happen when the expression is, e.g., "a.b". Just
5306 look at the underlying operand. */
5307 expr
= TREE_OPERAND (expr
, 0);
5309 if (TREE_CODE (expr
) == OFFSET_REF
5310 || TREE_CODE (expr
) == MEMBER_REF
5311 || TREE_CODE (expr
) == SCOPE_REF
)
5312 /* We're only interested in the field itself. If it is a
5313 BASELINK, we will need to see through it in the next
5315 expr
= TREE_OPERAND (expr
, 1);
5317 if (BASELINK_P (expr
))
5318 /* See through BASELINK nodes to the underlying function. */
5319 expr
= BASELINK_FUNCTIONS (expr
);
5321 switch (TREE_CODE (expr
))
5324 if (DECL_BIT_FIELD_TYPE (expr
))
5326 type
= DECL_BIT_FIELD_TYPE (expr
);
5329 /* Fall through for fields that aren't bitfields. */
5336 case TEMPLATE_PARM_INDEX
:
5337 expr
= mark_type_use (expr
);
5338 type
= TREE_TYPE (expr
);
5342 type
= error_mark_node
;
5346 mark_type_use (expr
);
5347 type
= is_bitfield_expr_with_lowered_type (expr
);
5349 type
= TREE_TYPE (TREE_OPERAND (expr
, 1));
5357 /* We can get here when the id-expression refers to an
5358 enumerator or non-type template parameter. */
5359 type
= TREE_TYPE (expr
);
5364 return error_mark_node
;
5369 /* Within a lambda-expression:
5371 Every occurrence of decltype((x)) where x is a possibly
5372 parenthesized id-expression that names an entity of
5373 automatic storage duration is treated as if x were
5374 transformed into an access to a corresponding data member
5375 of the closure type that would have been declared if x
5376 were a use of the denoted entity. */
5377 if (outer_automatic_var_p (expr
)
5378 && current_function_decl
5379 && LAMBDA_FUNCTION_P (current_function_decl
))
5380 type
= capture_decltype (expr
);
5381 else if (error_operand_p (expr
))
5382 type
= error_mark_node
;
5383 else if (expr
== current_class_ptr
)
5384 /* If the expression is just "this", we want the
5385 cv-unqualified pointer for the "this" type. */
5386 type
= TYPE_MAIN_VARIANT (TREE_TYPE (expr
));
5389 /* Otherwise, where T is the type of e, if e is an lvalue,
5390 decltype(e) is defined as T&; if an xvalue, T&&; otherwise, T. */
5391 cp_lvalue_kind clk
= lvalue_kind (expr
);
5392 type
= unlowered_expr_type (expr
);
5393 gcc_assert (TREE_CODE (type
) != REFERENCE_TYPE
);
5395 /* For vector types, pick a non-opaque variant. */
5396 if (TREE_CODE (type
) == VECTOR_TYPE
)
5397 type
= strip_typedefs (type
);
5399 if (clk
!= clk_none
&& !(clk
& clk_class
))
5400 type
= cp_build_reference_type (type
, (clk
& clk_rvalueref
));
5407 /* Called from trait_expr_value to evaluate either __has_nothrow_assign or
5408 __has_nothrow_copy, depending on assign_p. */
5411 classtype_has_nothrow_assign_or_copy_p (tree type
, bool assign_p
)
5418 ix
= lookup_fnfields_1 (type
, ansi_assopname (NOP_EXPR
));
5421 fns
= (*CLASSTYPE_METHOD_VEC (type
))[ix
];
5423 else if (TYPE_HAS_COPY_CTOR (type
))
5425 /* If construction of the copy constructor was postponed, create
5427 if (CLASSTYPE_LAZY_COPY_CTOR (type
))
5428 lazily_declare_fn (sfk_copy_constructor
, type
);
5429 if (CLASSTYPE_LAZY_MOVE_CTOR (type
))
5430 lazily_declare_fn (sfk_move_constructor
, type
);
5431 fns
= CLASSTYPE_CONSTRUCTORS (type
);
5436 for (; fns
; fns
= OVL_NEXT (fns
))
5438 tree fn
= OVL_CURRENT (fns
);
5442 if (copy_fn_p (fn
) == 0)
5445 else if (copy_fn_p (fn
) <= 0)
5448 maybe_instantiate_noexcept (fn
);
5449 if (!TYPE_NOTHROW_P (TREE_TYPE (fn
)))
5456 /* Actually evaluates the trait. */
5459 trait_expr_value (cp_trait_kind kind
, tree type1
, tree type2
)
5461 enum tree_code type_code1
;
5464 type_code1
= TREE_CODE (type1
);
5468 case CPTK_HAS_NOTHROW_ASSIGN
:
5469 type1
= strip_array_types (type1
);
5470 return (!CP_TYPE_CONST_P (type1
) && type_code1
!= REFERENCE_TYPE
5471 && (trait_expr_value (CPTK_HAS_TRIVIAL_ASSIGN
, type1
, type2
)
5472 || (CLASS_TYPE_P (type1
)
5473 && classtype_has_nothrow_assign_or_copy_p (type1
,
5476 case CPTK_HAS_TRIVIAL_ASSIGN
:
5477 /* ??? The standard seems to be missing the "or array of such a class
5478 type" wording for this trait. */
5479 type1
= strip_array_types (type1
);
5480 return (!CP_TYPE_CONST_P (type1
) && type_code1
!= REFERENCE_TYPE
5481 && (trivial_type_p (type1
)
5482 || (CLASS_TYPE_P (type1
)
5483 && TYPE_HAS_TRIVIAL_COPY_ASSIGN (type1
))));
5485 case CPTK_HAS_NOTHROW_CONSTRUCTOR
:
5486 type1
= strip_array_types (type1
);
5487 return (trait_expr_value (CPTK_HAS_TRIVIAL_CONSTRUCTOR
, type1
, type2
)
5488 || (CLASS_TYPE_P (type1
)
5489 && (t
= locate_ctor (type1
))
5490 && (maybe_instantiate_noexcept (t
),
5491 TYPE_NOTHROW_P (TREE_TYPE (t
)))));
5493 case CPTK_HAS_TRIVIAL_CONSTRUCTOR
:
5494 type1
= strip_array_types (type1
);
5495 return (trivial_type_p (type1
)
5496 || (CLASS_TYPE_P (type1
) && TYPE_HAS_TRIVIAL_DFLT (type1
)));
5498 case CPTK_HAS_NOTHROW_COPY
:
5499 type1
= strip_array_types (type1
);
5500 return (trait_expr_value (CPTK_HAS_TRIVIAL_COPY
, type1
, type2
)
5501 || (CLASS_TYPE_P (type1
)
5502 && classtype_has_nothrow_assign_or_copy_p (type1
, false)));
5504 case CPTK_HAS_TRIVIAL_COPY
:
5505 /* ??? The standard seems to be missing the "or array of such a class
5506 type" wording for this trait. */
5507 type1
= strip_array_types (type1
);
5508 return (trivial_type_p (type1
) || type_code1
== REFERENCE_TYPE
5509 || (CLASS_TYPE_P (type1
) && TYPE_HAS_TRIVIAL_COPY_CTOR (type1
)));
5511 case CPTK_HAS_TRIVIAL_DESTRUCTOR
:
5512 type1
= strip_array_types (type1
);
5513 return (trivial_type_p (type1
) || type_code1
== REFERENCE_TYPE
5514 || (CLASS_TYPE_P (type1
)
5515 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type1
)));
5517 case CPTK_HAS_VIRTUAL_DESTRUCTOR
:
5518 return type_has_virtual_destructor (type1
);
5520 case CPTK_IS_ABSTRACT
:
5521 return (ABSTRACT_CLASS_TYPE_P (type1
));
5523 case CPTK_IS_BASE_OF
:
5524 return (NON_UNION_CLASS_TYPE_P (type1
) && NON_UNION_CLASS_TYPE_P (type2
)
5525 && DERIVED_FROM_P (type1
, type2
));
5528 return (NON_UNION_CLASS_TYPE_P (type1
));
5530 case CPTK_IS_CONVERTIBLE_TO
:
5535 return (NON_UNION_CLASS_TYPE_P (type1
) && CLASSTYPE_EMPTY_P (type1
));
5538 return (type_code1
== ENUMERAL_TYPE
);
5541 return (CLASS_TYPE_P (type1
) && CLASSTYPE_FINAL (type1
));
5543 case CPTK_IS_LITERAL_TYPE
:
5544 return (literal_type_p (type1
));
5547 return (pod_type_p (type1
));
5549 case CPTK_IS_POLYMORPHIC
:
5550 return (CLASS_TYPE_P (type1
) && TYPE_POLYMORPHIC_P (type1
));
5552 case CPTK_IS_STD_LAYOUT
:
5553 return (std_layout_type_p (type1
));
5555 case CPTK_IS_TRIVIAL
:
5556 return (trivial_type_p (type1
));
5559 return (type_code1
== UNION_TYPE
);
5567 /* If TYPE is an array of unknown bound, or (possibly cv-qualified)
5568 void, or a complete type, returns it, otherwise NULL_TREE. */
5571 check_trait_type (tree type
)
5573 if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
)
5574 && COMPLETE_TYPE_P (TREE_TYPE (type
)))
5577 if (VOID_TYPE_P (type
))
5580 return complete_type_or_else (strip_array_types (type
), NULL_TREE
);
5583 /* Process a trait expression. */
5586 finish_trait_expr (cp_trait_kind kind
, tree type1
, tree type2
)
5588 gcc_assert (kind
== CPTK_HAS_NOTHROW_ASSIGN
5589 || kind
== CPTK_HAS_NOTHROW_CONSTRUCTOR
5590 || kind
== CPTK_HAS_NOTHROW_COPY
5591 || kind
== CPTK_HAS_TRIVIAL_ASSIGN
5592 || kind
== CPTK_HAS_TRIVIAL_CONSTRUCTOR
5593 || kind
== CPTK_HAS_TRIVIAL_COPY
5594 || kind
== CPTK_HAS_TRIVIAL_DESTRUCTOR
5595 || kind
== CPTK_HAS_VIRTUAL_DESTRUCTOR
5596 || kind
== CPTK_IS_ABSTRACT
5597 || kind
== CPTK_IS_BASE_OF
5598 || kind
== CPTK_IS_CLASS
5599 || kind
== CPTK_IS_CONVERTIBLE_TO
5600 || kind
== CPTK_IS_EMPTY
5601 || kind
== CPTK_IS_ENUM
5602 || kind
== CPTK_IS_FINAL
5603 || kind
== CPTK_IS_LITERAL_TYPE
5604 || kind
== CPTK_IS_POD
5605 || kind
== CPTK_IS_POLYMORPHIC
5606 || kind
== CPTK_IS_STD_LAYOUT
5607 || kind
== CPTK_IS_TRIVIAL
5608 || kind
== CPTK_IS_UNION
);
5610 if (kind
== CPTK_IS_CONVERTIBLE_TO
)
5612 sorry ("__is_convertible_to");
5613 return error_mark_node
;
5616 if (type1
== error_mark_node
5617 || ((kind
== CPTK_IS_BASE_OF
|| kind
== CPTK_IS_CONVERTIBLE_TO
)
5618 && type2
== error_mark_node
))
5619 return error_mark_node
;
5621 if (processing_template_decl
)
5623 tree trait_expr
= make_node (TRAIT_EXPR
);
5624 TREE_TYPE (trait_expr
) = boolean_type_node
;
5625 TRAIT_EXPR_TYPE1 (trait_expr
) = type1
;
5626 TRAIT_EXPR_TYPE2 (trait_expr
) = type2
;
5627 TRAIT_EXPR_KIND (trait_expr
) = kind
;
5633 case CPTK_HAS_NOTHROW_ASSIGN
:
5634 case CPTK_HAS_TRIVIAL_ASSIGN
:
5635 case CPTK_HAS_NOTHROW_CONSTRUCTOR
:
5636 case CPTK_HAS_TRIVIAL_CONSTRUCTOR
:
5637 case CPTK_HAS_NOTHROW_COPY
:
5638 case CPTK_HAS_TRIVIAL_COPY
:
5639 case CPTK_HAS_TRIVIAL_DESTRUCTOR
:
5640 case CPTK_HAS_VIRTUAL_DESTRUCTOR
:
5641 case CPTK_IS_ABSTRACT
:
5644 case CPTK_IS_LITERAL_TYPE
:
5646 case CPTK_IS_POLYMORPHIC
:
5647 case CPTK_IS_STD_LAYOUT
:
5648 case CPTK_IS_TRIVIAL
:
5649 if (!check_trait_type (type1
))
5650 return error_mark_node
;
5653 case CPTK_IS_BASE_OF
:
5654 if (NON_UNION_CLASS_TYPE_P (type1
) && NON_UNION_CLASS_TYPE_P (type2
)
5655 && !same_type_ignoring_top_level_qualifiers_p (type1
, type2
)
5656 && !complete_type_or_else (type2
, NULL_TREE
))
5657 /* We already issued an error. */
5658 return error_mark_node
;
5666 case CPTK_IS_CONVERTIBLE_TO
:
5671 return (trait_expr_value (kind
, type1
, type2
)
5672 ? boolean_true_node
: boolean_false_node
);
5675 /* Do-nothing variants of functions to handle pragma FLOAT_CONST_DECIMAL64,
5676 which is ignored for C++. */
5679 set_float_const_decimal64 (void)
5684 clear_float_const_decimal64 (void)
5689 float_const_decimal64_p (void)
5695 /* Return true if T is a literal type. */
5698 literal_type_p (tree t
)
5700 if (SCALAR_TYPE_P (t
)
5701 || TREE_CODE (t
) == VECTOR_TYPE
5702 || TREE_CODE (t
) == REFERENCE_TYPE
)
5704 if (CLASS_TYPE_P (t
))
5706 t
= complete_type (t
);
5707 gcc_assert (COMPLETE_TYPE_P (t
) || errorcount
);
5708 return CLASSTYPE_LITERAL_P (t
);
5710 if (TREE_CODE (t
) == ARRAY_TYPE
)
5711 return literal_type_p (strip_array_types (t
));
5715 /* If DECL is a variable declared `constexpr', require its type
5716 be literal. Return the DECL if OK, otherwise NULL. */
5719 ensure_literal_type_for_constexpr_object (tree decl
)
5721 tree type
= TREE_TYPE (decl
);
5722 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_DECLARED_CONSTEXPR_P (decl
)
5723 && !processing_template_decl
)
5725 if (CLASS_TYPE_P (type
) && !COMPLETE_TYPE_P (complete_type (type
)))
5726 /* Don't complain here, we'll complain about incompleteness
5727 when we try to initialize the variable. */;
5728 else if (!literal_type_p (type
))
5730 error ("the type %qT of constexpr variable %qD is not literal",
5732 explain_non_literal_class (type
);
5739 /* Representation of entries in the constexpr function definition table. */
5741 typedef struct GTY(()) constexpr_fundef
{
5746 /* This table holds all constexpr function definitions seen in
5747 the current translation unit. */
5749 static GTY ((param_is (constexpr_fundef
))) htab_t constexpr_fundef_table
;
5751 /* Utility function used for managing the constexpr function table.
5752 Return true if the entries pointed to by P and Q are for the
5753 same constexpr function. */
5756 constexpr_fundef_equal (const void *p
, const void *q
)
5758 const constexpr_fundef
*lhs
= (const constexpr_fundef
*) p
;
5759 const constexpr_fundef
*rhs
= (const constexpr_fundef
*) q
;
5760 return lhs
->decl
== rhs
->decl
;
5763 /* Utility function used for managing the constexpr function table.
5764 Return a hash value for the entry pointed to by Q. */
5766 static inline hashval_t
5767 constexpr_fundef_hash (const void *p
)
5769 const constexpr_fundef
*fundef
= (const constexpr_fundef
*) p
;
5770 return DECL_UID (fundef
->decl
);
5773 /* Return a previously saved definition of function FUN. */
5775 static constexpr_fundef
*
5776 retrieve_constexpr_fundef (tree fun
)
5778 constexpr_fundef fundef
= { NULL
, NULL
};
5779 if (constexpr_fundef_table
== NULL
)
5783 return (constexpr_fundef
*) htab_find (constexpr_fundef_table
, &fundef
);
5786 /* Check whether the parameter and return types of FUN are valid for a
5787 constexpr function, and complain if COMPLAIN. */
5790 is_valid_constexpr_fn (tree fun
, bool complain
)
5792 tree parm
= FUNCTION_FIRST_USER_PARM (fun
);
5794 for (; parm
!= NULL
; parm
= TREE_CHAIN (parm
))
5795 if (!literal_type_p (TREE_TYPE (parm
)))
5800 error ("invalid type for parameter %d of constexpr "
5801 "function %q+#D", DECL_PARM_INDEX (parm
), fun
);
5802 explain_non_literal_class (TREE_TYPE (parm
));
5806 if (!DECL_CONSTRUCTOR_P (fun
))
5808 tree rettype
= TREE_TYPE (TREE_TYPE (fun
));
5809 if (!literal_type_p (rettype
))
5814 error ("invalid return type %qT of constexpr function %q+D",
5816 explain_non_literal_class (rettype
);
5820 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
5821 && !CLASSTYPE_LITERAL_P (DECL_CONTEXT (fun
)))
5826 error ("enclosing class of constexpr non-static member "
5827 "function %q+#D is not a literal type", fun
);
5828 explain_non_literal_class (DECL_CONTEXT (fun
));
5832 else if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fun
)))
5836 error ("%q#T has virtual base classes", DECL_CONTEXT (fun
));
5842 /* Subroutine of build_data_member_initialization. MEMBER is a COMPONENT_REF
5843 for a member of an anonymous aggregate, INIT is the initializer for that
5844 member, and VEC_OUTER is the vector of constructor elements for the class
5845 whose constructor we are processing. Add the initializer to the vector
5846 and return true to indicate success. */
5849 build_anon_member_initialization (tree member
, tree init
,
5850 vec
<constructor_elt
, va_gc
> **vec_outer
)
5852 /* MEMBER presents the relevant fields from the inside out, but we need
5853 to build up the initializer from the outside in so that we can reuse
5854 previously built CONSTRUCTORs if this is, say, the second field in an
5855 anonymous struct. So we use a vec as a stack. */
5860 fields
.safe_push (TREE_OPERAND (member
, 1));
5861 member
= TREE_OPERAND (member
, 0);
5863 while (ANON_AGGR_TYPE_P (TREE_TYPE (member
)));
5865 /* VEC has the constructor elements vector for the context of FIELD.
5866 If FIELD is an anonymous aggregate, we will push inside it. */
5867 vec
<constructor_elt
, va_gc
> **vec
= vec_outer
;
5869 while (field
= fields
.pop(),
5870 ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
5873 /* If there is already an outer constructor entry for the anonymous
5874 aggregate FIELD, use it; otherwise, insert one. */
5875 if (vec_safe_is_empty (*vec
)
5876 || (*vec
)->last().index
!= field
)
5878 ctor
= build_constructor (TREE_TYPE (field
), NULL
);
5879 CONSTRUCTOR_APPEND_ELT (*vec
, field
, ctor
);
5882 ctor
= (*vec
)->last().value
;
5883 vec
= &CONSTRUCTOR_ELTS (ctor
);
5886 /* Now we're at the innermost field, the one that isn't an anonymous
5887 aggregate. Add its initializer to the CONSTRUCTOR and we're done. */
5888 gcc_assert (fields
.is_empty());
5890 CONSTRUCTOR_APPEND_ELT (*vec
, field
, init
);
5895 /* Subroutine of build_constexpr_constructor_member_initializers.
5896 The expression tree T represents a data member initialization
5897 in a (constexpr) constructor definition. Build a pairing of
5898 the data member with its initializer, and prepend that pair
5899 to the existing initialization pair INITS. */
5902 build_data_member_initialization (tree t
, vec
<constructor_elt
, va_gc
> **vec
)
5905 if (TREE_CODE (t
) == CLEANUP_POINT_EXPR
)
5906 t
= TREE_OPERAND (t
, 0);
5907 if (TREE_CODE (t
) == EXPR_STMT
)
5908 t
= TREE_OPERAND (t
, 0);
5909 if (t
== error_mark_node
)
5911 if (TREE_CODE (t
) == STATEMENT_LIST
)
5913 tree_stmt_iterator i
;
5914 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
5916 if (! build_data_member_initialization (tsi_stmt (i
), vec
))
5921 if (TREE_CODE (t
) == CLEANUP_STMT
)
5923 /* We can't see a CLEANUP_STMT in a constructor for a literal class,
5924 but we can in a constexpr constructor for a non-literal class. Just
5925 ignore it; either all the initialization will be constant, in which
5926 case the cleanup can't run, or it can't be constexpr.
5927 Still recurse into CLEANUP_BODY. */
5928 return build_data_member_initialization (CLEANUP_BODY (t
), vec
);
5930 if (TREE_CODE (t
) == CONVERT_EXPR
)
5931 t
= TREE_OPERAND (t
, 0);
5932 if (TREE_CODE (t
) == INIT_EXPR
5933 || TREE_CODE (t
) == MODIFY_EXPR
)
5935 member
= TREE_OPERAND (t
, 0);
5936 init
= unshare_expr (TREE_OPERAND (t
, 1));
5938 else if (TREE_CODE (t
) == CALL_EXPR
)
5940 member
= CALL_EXPR_ARG (t
, 0);
5941 /* We don't use build_cplus_new here because it complains about
5942 abstract bases. Leaving the call unwrapped means that it has the
5943 wrong type, but cxx_eval_constant_expression doesn't care. */
5944 init
= unshare_expr (t
);
5946 else if (TREE_CODE (t
) == DECL_EXPR
)
5947 /* Declaring a temporary, don't add it to the CONSTRUCTOR. */
5951 if (TREE_CODE (member
) == INDIRECT_REF
)
5952 member
= TREE_OPERAND (member
, 0);
5953 if (TREE_CODE (member
) == NOP_EXPR
)
5957 if (TREE_CODE (op
) == ADDR_EXPR
)
5959 gcc_assert (same_type_ignoring_top_level_qualifiers_p
5960 (TREE_TYPE (TREE_TYPE (op
)),
5961 TREE_TYPE (TREE_TYPE (member
))));
5962 /* Initializing a cv-qualified member; we need to look through
5966 else if (op
== current_class_ptr
5967 && (same_type_ignoring_top_level_qualifiers_p
5968 (TREE_TYPE (TREE_TYPE (member
)),
5969 current_class_type
)))
5970 /* Delegating constructor. */
5974 /* This is an initializer for an empty base; keep it for now so
5975 we can check it in cxx_eval_bare_aggregate. */
5976 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member
))));
5979 if (TREE_CODE (member
) == ADDR_EXPR
)
5980 member
= TREE_OPERAND (member
, 0);
5981 if (TREE_CODE (member
) == COMPONENT_REF
)
5983 tree aggr
= TREE_OPERAND (member
, 0);
5984 if (TREE_CODE (aggr
) != COMPONENT_REF
)
5985 /* Normal member initialization. */
5986 member
= TREE_OPERAND (member
, 1);
5987 else if (ANON_AGGR_TYPE_P (TREE_TYPE (aggr
)))
5988 /* Initializing a member of an anonymous union. */
5989 return build_anon_member_initialization (member
, init
, vec
);
5991 /* We're initializing a vtable pointer in a base. Leave it as
5992 COMPONENT_REF so we remember the path to get to the vfield. */
5993 gcc_assert (TREE_TYPE (member
) == vtbl_ptr_type_node
);
5996 CONSTRUCTOR_APPEND_ELT (*vec
, member
, init
);
6000 /* Make sure that there are no statements after LAST in the constructor
6001 body represented by LIST. */
6004 check_constexpr_ctor_body (tree last
, tree list
)
6007 if (TREE_CODE (list
) == STATEMENT_LIST
)
6009 tree_stmt_iterator i
= tsi_last (list
);
6010 for (; !tsi_end_p (i
); tsi_prev (&i
))
6012 tree t
= tsi_stmt (i
);
6015 if (TREE_CODE (t
) == BIND_EXPR
)
6017 if (!check_constexpr_ctor_body (last
, BIND_EXPR_BODY (t
)))
6022 /* We currently allow typedefs and static_assert.
6023 FIXME allow them in the standard, too. */
6024 if (TREE_CODE (t
) != STATIC_ASSERT
)
6031 else if (list
!= last
6032 && TREE_CODE (list
) != STATIC_ASSERT
)
6036 error ("constexpr constructor does not have empty body");
6037 DECL_DECLARED_CONSTEXPR_P (current_function_decl
) = false;
6042 /* V is a vector of constructor elements built up for the base and member
6043 initializers of a constructor for TYPE. They need to be in increasing
6044 offset order, which they might not be yet if TYPE has a primary base
6045 which is not first in the base-clause or a vptr and at least one base
6046 all of which are non-primary. */
6048 static vec
<constructor_elt
, va_gc
> *
6049 sort_constexpr_mem_initializers (tree type
, vec
<constructor_elt
, va_gc
> *v
)
6051 tree pri
= CLASSTYPE_PRIMARY_BINFO (type
);
6053 constructor_elt elt
;
6057 field_type
= BINFO_TYPE (pri
);
6058 else if (TYPE_CONTAINS_VPTR_P (type
))
6059 field_type
= vtbl_ptr_type_node
;
6063 /* Find the element for the primary base or vptr and move it to the
6064 beginning of the vec. */
6065 vec
<constructor_elt
, va_gc
> &vref
= *v
;
6067 if (TREE_TYPE (vref
[i
].index
) == field_type
)
6074 vref
[i
] = vref
[i
-1];
6081 /* Build compile-time evalable representations of member-initializer list
6082 for a constexpr constructor. */
6085 build_constexpr_constructor_member_initializers (tree type
, tree body
)
6087 vec
<constructor_elt
, va_gc
> *vec
= NULL
;
6089 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
6090 || TREE_CODE (body
) == EH_SPEC_BLOCK
)
6091 body
= TREE_OPERAND (body
, 0);
6092 if (TREE_CODE (body
) == STATEMENT_LIST
)
6093 body
= STATEMENT_LIST_HEAD (body
)->stmt
;
6094 body
= BIND_EXPR_BODY (body
);
6095 if (TREE_CODE (body
) == CLEANUP_POINT_EXPR
)
6097 body
= TREE_OPERAND (body
, 0);
6098 if (TREE_CODE (body
) == EXPR_STMT
)
6099 body
= TREE_OPERAND (body
, 0);
6100 if (TREE_CODE (body
) == INIT_EXPR
6101 && (same_type_ignoring_top_level_qualifiers_p
6102 (TREE_TYPE (TREE_OPERAND (body
, 0)),
6103 current_class_type
)))
6106 return TREE_OPERAND (body
, 1);
6108 ok
= build_data_member_initialization (body
, &vec
);
6110 else if (TREE_CODE (body
) == STATEMENT_LIST
)
6112 tree_stmt_iterator i
;
6113 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
6115 ok
= build_data_member_initialization (tsi_stmt (i
), &vec
);
6120 else if (TREE_CODE (body
) == TRY_BLOCK
)
6122 error ("body of %<constexpr%> constructor cannot be "
6123 "a function-try-block");
6124 return error_mark_node
;
6126 else if (EXPR_P (body
))
6127 ok
= build_data_member_initialization (body
, &vec
);
6129 gcc_assert (errorcount
> 0);
6132 if (vec_safe_length (vec
) > 0)
6134 /* In a delegating constructor, return the target. */
6135 constructor_elt
*ce
= &(*vec
)[0];
6136 if (ce
->index
== current_class_ptr
)
6143 vec
= sort_constexpr_mem_initializers (type
, vec
);
6144 return build_constructor (type
, vec
);
6147 return error_mark_node
;
6150 /* Subroutine of register_constexpr_fundef. BODY is the body of a function
6151 declared to be constexpr, or a sub-statement thereof. Returns the
6152 return value if suitable, error_mark_node for a statement not allowed in
6153 a constexpr function, or NULL_TREE if no return value was found. */
6156 constexpr_fn_retval (tree body
)
6158 switch (TREE_CODE (body
))
6160 case STATEMENT_LIST
:
6162 tree_stmt_iterator i
;
6163 tree expr
= NULL_TREE
;
6164 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
6166 tree s
= constexpr_fn_retval (tsi_stmt (i
));
6167 if (s
== error_mark_node
)
6168 return error_mark_node
;
6169 else if (s
== NULL_TREE
)
6170 /* Keep iterating. */;
6172 /* Multiple return statements. */
6173 return error_mark_node
;
6181 return unshare_expr (TREE_OPERAND (body
, 0));
6184 if (TREE_CODE (DECL_EXPR_DECL (body
)) == USING_DECL
)
6186 return error_mark_node
;
6188 case CLEANUP_POINT_EXPR
:
6189 return constexpr_fn_retval (TREE_OPERAND (body
, 0));
6195 return error_mark_node
;
6199 /* Subroutine of register_constexpr_fundef. BODY is the DECL_SAVED_TREE of
6200 FUN; do the necessary transformations to turn it into a single expression
6201 that we can store in the hash table. */
6204 massage_constexpr_body (tree fun
, tree body
)
6206 if (DECL_CONSTRUCTOR_P (fun
))
6207 body
= build_constexpr_constructor_member_initializers
6208 (DECL_CONTEXT (fun
), body
);
6211 if (TREE_CODE (body
) == EH_SPEC_BLOCK
)
6212 body
= EH_SPEC_STMTS (body
);
6213 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
6214 body
= TREE_OPERAND (body
, 0);
6215 if (TREE_CODE (body
) == BIND_EXPR
)
6216 body
= BIND_EXPR_BODY (body
);
6217 body
= constexpr_fn_retval (body
);
6222 /* FUN is a constexpr constructor with massaged body BODY. Return true
6223 if some bases/fields are uninitialized, and complain if COMPLAIN. */
6226 cx_check_missing_mem_inits (tree fun
, tree body
, bool complain
)
6233 if (TREE_CODE (body
) != CONSTRUCTOR
)
6236 nelts
= CONSTRUCTOR_NELTS (body
);
6237 ctype
= DECL_CONTEXT (fun
);
6238 field
= TYPE_FIELDS (ctype
);
6240 if (TREE_CODE (ctype
) == UNION_TYPE
)
6242 if (nelts
== 0 && next_initializable_field (field
))
6245 error ("%<constexpr%> constructor for union %qT must "
6246 "initialize exactly one non-static data member", ctype
);
6253 for (i
= 0; i
<= nelts
; ++i
)
6260 index
= CONSTRUCTOR_ELT (body
, i
)->index
;
6261 /* Skip base and vtable inits. */
6262 if (TREE_CODE (index
) != FIELD_DECL
6263 || DECL_ARTIFICIAL (index
))
6266 for (; field
!= index
; field
= DECL_CHAIN (field
))
6269 if (TREE_CODE (field
) != FIELD_DECL
6270 || (DECL_C_BIT_FIELD (field
) && !DECL_NAME (field
))
6271 || DECL_ARTIFICIAL (field
))
6273 ftype
= strip_array_types (TREE_TYPE (field
));
6274 if (type_has_constexpr_default_constructor (ftype
))
6276 /* It's OK to skip a member with a trivial constexpr ctor.
6277 A constexpr ctor that isn't trivial should have been
6279 gcc_checking_assert (!TYPE_HAS_COMPLEX_DFLT (ftype
)
6280 || errorcount
!= 0);
6285 error ("uninitialized member %qD in %<constexpr%> constructor",
6289 if (field
== NULL_TREE
)
6291 field
= DECL_CHAIN (field
);
6297 /* We are processing the definition of the constexpr function FUN.
6298 Check that its BODY fulfills the propriate requirements and
6299 enter it in the constexpr function definition table.
6300 For constructor BODY is actually the TREE_LIST of the
6301 member-initializer list. */
6304 register_constexpr_fundef (tree fun
, tree body
)
6306 constexpr_fundef entry
;
6307 constexpr_fundef
**slot
;
6309 if (!is_valid_constexpr_fn (fun
, !DECL_GENERATED_P (fun
)))
6312 body
= massage_constexpr_body (fun
, body
);
6313 if (body
== NULL_TREE
|| body
== error_mark_node
)
6315 if (!DECL_CONSTRUCTOR_P (fun
))
6316 error ("body of constexpr function %qD not a return-statement", fun
);
6320 if (!potential_rvalue_constant_expression (body
))
6322 if (!DECL_GENERATED_P (fun
))
6323 require_potential_rvalue_constant_expression (body
);
6327 if (DECL_CONSTRUCTOR_P (fun
)
6328 && cx_check_missing_mem_inits (fun
, body
, !DECL_GENERATED_P (fun
)))
6331 /* Create the constexpr function table if necessary. */
6332 if (constexpr_fundef_table
== NULL
)
6333 constexpr_fundef_table
= htab_create_ggc (101,
6334 constexpr_fundef_hash
,
6335 constexpr_fundef_equal
,
6339 slot
= (constexpr_fundef
**)
6340 htab_find_slot (constexpr_fundef_table
, &entry
, INSERT
);
6342 gcc_assert (*slot
== NULL
);
6343 *slot
= ggc_alloc_constexpr_fundef ();
6349 /* FUN is a non-constexpr function called in a context that requires a
6350 constant expression. If it comes from a constexpr template, explain why
6351 the instantiation isn't constexpr. */
6354 explain_invalid_constexpr_fn (tree fun
)
6356 static struct pointer_set_t
*diagnosed
;
6358 location_t save_loc
;
6359 /* Only diagnose defaulted functions or instantiations. */
6360 if (!DECL_DEFAULTED_FN (fun
)
6361 && !is_instantiation_of_constexpr (fun
))
6363 if (diagnosed
== NULL
)
6364 diagnosed
= pointer_set_create ();
6365 if (pointer_set_insert (diagnosed
, fun
) != 0)
6366 /* Already explained. */
6369 save_loc
= input_location
;
6370 input_location
= DECL_SOURCE_LOCATION (fun
);
6371 inform (0, "%q+D is not usable as a constexpr function because:", fun
);
6372 /* First check the declaration. */
6373 if (is_valid_constexpr_fn (fun
, true))
6375 /* Then if it's OK, the body. */
6376 if (DECL_DEFAULTED_FN (fun
))
6377 explain_implicit_non_constexpr (fun
);
6380 body
= massage_constexpr_body (fun
, DECL_SAVED_TREE (fun
));
6381 require_potential_rvalue_constant_expression (body
);
6382 if (DECL_CONSTRUCTOR_P (fun
))
6383 cx_check_missing_mem_inits (fun
, body
, true);
6386 input_location
= save_loc
;
6389 /* Objects of this type represent calls to constexpr functions
6390 along with the bindings of parameters to their arguments, for
6391 the purpose of compile time evaluation. */
6393 typedef struct GTY(()) constexpr_call
{
6394 /* Description of the constexpr function definition. */
6395 constexpr_fundef
*fundef
;
6396 /* Parameter bindings environment. A TREE_LIST where each TREE_PURPOSE
6397 is a parameter _DECL and the TREE_VALUE is the value of the parameter.
6398 Note: This arrangement is made to accomodate the use of
6399 iterative_hash_template_arg (see pt.c). If you change this
6400 representation, also change the hash calculation in
6401 cxx_eval_call_expression. */
6403 /* Result of the call.
6404 NULL means the call is being evaluated.
6405 error_mark_node means that the evaluation was erroneous;
6406 otherwise, the actuall value of the call. */
6408 /* The hash of this call; we remember it here to avoid having to
6409 recalculate it when expanding the hash table. */
6413 /* A table of all constexpr calls that have been evaluated by the
6414 compiler in this translation unit. */
6416 static GTY ((param_is (constexpr_call
))) htab_t constexpr_call_table
;
6418 static tree
cxx_eval_constant_expression (const constexpr_call
*, tree
,
6419 bool, bool, bool *, bool *);
6421 /* Compute a hash value for a constexpr call representation. */
6424 constexpr_call_hash (const void *p
)
6426 const constexpr_call
*info
= (const constexpr_call
*) p
;
6430 /* Return 1 if the objects pointed to by P and Q represent calls
6431 to the same constexpr function with the same arguments.
6432 Otherwise, return 0. */
6435 constexpr_call_equal (const void *p
, const void *q
)
6437 const constexpr_call
*lhs
= (const constexpr_call
*) p
;
6438 const constexpr_call
*rhs
= (const constexpr_call
*) q
;
6443 if (!constexpr_fundef_equal (lhs
->fundef
, rhs
->fundef
))
6445 lhs_bindings
= lhs
->bindings
;
6446 rhs_bindings
= rhs
->bindings
;
6447 while (lhs_bindings
!= NULL
&& rhs_bindings
!= NULL
)
6449 tree lhs_arg
= TREE_VALUE (lhs_bindings
);
6450 tree rhs_arg
= TREE_VALUE (rhs_bindings
);
6451 gcc_assert (TREE_TYPE (lhs_arg
) == TREE_TYPE (rhs_arg
));
6452 if (!cp_tree_equal (lhs_arg
, rhs_arg
))
6454 lhs_bindings
= TREE_CHAIN (lhs_bindings
);
6455 rhs_bindings
= TREE_CHAIN (rhs_bindings
);
6457 return lhs_bindings
== rhs_bindings
;
6460 /* Initialize the constexpr call table, if needed. */
6463 maybe_initialize_constexpr_call_table (void)
6465 if (constexpr_call_table
== NULL
)
6466 constexpr_call_table
= htab_create_ggc (101,
6467 constexpr_call_hash
,
6468 constexpr_call_equal
,
6472 /* Return true if T designates the implied `this' parameter. */
6475 is_this_parameter (tree t
)
6477 return t
== current_class_ptr
;
6480 /* We have an expression tree T that represents a call, either CALL_EXPR
6481 or AGGR_INIT_EXPR. If the call is lexically to a named function,
6482 retrun the _DECL for that function. */
6485 get_function_named_in_call (tree t
)
6488 switch (TREE_CODE (t
))
6491 fun
= CALL_EXPR_FN (t
);
6494 case AGGR_INIT_EXPR
:
6495 fun
= AGGR_INIT_EXPR_FN (t
);
6502 if (TREE_CODE (fun
) == ADDR_EXPR
6503 && TREE_CODE (TREE_OPERAND (fun
, 0)) == FUNCTION_DECL
)
6504 fun
= TREE_OPERAND (fun
, 0);
6508 /* We have an expression tree T that represents a call, either CALL_EXPR
6509 or AGGR_INIT_EXPR. Return the Nth argument. */
6512 get_nth_callarg (tree t
, int n
)
6514 switch (TREE_CODE (t
))
6517 return CALL_EXPR_ARG (t
, n
);
6519 case AGGR_INIT_EXPR
:
6520 return AGGR_INIT_EXPR_ARG (t
, n
);
6528 /* Look up the binding of the function parameter T in a constexpr
6529 function call context CALL. */
6532 lookup_parameter_binding (const constexpr_call
*call
, tree t
)
6534 tree b
= purpose_member (t
, call
->bindings
);
6535 return TREE_VALUE (b
);
6538 /* Attempt to evaluate T which represents a call to a builtin function.
6539 We assume here that all builtin functions evaluate to scalar types
6540 represented by _CST nodes. */
6543 cxx_eval_builtin_function_call (const constexpr_call
*call
, tree t
,
6544 bool allow_non_constant
, bool addr
,
6545 bool *non_constant_p
, bool *overflow_p
)
6547 const int nargs
= call_expr_nargs (t
);
6548 tree
*args
= (tree
*) alloca (nargs
* sizeof (tree
));
6551 for (i
= 0; i
< nargs
; ++i
)
6553 args
[i
] = cxx_eval_constant_expression (call
, CALL_EXPR_ARG (t
, i
),
6554 allow_non_constant
, addr
,
6555 non_constant_p
, overflow_p
);
6556 if (allow_non_constant
&& *non_constant_p
)
6559 if (*non_constant_p
)
6561 new_call
= build_call_array_loc (EXPR_LOCATION (t
), TREE_TYPE (t
),
6562 CALL_EXPR_FN (t
), nargs
, args
);
6563 new_call
= fold (new_call
);
6564 VERIFY_CONSTANT (new_call
);
6568 /* TEMP is the constant value of a temporary object of type TYPE. Adjust
6569 the type of the value to match. */
6572 adjust_temp_type (tree type
, tree temp
)
6574 if (TREE_TYPE (temp
) == type
)
6576 /* Avoid wrapping an aggregate value in a NOP_EXPR. */
6577 if (TREE_CODE (temp
) == CONSTRUCTOR
)
6578 return build_constructor (type
, CONSTRUCTOR_ELTS (temp
));
6579 gcc_assert (scalarish_type_p (type
));
6580 return cp_fold_convert (type
, temp
);
6583 /* Subroutine of cxx_eval_call_expression.
6584 We are processing a call expression (either CALL_EXPR or
6585 AGGR_INIT_EXPR) in the call context of OLD_CALL. Evaluate
6586 all arguments and bind their values to correspondings
6587 parameters, making up the NEW_CALL context. */
6590 cxx_bind_parameters_in_call (const constexpr_call
*old_call
, tree t
,
6591 constexpr_call
*new_call
,
6592 bool allow_non_constant
,
6593 bool *non_constant_p
, bool *overflow_p
)
6595 const int nargs
= call_expr_nargs (t
);
6596 tree fun
= new_call
->fundef
->decl
;
6597 tree parms
= DECL_ARGUMENTS (fun
);
6599 for (i
= 0; i
< nargs
; ++i
)
6602 tree type
= parms
? TREE_TYPE (parms
) : void_type_node
;
6603 /* For member function, the first argument is a pointer to the implied
6604 object. And for an object contruction, don't bind `this' before
6605 it is fully constructed. */
6606 if (i
== 0 && DECL_CONSTRUCTOR_P (fun
))
6608 x
= get_nth_callarg (t
, i
);
6609 if (parms
&& DECL_BY_REFERENCE (parms
))
6611 /* cp_genericize made this a reference for argument passing, but
6612 we don't want to treat it like one for constexpr evaluation. */
6613 gcc_assert (TREE_CODE (type
) == REFERENCE_TYPE
);
6614 gcc_assert (TREE_CODE (TREE_TYPE (x
)) == REFERENCE_TYPE
);
6615 type
= TREE_TYPE (type
);
6616 x
= convert_from_reference (x
);
6618 arg
= cxx_eval_constant_expression (old_call
, x
, allow_non_constant
,
6619 TREE_CODE (type
) == REFERENCE_TYPE
,
6620 non_constant_p
, overflow_p
);
6621 /* Don't VERIFY_CONSTANT here. */
6622 if (*non_constant_p
&& allow_non_constant
)
6624 /* Just discard ellipsis args after checking their constantitude. */
6627 if (*non_constant_p
)
6628 /* Don't try to adjust the type of non-constant args. */
6631 /* Make sure the binding has the same type as the parm. */
6632 if (TREE_CODE (type
) != REFERENCE_TYPE
)
6633 arg
= adjust_temp_type (type
, arg
);
6634 new_call
->bindings
= tree_cons (parms
, arg
, new_call
->bindings
);
6636 parms
= TREE_CHAIN (parms
);
6640 /* Variables and functions to manage constexpr call expansion context.
6641 These do not need to be marked for PCH or GC. */
6643 /* FIXME remember and print actual constant arguments. */
6644 static vec
<tree
> call_stack
= vNULL
;
6645 static int call_stack_tick
;
6646 static int last_cx_error_tick
;
6649 push_cx_call_context (tree call
)
6652 if (!EXPR_HAS_LOCATION (call
))
6653 SET_EXPR_LOCATION (call
, input_location
);
6654 call_stack
.safe_push (call
);
6655 if (call_stack
.length () > (unsigned) max_constexpr_depth
)
6661 pop_cx_call_context (void)
6668 cx_error_context (void)
6670 vec
<tree
> r
= vNULL
;
6671 if (call_stack_tick
!= last_cx_error_tick
6672 && !call_stack
.is_empty ())
6674 last_cx_error_tick
= call_stack_tick
;
6678 /* Subroutine of cxx_eval_constant_expression.
6679 Evaluate the call expression tree T in the context of OLD_CALL expression
6683 cxx_eval_call_expression (const constexpr_call
*old_call
, tree t
,
6684 bool allow_non_constant
, bool addr
,
6685 bool *non_constant_p
, bool *overflow_p
)
6687 location_t loc
= EXPR_LOC_OR_HERE (t
);
6688 tree fun
= get_function_named_in_call (t
);
6690 constexpr_call new_call
= { NULL
, NULL
, NULL
, 0 };
6691 constexpr_call
**slot
;
6692 constexpr_call
*entry
;
6695 if (TREE_CODE (fun
) != FUNCTION_DECL
)
6697 /* Might be a constexpr function pointer. */
6698 fun
= cxx_eval_constant_expression (old_call
, fun
, allow_non_constant
,
6699 /*addr*/false, non_constant_p
, overflow_p
);
6700 if (TREE_CODE (fun
) == ADDR_EXPR
)
6701 fun
= TREE_OPERAND (fun
, 0);
6703 if (TREE_CODE (fun
) != FUNCTION_DECL
)
6705 if (!allow_non_constant
&& !*non_constant_p
)
6706 error_at (loc
, "expression %qE does not designate a constexpr "
6708 *non_constant_p
= true;
6711 if (DECL_CLONED_FUNCTION_P (fun
))
6712 fun
= DECL_CLONED_FUNCTION (fun
);
6713 if (is_builtin_fn (fun
))
6714 return cxx_eval_builtin_function_call (old_call
, t
, allow_non_constant
,
6715 addr
, non_constant_p
, overflow_p
);
6716 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
6718 if (!allow_non_constant
)
6720 error_at (loc
, "call to non-constexpr function %qD", fun
);
6721 explain_invalid_constexpr_fn (fun
);
6723 *non_constant_p
= true;
6727 /* Shortcut trivial copy constructor/op=. */
6728 if (call_expr_nargs (t
) == 2 && trivial_fn_p (fun
))
6730 tree arg
= convert_from_reference (get_nth_callarg (t
, 1));
6731 return cxx_eval_constant_expression (old_call
, arg
, allow_non_constant
,
6732 addr
, non_constant_p
, overflow_p
);
6735 /* If in direct recursive call, optimize definition search. */
6736 if (old_call
!= NULL
&& old_call
->fundef
->decl
== fun
)
6737 new_call
.fundef
= old_call
->fundef
;
6740 new_call
.fundef
= retrieve_constexpr_fundef (fun
);
6741 if (new_call
.fundef
== NULL
|| new_call
.fundef
->body
== NULL
)
6743 if (!allow_non_constant
)
6745 if (DECL_INITIAL (fun
))
6747 /* The definition of fun was somehow unsuitable. */
6748 error_at (loc
, "%qD called in a constant expression", fun
);
6749 explain_invalid_constexpr_fn (fun
);
6752 error_at (loc
, "%qD used before its definition", fun
);
6754 *non_constant_p
= true;
6758 cxx_bind_parameters_in_call (old_call
, t
, &new_call
,
6759 allow_non_constant
, non_constant_p
, overflow_p
);
6760 if (*non_constant_p
)
6763 depth_ok
= push_cx_call_context (t
);
6766 = iterative_hash_template_arg (new_call
.bindings
,
6767 constexpr_fundef_hash (new_call
.fundef
));
6769 /* If we have seen this call before, we are done. */
6770 maybe_initialize_constexpr_call_table ();
6771 slot
= (constexpr_call
**)
6772 htab_find_slot (constexpr_call_table
, &new_call
, INSERT
);
6776 /* We need to keep a pointer to the entry, not just the slot, as the
6777 slot can move in the call to cxx_eval_builtin_function_call. */
6778 *slot
= entry
= ggc_alloc_constexpr_call ();
6781 /* Calls which are in progress have their result set to NULL
6782 so that we can detect circular dependencies. */
6783 else if (entry
->result
== NULL
)
6785 if (!allow_non_constant
)
6786 error ("call has circular dependency");
6787 *non_constant_p
= true;
6788 entry
->result
= result
= error_mark_node
;
6793 if (!allow_non_constant
)
6794 error ("constexpr evaluation depth exceeds maximum of %d (use "
6795 "-fconstexpr-depth= to increase the maximum)",
6796 max_constexpr_depth
);
6797 *non_constant_p
= true;
6798 entry
->result
= result
= error_mark_node
;
6802 result
= entry
->result
;
6803 if (!result
|| result
== error_mark_node
)
6804 result
= (cxx_eval_constant_expression
6805 (&new_call
, new_call
.fundef
->body
,
6806 allow_non_constant
, addr
,
6807 non_constant_p
, overflow_p
));
6808 if (result
== error_mark_node
)
6809 *non_constant_p
= true;
6810 if (*non_constant_p
)
6811 entry
->result
= result
= error_mark_node
;
6814 /* If this was a call to initialize an object, set the type of
6815 the CONSTRUCTOR to the type of that object. */
6816 if (DECL_CONSTRUCTOR_P (fun
))
6818 tree ob_arg
= get_nth_callarg (t
, 0);
6819 STRIP_NOPS (ob_arg
);
6820 gcc_assert (TREE_CODE (TREE_TYPE (ob_arg
)) == POINTER_TYPE
6821 && CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (ob_arg
))));
6822 result
= adjust_temp_type (TREE_TYPE (TREE_TYPE (ob_arg
)),
6825 entry
->result
= result
;
6829 pop_cx_call_context ();
6830 return unshare_expr (result
);
6833 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
6836 reduced_constant_expression_p (tree t
)
6838 if (TREE_CODE (t
) == PTRMEM_CST
)
6839 /* Even if we can't lower this yet, it's constant. */
6841 /* FIXME are we calling this too much? */
6842 return initializer_constant_valid_p (t
, TREE_TYPE (t
)) != NULL_TREE
;
6845 /* Some expressions may have constant operands but are not constant
6846 themselves, such as 1/0. Call this function (or rather, the macro
6847 following it) to check for that condition.
6849 We only call this in places that require an arithmetic constant, not in
6850 places where we might have a non-constant expression that can be a
6851 component of a constant expression, such as the address of a constexpr
6852 variable that might be dereferenced later. */
6855 verify_constant (tree t
, bool allow_non_constant
, bool *non_constant_p
,
6858 if (!*non_constant_p
&& !reduced_constant_expression_p (t
))
6860 if (!allow_non_constant
)
6861 error ("%q+E is not a constant expression", t
);
6862 *non_constant_p
= true;
6864 if (TREE_OVERFLOW_P (t
))
6866 if (!allow_non_constant
)
6868 permerror (input_location
, "overflow in constant expression");
6869 /* If we're being permissive (and are in an enforcing
6870 context), ignore the overflow. */
6871 if (flag_permissive
)
6872 return *non_constant_p
;
6876 return *non_constant_p
;
6879 /* Subroutine of cxx_eval_constant_expression.
6880 Attempt to reduce the unary expression tree T to a compile time value.
6881 If successful, return the value. Otherwise issue a diagnostic
6882 and return error_mark_node. */
6885 cxx_eval_unary_expression (const constexpr_call
*call
, tree t
,
6886 bool allow_non_constant
, bool addr
,
6887 bool *non_constant_p
, bool *overflow_p
)
6890 tree orig_arg
= TREE_OPERAND (t
, 0);
6891 tree arg
= cxx_eval_constant_expression (call
, orig_arg
, allow_non_constant
,
6892 addr
, non_constant_p
, overflow_p
);
6893 VERIFY_CONSTANT (arg
);
6894 if (arg
== orig_arg
)
6896 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), arg
);
6897 VERIFY_CONSTANT (r
);
6901 /* Subroutine of cxx_eval_constant_expression.
6902 Like cxx_eval_unary_expression, except for binary expressions. */
6905 cxx_eval_binary_expression (const constexpr_call
*call
, tree t
,
6906 bool allow_non_constant
, bool addr
,
6907 bool *non_constant_p
, bool *overflow_p
)
6910 tree orig_lhs
= TREE_OPERAND (t
, 0);
6911 tree orig_rhs
= TREE_OPERAND (t
, 1);
6913 lhs
= cxx_eval_constant_expression (call
, orig_lhs
,
6914 allow_non_constant
, addr
,
6915 non_constant_p
, overflow_p
);
6916 VERIFY_CONSTANT (lhs
);
6917 rhs
= cxx_eval_constant_expression (call
, orig_rhs
,
6918 allow_non_constant
, addr
,
6919 non_constant_p
, overflow_p
);
6920 VERIFY_CONSTANT (rhs
);
6921 if (lhs
== orig_lhs
&& rhs
== orig_rhs
)
6923 r
= fold_build2 (TREE_CODE (t
), TREE_TYPE (t
), lhs
, rhs
);
6924 VERIFY_CONSTANT (r
);
6928 /* Subroutine of cxx_eval_constant_expression.
6929 Attempt to evaluate condition expressions. Dead branches are not
6933 cxx_eval_conditional_expression (const constexpr_call
*call
, tree t
,
6934 bool allow_non_constant
, bool addr
,
6935 bool *non_constant_p
, bool *overflow_p
)
6937 tree val
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 0),
6938 allow_non_constant
, addr
,
6939 non_constant_p
, overflow_p
);
6940 VERIFY_CONSTANT (val
);
6941 /* Don't VERIFY_CONSTANT the other operands. */
6942 if (integer_zerop (val
))
6943 return cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 2),
6944 allow_non_constant
, addr
,
6945 non_constant_p
, overflow_p
);
6946 return cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 1),
6947 allow_non_constant
, addr
,
6948 non_constant_p
, overflow_p
);
6951 /* Subroutine of cxx_eval_constant_expression.
6952 Attempt to reduce a reference to an array slot. */
6955 cxx_eval_array_reference (const constexpr_call
*call
, tree t
,
6956 bool allow_non_constant
, bool addr
,
6957 bool *non_constant_p
, bool *overflow_p
)
6959 tree oldary
= TREE_OPERAND (t
, 0);
6960 tree ary
= cxx_eval_constant_expression (call
, oldary
,
6961 allow_non_constant
, addr
,
6962 non_constant_p
, overflow_p
);
6966 unsigned len
, elem_nchars
= 1;
6967 if (*non_constant_p
)
6969 oldidx
= TREE_OPERAND (t
, 1);
6970 index
= cxx_eval_constant_expression (call
, oldidx
,
6971 allow_non_constant
, false,
6972 non_constant_p
, overflow_p
);
6973 VERIFY_CONSTANT (index
);
6974 if (addr
&& ary
== oldary
&& index
== oldidx
)
6977 return build4 (ARRAY_REF
, TREE_TYPE (t
), ary
, index
, NULL
, NULL
);
6978 elem_type
= TREE_TYPE (TREE_TYPE (ary
));
6979 if (TREE_CODE (ary
) == CONSTRUCTOR
)
6980 len
= CONSTRUCTOR_NELTS (ary
);
6981 else if (TREE_CODE (ary
) == STRING_CST
)
6983 elem_nchars
= (TYPE_PRECISION (elem_type
)
6984 / TYPE_PRECISION (char_type_node
));
6985 len
= (unsigned) TREE_STRING_LENGTH (ary
) / elem_nchars
;
6989 /* We can't do anything with other tree codes, so use
6990 VERIFY_CONSTANT to complain and fail. */
6991 VERIFY_CONSTANT (ary
);
6994 if (compare_tree_int (index
, len
) >= 0)
6996 if (tree_int_cst_lt (index
, array_type_nelts_top (TREE_TYPE (ary
))))
6998 /* If it's within the array bounds but doesn't have an explicit
6999 initializer, it's value-initialized. */
7000 tree val
= build_value_init (elem_type
, tf_warning_or_error
);
7001 return cxx_eval_constant_expression (call
, val
,
7002 allow_non_constant
, addr
,
7003 non_constant_p
, overflow_p
);
7006 if (!allow_non_constant
)
7007 error ("array subscript out of bound");
7008 *non_constant_p
= true;
7011 else if (tree_int_cst_lt (index
, integer_zero_node
))
7013 if (!allow_non_constant
)
7014 error ("negative array subscript");
7015 *non_constant_p
= true;
7018 i
= tree_low_cst (index
, 0);
7019 if (TREE_CODE (ary
) == CONSTRUCTOR
)
7020 return (*CONSTRUCTOR_ELTS (ary
))[i
].value
;
7021 else if (elem_nchars
== 1)
7022 return build_int_cst (cv_unqualified (TREE_TYPE (TREE_TYPE (ary
))),
7023 TREE_STRING_POINTER (ary
)[i
]);
7026 tree type
= cv_unqualified (TREE_TYPE (TREE_TYPE (ary
)));
7027 return native_interpret_expr (type
, (const unsigned char *)
7028 TREE_STRING_POINTER (ary
)
7029 + i
* elem_nchars
, elem_nchars
);
7031 /* Don't VERIFY_CONSTANT here. */
7034 /* Subroutine of cxx_eval_constant_expression.
7035 Attempt to reduce a field access of a value of class type. */
7038 cxx_eval_component_reference (const constexpr_call
*call
, tree t
,
7039 bool allow_non_constant
, bool addr
,
7040 bool *non_constant_p
, bool *overflow_p
)
7042 unsigned HOST_WIDE_INT i
;
7045 tree part
= TREE_OPERAND (t
, 1);
7046 tree orig_whole
= TREE_OPERAND (t
, 0);
7047 tree whole
= cxx_eval_constant_expression (call
, orig_whole
,
7048 allow_non_constant
, addr
,
7049 non_constant_p
, overflow_p
);
7050 if (whole
== orig_whole
)
7053 return fold_build3 (COMPONENT_REF
, TREE_TYPE (t
),
7054 whole
, part
, NULL_TREE
);
7055 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
7057 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
7059 if (!allow_non_constant
)
7060 error ("%qE is not a constant expression", orig_whole
);
7061 *non_constant_p
= true;
7063 if (DECL_MUTABLE_P (part
))
7065 if (!allow_non_constant
)
7066 error ("mutable %qD is not usable in a constant expression", part
);
7067 *non_constant_p
= true;
7069 if (*non_constant_p
)
7071 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
7076 if (TREE_CODE (TREE_TYPE (whole
)) == UNION_TYPE
7077 && CONSTRUCTOR_NELTS (whole
) > 0)
7079 /* DR 1188 says we don't have to deal with this. */
7080 if (!allow_non_constant
)
7081 error ("accessing %qD member instead of initialized %qD member in "
7082 "constant expression", part
, CONSTRUCTOR_ELT (whole
, 0)->index
);
7083 *non_constant_p
= true;
7087 /* If there's no explicit init for this field, it's value-initialized. */
7088 value
= build_value_init (TREE_TYPE (t
), tf_warning_or_error
);
7089 return cxx_eval_constant_expression (call
, value
,
7090 allow_non_constant
, addr
,
7091 non_constant_p
, overflow_p
);
7094 /* Subroutine of cxx_eval_constant_expression.
7095 Attempt to reduce a field access of a value of class type that is
7096 expressed as a BIT_FIELD_REF. */
7099 cxx_eval_bit_field_ref (const constexpr_call
*call
, tree t
,
7100 bool allow_non_constant
, bool addr
,
7101 bool *non_constant_p
, bool *overflow_p
)
7103 tree orig_whole
= TREE_OPERAND (t
, 0);
7104 tree retval
, fldval
, utype
, mask
;
7105 bool fld_seen
= false;
7106 HOST_WIDE_INT istart
, isize
;
7107 tree whole
= cxx_eval_constant_expression (call
, orig_whole
,
7108 allow_non_constant
, addr
,
7109 non_constant_p
, overflow_p
);
7110 tree start
, field
, value
;
7111 unsigned HOST_WIDE_INT i
;
7113 if (whole
== orig_whole
)
7115 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
7117 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
7119 if (!allow_non_constant
)
7120 error ("%qE is not a constant expression", orig_whole
);
7121 *non_constant_p
= true;
7123 if (*non_constant_p
)
7126 start
= TREE_OPERAND (t
, 2);
7127 istart
= tree_low_cst (start
, 0);
7128 isize
= tree_low_cst (TREE_OPERAND (t
, 1), 0);
7129 utype
= TREE_TYPE (t
);
7130 if (!TYPE_UNSIGNED (utype
))
7131 utype
= build_nonstandard_integer_type (TYPE_PRECISION (utype
), 1);
7132 retval
= build_int_cst (utype
, 0);
7133 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
7135 tree bitpos
= bit_position (field
);
7136 if (bitpos
== start
&& DECL_SIZE (field
) == TREE_OPERAND (t
, 1))
7138 if (TREE_CODE (TREE_TYPE (field
)) == INTEGER_TYPE
7139 && TREE_CODE (value
) == INTEGER_CST
7140 && host_integerp (bitpos
, 0)
7141 && host_integerp (DECL_SIZE (field
), 0))
7143 HOST_WIDE_INT bit
= tree_low_cst (bitpos
, 0);
7144 HOST_WIDE_INT sz
= tree_low_cst (DECL_SIZE (field
), 0);
7145 HOST_WIDE_INT shift
;
7146 if (bit
>= istart
&& bit
+ sz
<= istart
+ isize
)
7148 fldval
= fold_convert (utype
, value
);
7149 mask
= build_int_cst_type (utype
, -1);
7150 mask
= fold_build2 (LSHIFT_EXPR
, utype
, mask
,
7151 size_int (TYPE_PRECISION (utype
) - sz
));
7152 mask
= fold_build2 (RSHIFT_EXPR
, utype
, mask
,
7153 size_int (TYPE_PRECISION (utype
) - sz
));
7154 fldval
= fold_build2 (BIT_AND_EXPR
, utype
, fldval
, mask
);
7155 shift
= bit
- istart
;
7156 if (BYTES_BIG_ENDIAN
)
7157 shift
= TYPE_PRECISION (utype
) - shift
- sz
;
7158 fldval
= fold_build2 (LSHIFT_EXPR
, utype
, fldval
,
7160 retval
= fold_build2 (BIT_IOR_EXPR
, utype
, retval
, fldval
);
7166 return fold_convert (TREE_TYPE (t
), retval
);
7168 return error_mark_node
;
7171 /* Subroutine of cxx_eval_constant_expression.
7172 Evaluate a short-circuited logical expression T in the context
7173 of a given constexpr CALL. BAILOUT_VALUE is the value for
7174 early return. CONTINUE_VALUE is used here purely for
7175 sanity check purposes. */
7178 cxx_eval_logical_expression (const constexpr_call
*call
, tree t
,
7179 tree bailout_value
, tree continue_value
,
7180 bool allow_non_constant
, bool addr
,
7181 bool *non_constant_p
, bool *overflow_p
)
7184 tree lhs
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 0),
7185 allow_non_constant
, addr
,
7186 non_constant_p
, overflow_p
);
7187 VERIFY_CONSTANT (lhs
);
7188 if (tree_int_cst_equal (lhs
, bailout_value
))
7190 gcc_assert (tree_int_cst_equal (lhs
, continue_value
));
7191 r
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 1),
7192 allow_non_constant
, addr
, non_constant_p
, overflow_p
);
7193 VERIFY_CONSTANT (r
);
7197 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
7198 CONSTRUCTOR elements to initialize (part of) an object containing that
7199 field. Return a pointer to the constructor_elt corresponding to the
7200 initialization of the field. */
7202 static constructor_elt
*
7203 base_field_constructor_elt (vec
<constructor_elt
, va_gc
> *v
, tree ref
)
7205 tree aggr
= TREE_OPERAND (ref
, 0);
7206 tree field
= TREE_OPERAND (ref
, 1);
7208 constructor_elt
*ce
;
7210 gcc_assert (TREE_CODE (ref
) == COMPONENT_REF
);
7212 if (TREE_CODE (aggr
) == COMPONENT_REF
)
7214 constructor_elt
*base_ce
7215 = base_field_constructor_elt (v
, aggr
);
7216 v
= CONSTRUCTOR_ELTS (base_ce
->value
);
7219 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
7220 if (ce
->index
== field
)
7227 /* Subroutine of cxx_eval_constant_expression.
7228 The expression tree T denotes a C-style array or a C-style
7229 aggregate. Reduce it to a constant expression. */
7232 cxx_eval_bare_aggregate (const constexpr_call
*call
, tree t
,
7233 bool allow_non_constant
, bool addr
,
7234 bool *non_constant_p
, bool *overflow_p
)
7236 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
7237 vec
<constructor_elt
, va_gc
> *n
;
7238 vec_alloc (n
, vec_safe_length (v
));
7239 constructor_elt
*ce
;
7241 bool changed
= false;
7242 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t
));
7243 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
7245 tree elt
= cxx_eval_constant_expression (call
, ce
->value
,
7246 allow_non_constant
, addr
,
7247 non_constant_p
, overflow_p
);
7248 /* Don't VERIFY_CONSTANT here. */
7249 if (allow_non_constant
&& *non_constant_p
)
7251 if (elt
!= ce
->value
)
7253 if (ce
->index
&& TREE_CODE (ce
->index
) == COMPONENT_REF
)
7255 /* This is an initialization of a vfield inside a base
7256 subaggregate that we already initialized; push this
7257 initialization into the previous initialization. */
7258 constructor_elt
*inner
= base_field_constructor_elt (n
, ce
->index
);
7261 else if (ce
->index
&& TREE_CODE (ce
->index
) == NOP_EXPR
)
7263 /* This is an initializer for an empty base; now that we've
7264 checked that it's constant, we can ignore it. */
7265 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (ce
->index
))));
7268 CONSTRUCTOR_APPEND_ELT (n
, ce
->index
, elt
);
7270 if (*non_constant_p
|| !changed
)
7276 t
= build_constructor (TREE_TYPE (t
), n
);
7277 TREE_CONSTANT (t
) = true;
7278 if (TREE_CODE (TREE_TYPE (t
)) == VECTOR_TYPE
)
7283 /* Subroutine of cxx_eval_constant_expression.
7284 The expression tree T is a VEC_INIT_EXPR which denotes the desired
7285 initialization of a non-static data member of array type. Reduce it to a
7288 Note that apart from value-initialization (when VALUE_INIT is true),
7289 this is only intended to support value-initialization and the
7290 initializations done by defaulted constructors for classes with
7291 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
7292 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
7293 for the copy/move constructor. */
7296 cxx_eval_vec_init_1 (const constexpr_call
*call
, tree atype
, tree init
,
7297 bool value_init
, bool allow_non_constant
, bool addr
,
7298 bool *non_constant_p
, bool *overflow_p
)
7300 tree elttype
= TREE_TYPE (atype
);
7301 int max
= tree_low_cst (array_type_nelts (atype
), 0);
7302 vec
<constructor_elt
, va_gc
> *n
;
7303 vec_alloc (n
, max
+ 1);
7304 bool pre_init
= false;
7307 /* For the default constructor, build up a call to the default
7308 constructor of the element type. We only need to handle class types
7309 here, as for a constructor to be constexpr, all members must be
7310 initialized, which for a defaulted default constructor means they must
7311 be of a class type with a constexpr default constructor. */
7312 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
7313 /* We only do this at the lowest level. */;
7314 else if (value_init
)
7316 init
= build_value_init (elttype
, tf_warning_or_error
);
7317 init
= cxx_eval_constant_expression
7318 (call
, init
, allow_non_constant
, addr
, non_constant_p
, overflow_p
);
7323 vec
<tree
, va_gc
> *argvec
= make_tree_vector ();
7324 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
7325 &argvec
, elttype
, LOOKUP_NORMAL
,
7326 tf_warning_or_error
);
7327 release_tree_vector (argvec
);
7328 init
= cxx_eval_constant_expression (call
, init
, allow_non_constant
,
7329 addr
, non_constant_p
, overflow_p
);
7333 if (*non_constant_p
&& !allow_non_constant
)
7336 for (i
= 0; i
<= max
; ++i
)
7338 tree idx
= build_int_cst (size_type_node
, i
);
7340 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
7342 /* A multidimensional array; recurse. */
7343 if (value_init
|| init
== NULL_TREE
)
7344 eltinit
= NULL_TREE
;
7346 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
7347 tf_warning_or_error
);
7348 eltinit
= cxx_eval_vec_init_1 (call
, elttype
, eltinit
, value_init
,
7349 allow_non_constant
, addr
,
7350 non_constant_p
, overflow_p
);
7354 /* Initializing an element using value or default initialization
7355 we just pre-built above. */
7359 eltinit
= unshare_expr (init
);
7363 /* Copying an element. */
7364 vec
<tree
, va_gc
> *argvec
;
7365 gcc_assert (same_type_ignoring_top_level_qualifiers_p
7366 (atype
, TREE_TYPE (init
)));
7367 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
7368 tf_warning_or_error
);
7369 if (!real_lvalue_p (init
))
7370 eltinit
= move (eltinit
);
7371 argvec
= make_tree_vector ();
7372 argvec
->quick_push (eltinit
);
7373 eltinit
= (build_special_member_call
7374 (NULL_TREE
, complete_ctor_identifier
, &argvec
,
7375 elttype
, LOOKUP_NORMAL
, tf_warning_or_error
));
7376 release_tree_vector (argvec
);
7377 eltinit
= cxx_eval_constant_expression
7378 (call
, eltinit
, allow_non_constant
, addr
, non_constant_p
, overflow_p
);
7380 if (*non_constant_p
&& !allow_non_constant
)
7382 CONSTRUCTOR_APPEND_ELT (n
, idx
, eltinit
);
7385 if (!*non_constant_p
)
7387 init
= build_constructor (atype
, n
);
7388 TREE_CONSTANT (init
) = true;
7398 cxx_eval_vec_init (const constexpr_call
*call
, tree t
,
7399 bool allow_non_constant
, bool addr
,
7400 bool *non_constant_p
, bool *overflow_p
)
7402 tree atype
= TREE_TYPE (t
);
7403 tree init
= VEC_INIT_EXPR_INIT (t
);
7404 tree r
= cxx_eval_vec_init_1 (call
, atype
, init
,
7405 VEC_INIT_EXPR_VALUE_INIT (t
),
7406 allow_non_constant
, addr
, non_constant_p
, overflow_p
);
7407 if (*non_constant_p
)
7413 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
7414 match. We want to be less strict for simple *& folding; if we have a
7415 non-const temporary that we access through a const pointer, that should
7416 work. We handle this here rather than change fold_indirect_ref_1
7417 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
7418 don't really make sense outside of constant expression evaluation. Also
7419 we want to allow folding to COMPONENT_REF, which could cause trouble
7420 with TBAA in fold_indirect_ref_1.
7422 Try to keep this function synced with fold_indirect_ref_1. */
7425 cxx_fold_indirect_ref (location_t loc
, tree type
, tree op0
, bool *empty_base
)
7431 subtype
= TREE_TYPE (sub
);
7432 if (!POINTER_TYPE_P (subtype
))
7435 if (TREE_CODE (sub
) == ADDR_EXPR
)
7437 tree op
= TREE_OPERAND (sub
, 0);
7438 tree optype
= TREE_TYPE (op
);
7440 /* *&CONST_DECL -> to the value of the const decl. */
7441 if (TREE_CODE (op
) == CONST_DECL
)
7442 return DECL_INITIAL (op
);
7443 /* *&p => p; make sure to handle *&"str"[cst] here. */
7444 if (same_type_ignoring_top_level_qualifiers_p (optype
, type
))
7446 tree fop
= fold_read_from_constant_string (op
);
7452 /* *(foo *)&fooarray => fooarray[0] */
7453 else if (TREE_CODE (optype
) == ARRAY_TYPE
7454 && (same_type_ignoring_top_level_qualifiers_p
7455 (type
, TREE_TYPE (optype
))))
7457 tree type_domain
= TYPE_DOMAIN (optype
);
7458 tree min_val
= size_zero_node
;
7459 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
7460 min_val
= TYPE_MIN_VALUE (type_domain
);
7461 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
7462 NULL_TREE
, NULL_TREE
);
7464 /* *(foo *)&complexfoo => __real__ complexfoo */
7465 else if (TREE_CODE (optype
) == COMPLEX_TYPE
7466 && (same_type_ignoring_top_level_qualifiers_p
7467 (type
, TREE_TYPE (optype
))))
7468 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
7469 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
7470 else if (TREE_CODE (optype
) == VECTOR_TYPE
7471 && (same_type_ignoring_top_level_qualifiers_p
7472 (type
, TREE_TYPE (optype
))))
7474 tree part_width
= TYPE_SIZE (type
);
7475 tree index
= bitsize_int (0);
7476 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
, index
);
7478 /* Also handle conversion to an empty base class, which
7479 is represented with a NOP_EXPR. */
7480 else if (is_empty_class (type
)
7481 && CLASS_TYPE_P (optype
)
7482 && DERIVED_FROM_P (type
, optype
))
7487 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
7488 else if (RECORD_OR_UNION_TYPE_P (optype
))
7490 tree field
= TYPE_FIELDS (optype
);
7491 for (; field
; field
= DECL_CHAIN (field
))
7492 if (TREE_CODE (field
) == FIELD_DECL
7493 && integer_zerop (byte_position (field
))
7494 && (same_type_ignoring_top_level_qualifiers_p
7495 (TREE_TYPE (field
), type
)))
7497 return fold_build3 (COMPONENT_REF
, type
, op
, field
, NULL_TREE
);
7502 else if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
7503 && TREE_CODE (TREE_OPERAND (sub
, 1)) == INTEGER_CST
)
7505 tree op00
= TREE_OPERAND (sub
, 0);
7506 tree op01
= TREE_OPERAND (sub
, 1);
7509 if (TREE_CODE (op00
) == ADDR_EXPR
)
7512 op00
= TREE_OPERAND (op00
, 0);
7513 op00type
= TREE_TYPE (op00
);
7515 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
7516 if (TREE_CODE (op00type
) == VECTOR_TYPE
7517 && (same_type_ignoring_top_level_qualifiers_p
7518 (type
, TREE_TYPE (op00type
))))
7520 HOST_WIDE_INT offset
= tree_low_cst (op01
, 0);
7521 tree part_width
= TYPE_SIZE (type
);
7522 unsigned HOST_WIDE_INT part_widthi
= tree_low_cst (part_width
, 0)/BITS_PER_UNIT
;
7523 unsigned HOST_WIDE_INT indexi
= offset
* BITS_PER_UNIT
;
7524 tree index
= bitsize_int (indexi
);
7526 if (offset
/part_widthi
<= TYPE_VECTOR_SUBPARTS (op00type
))
7527 return fold_build3_loc (loc
,
7528 BIT_FIELD_REF
, type
, op00
,
7532 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
7533 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
7534 && (same_type_ignoring_top_level_qualifiers_p
7535 (type
, TREE_TYPE (op00type
))))
7537 tree size
= TYPE_SIZE_UNIT (type
);
7538 if (tree_int_cst_equal (size
, op01
))
7539 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
7541 /* ((foo *)&fooarray)[1] => fooarray[1] */
7542 else if (TREE_CODE (op00type
) == ARRAY_TYPE
7543 && (same_type_ignoring_top_level_qualifiers_p
7544 (type
, TREE_TYPE (op00type
))))
7546 tree type_domain
= TYPE_DOMAIN (op00type
);
7547 tree min_val
= size_zero_node
;
7548 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
7549 min_val
= TYPE_MIN_VALUE (type_domain
);
7550 op01
= size_binop_loc (loc
, EXACT_DIV_EXPR
, op01
,
7551 TYPE_SIZE_UNIT (type
));
7552 op01
= size_binop_loc (loc
, PLUS_EXPR
, op01
, min_val
);
7553 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
7554 NULL_TREE
, NULL_TREE
);
7556 /* Also handle conversion to an empty base class, which
7557 is represented with a NOP_EXPR. */
7558 else if (is_empty_class (type
)
7559 && CLASS_TYPE_P (op00type
)
7560 && DERIVED_FROM_P (type
, op00type
))
7565 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
7566 else if (RECORD_OR_UNION_TYPE_P (op00type
))
7568 tree field
= TYPE_FIELDS (op00type
);
7569 for (; field
; field
= DECL_CHAIN (field
))
7570 if (TREE_CODE (field
) == FIELD_DECL
7571 && tree_int_cst_equal (byte_position (field
), op01
)
7572 && (same_type_ignoring_top_level_qualifiers_p
7573 (TREE_TYPE (field
), type
)))
7575 return fold_build3 (COMPONENT_REF
, type
, op00
,
7582 /* *(foo *)fooarrptreturn> (*fooarrptr)[0] */
7583 else if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
7584 && (same_type_ignoring_top_level_qualifiers_p
7585 (type
, TREE_TYPE (TREE_TYPE (subtype
)))))
7588 tree min_val
= size_zero_node
;
7589 sub
= cxx_fold_indirect_ref (loc
, TREE_TYPE (subtype
), sub
, NULL
);
7591 sub
= build1_loc (loc
, INDIRECT_REF
, TREE_TYPE (subtype
), sub
);
7592 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
7593 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
7594 min_val
= TYPE_MIN_VALUE (type_domain
);
7595 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
7603 cxx_eval_indirect_ref (const constexpr_call
*call
, tree t
,
7604 bool allow_non_constant
, bool addr
,
7605 bool *non_constant_p
, bool *overflow_p
)
7607 tree orig_op0
= TREE_OPERAND (t
, 0);
7608 tree op0
= cxx_eval_constant_expression (call
, orig_op0
, allow_non_constant
,
7609 /*addr*/false, non_constant_p
, overflow_p
);
7610 bool empty_base
= false;
7613 /* Don't VERIFY_CONSTANT here. */
7614 if (*non_constant_p
)
7617 r
= cxx_fold_indirect_ref (EXPR_LOCATION (t
), TREE_TYPE (t
), op0
,
7621 r
= cxx_eval_constant_expression (call
, r
, allow_non_constant
,
7622 addr
, non_constant_p
, overflow_p
);
7627 if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
)
7629 sub
= TREE_OPERAND (sub
, 0);
7632 if (TREE_CODE (sub
) == ADDR_EXPR
)
7634 /* We couldn't fold to a constant value. Make sure it's not
7635 something we should have been able to fold. */
7636 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
7637 (TREE_TYPE (TREE_TYPE (sub
)), TREE_TYPE (t
)));
7638 /* DR 1188 says we don't have to deal with this. */
7639 if (!allow_non_constant
)
7640 error ("accessing value of %qE through a %qT glvalue in a "
7641 "constant expression", build_fold_indirect_ref (sub
),
7643 *non_constant_p
= true;
7648 /* If we're pulling out the value of an empty base, make sure
7649 that the whole object is constant and then return an empty
7653 VERIFY_CONSTANT (r
);
7654 r
= build_constructor (TREE_TYPE (t
), NULL
);
7655 TREE_CONSTANT (r
) = true;
7661 VERIFY_CONSTANT (t
);
7667 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
7668 Shared between potential_constant_expression and
7669 cxx_eval_constant_expression. */
7672 non_const_var_error (tree r
)
7674 tree type
= TREE_TYPE (r
);
7675 error ("the value of %qD is not usable in a constant "
7677 /* Avoid error cascade. */
7678 if (DECL_INITIAL (r
) == error_mark_node
)
7680 if (DECL_DECLARED_CONSTEXPR_P (r
))
7681 inform (DECL_SOURCE_LOCATION (r
),
7682 "%qD used in its own initializer", r
);
7683 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
7685 if (!CP_TYPE_CONST_P (type
))
7686 inform (DECL_SOURCE_LOCATION (r
),
7687 "%q#D is not const", r
);
7688 else if (CP_TYPE_VOLATILE_P (type
))
7689 inform (DECL_SOURCE_LOCATION (r
),
7690 "%q#D is volatile", r
);
7691 else if (!DECL_INITIAL (r
)
7692 || !TREE_CONSTANT (DECL_INITIAL (r
)))
7693 inform (DECL_SOURCE_LOCATION (r
),
7694 "%qD was not initialized with a constant "
7701 if (cxx_dialect
>= cxx0x
&& !DECL_DECLARED_CONSTEXPR_P (r
))
7702 inform (DECL_SOURCE_LOCATION (r
),
7703 "%qD was not declared %<constexpr%>", r
);
7705 inform (DECL_SOURCE_LOCATION (r
),
7706 "%qD does not have integral or enumeration type",
7711 /* Evaluate VEC_PERM_EXPR (v1, v2, mask). */
7713 cxx_eval_vec_perm_expr (const constexpr_call
*call
, tree t
,
7714 bool allow_non_constant
, bool addr
,
7715 bool *non_constant_p
, bool *overflow_p
)
7720 tree elttype
= TREE_TYPE (t
);
7722 for (i
= 0; i
< 3; i
++)
7724 args
[i
] = cxx_eval_constant_expression (call
, TREE_OPERAND (t
, i
),
7725 allow_non_constant
, addr
,
7726 non_constant_p
, overflow_p
);
7727 if (*non_constant_p
)
7731 gcc_assert (TREE_CODE (TREE_TYPE (args
[0])) == VECTOR_TYPE
);
7732 gcc_assert (TREE_CODE (TREE_TYPE (args
[1])) == VECTOR_TYPE
);
7733 gcc_assert (TREE_CODE (TREE_TYPE (args
[2])) == VECTOR_TYPE
);
7735 val
= fold_ternary_loc (EXPR_LOCATION (t
), VEC_PERM_EXPR
, elttype
,
7736 args
[0], args
[1], args
[2]);
7737 if (val
!= NULL_TREE
)
7744 /* Attempt to reduce the expression T to a constant value.
7745 On failure, issue diagnostic and return error_mark_node. */
7746 /* FIXME unify with c_fully_fold */
7749 cxx_eval_constant_expression (const constexpr_call
*call
, tree t
,
7750 bool allow_non_constant
, bool addr
,
7751 bool *non_constant_p
, bool *overflow_p
)
7755 if (t
== error_mark_node
)
7757 *non_constant_p
= true;
7760 if (CONSTANT_CLASS_P (t
))
7762 if (TREE_CODE (t
) == PTRMEM_CST
)
7763 t
= cplus_expand_constant (t
);
7764 else if (TREE_OVERFLOW (t
) && (!flag_permissive
|| allow_non_constant
))
7768 if (TREE_CODE (t
) != NOP_EXPR
7769 && reduced_constant_expression_p (t
))
7772 switch (TREE_CODE (t
))
7777 /* else fall through. */
7779 r
= integral_constant_value (t
);
7780 if (TREE_CODE (r
) == TARGET_EXPR
7781 && TREE_CODE (TARGET_EXPR_INITIAL (r
)) == CONSTRUCTOR
)
7782 r
= TARGET_EXPR_INITIAL (r
);
7785 if (!allow_non_constant
)
7786 non_const_var_error (r
);
7787 *non_constant_p
= true;
7797 if (call
&& DECL_CONTEXT (t
) == call
->fundef
->decl
)
7799 if (DECL_ARTIFICIAL (t
) && DECL_CONSTRUCTOR_P (DECL_CONTEXT (t
)))
7801 if (!allow_non_constant
)
7802 sorry ("use of the value of the object being constructed "
7803 "in a constant expression");
7804 *non_constant_p
= true;
7807 r
= lookup_parameter_binding (call
, t
);
7810 /* Defer in case this is only used for its type. */;
7813 if (!allow_non_constant
)
7814 error ("%qE is not a constant expression", t
);
7815 *non_constant_p
= true;
7820 case AGGR_INIT_EXPR
:
7821 r
= cxx_eval_call_expression (call
, t
, allow_non_constant
, addr
,
7822 non_constant_p
, overflow_p
);
7826 if (!literal_type_p (TREE_TYPE (t
)))
7828 if (!allow_non_constant
)
7830 error ("temporary of non-literal type %qT in a "
7831 "constant expression", TREE_TYPE (t
));
7832 explain_non_literal_class (TREE_TYPE (t
));
7834 *non_constant_p
= true;
7837 /* else fall through. */
7839 /* Pass false for 'addr' because these codes indicate
7840 initialization of a temporary. */
7841 r
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 1),
7842 allow_non_constant
, false,
7843 non_constant_p
, overflow_p
);
7844 if (!*non_constant_p
)
7845 /* Adjust the type of the result to the type of the temporary. */
7846 r
= adjust_temp_type (TREE_TYPE (t
), r
);
7850 r
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 1),
7851 allow_non_constant
, addr
,
7852 non_constant_p
, overflow_p
);
7856 case NON_LVALUE_EXPR
:
7857 case TRY_CATCH_EXPR
:
7858 case CLEANUP_POINT_EXPR
:
7859 case MUST_NOT_THROW_EXPR
:
7861 r
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 0),
7862 allow_non_constant
, addr
,
7863 non_constant_p
, overflow_p
);
7866 /* These differ from cxx_eval_unary_expression in that this doesn't
7867 check for a constant operand or result; an address can be
7868 constant without its operand being, and vice versa. */
7870 r
= cxx_eval_indirect_ref (call
, t
, allow_non_constant
, addr
,
7871 non_constant_p
, overflow_p
);
7876 tree oldop
= TREE_OPERAND (t
, 0);
7877 tree op
= cxx_eval_constant_expression (call
, oldop
,
7880 non_constant_p
, overflow_p
);
7881 /* Don't VERIFY_CONSTANT here. */
7882 if (*non_constant_p
)
7884 /* This function does more aggressive folding than fold itself. */
7885 r
= build_fold_addr_expr_with_type (op
, TREE_TYPE (t
));
7886 if (TREE_CODE (r
) == ADDR_EXPR
&& TREE_OPERAND (r
, 0) == oldop
)
7894 case FIX_TRUNC_EXPR
:
7899 case TRUTH_NOT_EXPR
:
7900 case FIXED_CONVERT_EXPR
:
7901 r
= cxx_eval_unary_expression (call
, t
, allow_non_constant
, addr
,
7902 non_constant_p
, overflow_p
);
7906 if (SIZEOF_EXPR_TYPE_P (t
))
7907 r
= cxx_sizeof_or_alignof_type (TREE_TYPE (TREE_OPERAND (t
, 0)),
7908 SIZEOF_EXPR
, false);
7909 else if (TYPE_P (TREE_OPERAND (t
, 0)))
7910 r
= cxx_sizeof_or_alignof_type (TREE_OPERAND (t
, 0), SIZEOF_EXPR
,
7913 r
= cxx_sizeof_or_alignof_expr (TREE_OPERAND (t
, 0), SIZEOF_EXPR
,
7915 if (r
== error_mark_node
)
7917 VERIFY_CONSTANT (r
);
7922 /* check_return_expr sometimes wraps a TARGET_EXPR in a
7923 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
7924 introduced by build_call_a. */
7925 tree op0
= TREE_OPERAND (t
, 0);
7926 tree op1
= TREE_OPERAND (t
, 1);
7928 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
7929 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
7930 r
= cxx_eval_constant_expression (call
, op0
, allow_non_constant
,
7931 addr
, non_constant_p
, overflow_p
);
7934 /* Check that the LHS is constant and then discard it. */
7935 cxx_eval_constant_expression (call
, op0
, allow_non_constant
,
7936 false, non_constant_p
, overflow_p
);
7937 op1
= TREE_OPERAND (t
, 1);
7938 r
= cxx_eval_constant_expression (call
, op1
, allow_non_constant
,
7939 addr
, non_constant_p
, overflow_p
);
7944 case POINTER_PLUS_EXPR
:
7948 case TRUNC_DIV_EXPR
:
7950 case FLOOR_DIV_EXPR
:
7951 case ROUND_DIV_EXPR
:
7952 case TRUNC_MOD_EXPR
:
7954 case ROUND_MOD_EXPR
:
7956 case EXACT_DIV_EXPR
:
7966 case TRUTH_XOR_EXPR
:
7973 case UNORDERED_EXPR
:
7982 r
= cxx_eval_binary_expression (call
, t
, allow_non_constant
, addr
,
7983 non_constant_p
, overflow_p
);
7986 /* fold can introduce non-IF versions of these; still treat them as
7987 short-circuiting. */
7988 case TRUTH_AND_EXPR
:
7989 case TRUTH_ANDIF_EXPR
:
7990 r
= cxx_eval_logical_expression (call
, t
, boolean_false_node
,
7992 allow_non_constant
, addr
,
7993 non_constant_p
, overflow_p
);
7997 case TRUTH_ORIF_EXPR
:
7998 r
= cxx_eval_logical_expression (call
, t
, boolean_true_node
,
8000 allow_non_constant
, addr
,
8001 non_constant_p
, overflow_p
);
8005 r
= cxx_eval_array_reference (call
, t
, allow_non_constant
, addr
,
8006 non_constant_p
, overflow_p
);
8010 r
= cxx_eval_component_reference (call
, t
, allow_non_constant
, addr
,
8011 non_constant_p
, overflow_p
);
8015 r
= cxx_eval_bit_field_ref (call
, t
, allow_non_constant
, addr
,
8016 non_constant_p
, overflow_p
);
8021 r
= cxx_eval_conditional_expression (call
, t
, allow_non_constant
, addr
,
8022 non_constant_p
, overflow_p
);
8026 r
= cxx_eval_bare_aggregate (call
, t
, allow_non_constant
, addr
,
8027 non_constant_p
, overflow_p
);
8031 /* We can get this in a defaulted constructor for a class with a
8032 non-static data member of array type. Either the initializer will
8033 be NULL, meaning default-initialization, or it will be an lvalue
8034 or xvalue of the same type, meaning direct-initialization from the
8035 corresponding member. */
8036 r
= cxx_eval_vec_init (call
, t
, allow_non_constant
, addr
,
8037 non_constant_p
, overflow_p
);
8041 r
= cxx_eval_vec_perm_expr (call
, t
, allow_non_constant
, addr
,
8042 non_constant_p
, overflow_p
);
8046 case VIEW_CONVERT_EXPR
:
8049 tree oldop
= TREE_OPERAND (t
, 0);
8050 tree op
= cxx_eval_constant_expression (call
, oldop
,
8051 allow_non_constant
, addr
,
8052 non_constant_p
, overflow_p
);
8053 if (*non_constant_p
)
8056 /* We didn't fold at the top so we could check for ptr-int
8059 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), op
);
8060 /* Conversion of an out-of-range value has implementation-defined
8061 behavior; the language considers it different from arithmetic
8062 overflow, which is undefined. */
8063 if (TREE_OVERFLOW_P (r
) && !TREE_OVERFLOW_P (op
))
8064 TREE_OVERFLOW (r
) = false;
8068 case EMPTY_CLASS_EXPR
:
8069 /* This is good enough for a function argument that might not get
8070 used, and they can't do anything with it, so just return it. */
8074 case PREINCREMENT_EXPR
:
8075 case POSTINCREMENT_EXPR
:
8076 case PREDECREMENT_EXPR
:
8077 case POSTDECREMENT_EXPR
:
8081 case VEC_DELETE_EXPR
:
8085 /* GCC internal stuff. */
8088 case WITH_CLEANUP_EXPR
:
8089 case STATEMENT_LIST
:
8091 case NON_DEPENDENT_EXPR
:
8095 if (!allow_non_constant
)
8096 error_at (EXPR_LOC_OR_HERE (t
),
8097 "expression %qE is not a constant-expression", t
);
8098 *non_constant_p
= true;
8102 internal_error ("unexpected expression %qE of kind %s", t
,
8103 tree_code_name
[TREE_CODE (t
)]);
8104 *non_constant_p
= true;
8108 if (r
== error_mark_node
)
8109 *non_constant_p
= true;
8111 if (*non_constant_p
)
8118 cxx_eval_outermost_constant_expr (tree t
, bool allow_non_constant
)
8120 bool non_constant_p
= false;
8121 bool overflow_p
= false;
8122 tree r
= cxx_eval_constant_expression (NULL
, t
, allow_non_constant
,
8123 false, &non_constant_p
, &overflow_p
);
8125 verify_constant (r
, allow_non_constant
, &non_constant_p
, &overflow_p
);
8127 if (TREE_CODE (t
) != CONSTRUCTOR
8128 && cp_has_mutable_p (TREE_TYPE (t
)))
8130 /* We allow a mutable type if the original expression was a
8131 CONSTRUCTOR so that we can do aggregate initialization of
8132 constexpr variables. */
8133 if (!allow_non_constant
)
8134 error ("%qT cannot be the type of a complete constant expression "
8135 "because it has mutable sub-objects", TREE_TYPE (t
));
8136 non_constant_p
= true;
8139 /* Technically we should check this for all subexpressions, but that
8140 runs into problems with our internal representation of pointer
8141 subtraction and the 5.19 rules are still in flux. */
8142 if (CONVERT_EXPR_CODE_P (TREE_CODE (r
))
8143 && ARITHMETIC_TYPE_P (TREE_TYPE (r
))
8144 && TREE_CODE (TREE_OPERAND (r
, 0)) == ADDR_EXPR
)
8146 if (!allow_non_constant
)
8147 error ("conversion from pointer type %qT "
8148 "to arithmetic type %qT in a constant-expression",
8149 TREE_TYPE (TREE_OPERAND (r
, 0)), TREE_TYPE (r
));
8150 non_constant_p
= true;
8153 if (!non_constant_p
&& overflow_p
)
8154 non_constant_p
= true;
8156 if (non_constant_p
&& !allow_non_constant
)
8157 return error_mark_node
;
8158 else if (non_constant_p
&& TREE_CONSTANT (r
))
8160 /* This isn't actually constant, so unset TREE_CONSTANT. */
8163 else if (TREE_CODE (r
) == CONSTRUCTOR
)
8164 r
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (r
), r
);
8166 r
= build_nop (TREE_TYPE (r
), r
);
8167 TREE_CONSTANT (r
) = false;
8169 else if (non_constant_p
|| r
== t
)
8172 if (TREE_CODE (r
) == CONSTRUCTOR
&& CLASS_TYPE_P (TREE_TYPE (r
)))
8174 if (TREE_CODE (t
) == TARGET_EXPR
8175 && TARGET_EXPR_INITIAL (t
) == r
)
8179 r
= get_target_expr (r
);
8180 TREE_CONSTANT (r
) = true;
8188 /* Returns true if T is a valid subexpression of a constant expression,
8189 even if it isn't itself a constant expression. */
8192 is_sub_constant_expr (tree t
)
8194 bool non_constant_p
= false;
8195 bool overflow_p
= false;
8196 cxx_eval_constant_expression (NULL
, t
, true, false, &non_constant_p
,
8198 return !non_constant_p
&& !overflow_p
;
8201 /* If T represents a constant expression returns its reduced value.
8202 Otherwise return error_mark_node. If T is dependent, then
8206 cxx_constant_value (tree t
)
8208 return cxx_eval_outermost_constant_expr (t
, false);
8211 /* If T is a constant expression, returns its reduced value.
8212 Otherwise, if T does not have TREE_CONSTANT set, returns T.
8213 Otherwise, returns a version of T without TREE_CONSTANT. */
8216 maybe_constant_value (tree t
)
8220 if (type_dependent_expression_p (t
)
8221 || type_unknown_p (t
)
8222 || BRACE_ENCLOSED_INITIALIZER_P (t
)
8223 || !potential_constant_expression (t
)
8224 || value_dependent_expression_p (t
))
8226 if (TREE_OVERFLOW_P (t
))
8228 t
= build_nop (TREE_TYPE (t
), t
);
8229 TREE_CONSTANT (t
) = false;
8234 r
= cxx_eval_outermost_constant_expr (t
, true);
8235 #ifdef ENABLE_CHECKING
8236 /* cp_tree_equal looks through NOPs, so allow them. */
8238 || CONVERT_EXPR_P (t
)
8239 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
8240 || !cp_tree_equal (r
, t
));
8245 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
8246 than wrapped in a TARGET_EXPR. */
8249 maybe_constant_init (tree t
)
8251 t
= maybe_constant_value (t
);
8252 if (TREE_CODE (t
) == TARGET_EXPR
)
8254 tree init
= TARGET_EXPR_INITIAL (t
);
8255 if (TREE_CODE (init
) == CONSTRUCTOR
)
8262 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
8263 /* Return true if the object referred to by REF has automatic or thread
8266 enum { ck_ok
, ck_bad
, ck_unknown
};
8268 check_automatic_or_tls (tree ref
)
8270 enum machine_mode mode
;
8271 HOST_WIDE_INT bitsize
, bitpos
;
8273 int volatilep
= 0, unsignedp
= 0;
8274 tree decl
= get_inner_reference (ref
, &bitsize
, &bitpos
, &offset
,
8275 &mode
, &unsignedp
, &volatilep
, false);
8278 /* If there isn't a decl in the middle, we don't know the linkage here,
8279 and this isn't a constant expression anyway. */
8282 dk
= decl_storage_duration (decl
);
8283 return (dk
== dk_auto
|| dk
== dk_thread
) ? ck_bad
: ck_ok
;
8287 /* Return true if T denotes a potentially constant expression. Issue
8288 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
8289 an lvalue-rvalue conversion is implied.
8291 C++0x [expr.const] used to say
8293 6 An expression is a potential constant expression if it is
8294 a constant expression where all occurences of function
8295 parameters are replaced by arbitrary constant expressions
8296 of the appropriate type.
8298 2 A conditional expression is a constant expression unless it
8299 involves one of the following as a potentially evaluated
8300 subexpression (3.2), but subexpressions of logical AND (5.14),
8301 logical OR (5.15), and conditional (5.16) operations that are
8302 not evaluated are not considered. */
8305 potential_constant_expression_1 (tree t
, bool want_rval
, tsubst_flags_t flags
)
8307 enum { any
= false, rval
= true };
8311 if (t
== error_mark_node
)
8315 if (TREE_THIS_VOLATILE (t
))
8317 if (flags
& tf_error
)
8318 error ("expression %qE has side-effects", t
);
8321 if (CONSTANT_CLASS_P (t
))
8324 switch (TREE_CODE (t
))
8330 case TEMPLATE_ID_EXPR
:
8337 case TEMPLATE_PARM_INDEX
:
8339 case IDENTIFIER_NODE
:
8340 case USERDEF_LITERAL
:
8341 /* We can see a FIELD_DECL in a pointer-to-member expression. */
8347 case AGGR_INIT_EXPR
:
8349 /* -- an invocation of a function other than a constexpr function
8350 or a constexpr constructor. */
8352 tree fun
= get_function_named_in_call (t
);
8353 const int nargs
= call_expr_nargs (t
);
8356 if (is_overloaded_fn (fun
))
8358 if (TREE_CODE (fun
) == FUNCTION_DECL
)
8360 if (builtin_valid_in_constant_expr_p (fun
))
8362 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
8363 /* Allow any built-in function; if the expansion
8364 isn't constant, we'll deal with that then. */
8365 && !is_builtin_fn (fun
))
8367 if (flags
& tf_error
)
8369 error_at (EXPR_LOC_OR_HERE (t
),
8370 "call to non-constexpr function %qD", fun
);
8371 explain_invalid_constexpr_fn (fun
);
8375 /* A call to a non-static member function takes the address
8376 of the object as the first argument. But in a constant
8377 expression the address will be folded away, so look
8379 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
8380 && !DECL_CONSTRUCTOR_P (fun
))
8382 tree x
= get_nth_callarg (t
, 0);
8383 if (is_this_parameter (x
))
8385 if (DECL_CONSTRUCTOR_P (DECL_CONTEXT (x
)))
8387 if (flags
& tf_error
)
8388 sorry ("calling a member function of the "
8389 "object being constructed in a constant "
8393 /* Otherwise OK. */;
8395 else if (!potential_constant_expression_1 (x
, rval
, flags
))
8401 fun
= get_first_fn (fun
);
8402 /* Skip initial arguments to base constructors. */
8403 if (DECL_BASE_CONSTRUCTOR_P (fun
))
8404 i
= num_artificial_parms_for (fun
);
8405 fun
= DECL_ORIGIN (fun
);
8409 if (potential_constant_expression_1 (fun
, rval
, flags
))
8410 /* Might end up being a constant function pointer. */;
8414 for (; i
< nargs
; ++i
)
8416 tree x
= get_nth_callarg (t
, i
);
8417 if (!potential_constant_expression_1 (x
, rval
, flags
))
8423 case NON_LVALUE_EXPR
:
8424 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
8425 -- an lvalue of integral type that refers to a non-volatile
8426 const variable or static data member initialized with
8427 constant expressions, or
8429 -- an lvalue of literal type that refers to non-volatile
8430 object defined with constexpr, or that refers to a
8431 sub-object of such an object; */
8432 return potential_constant_expression_1 (TREE_OPERAND (t
, 0), rval
, flags
);
8435 if (want_rval
&& !decl_constant_var_p (t
)
8436 && !dependent_type_p (TREE_TYPE (t
)))
8438 if (flags
& tf_error
)
8439 non_const_var_error (t
);
8446 case VIEW_CONVERT_EXPR
:
8447 /* -- a reinterpret_cast. FIXME not implemented, and this rule
8448 may change to something more specific to type-punning (DR 1312). */
8450 tree from
= TREE_OPERAND (t
, 0);
8451 return (potential_constant_expression_1
8452 (from
, TREE_CODE (t
) != VIEW_CONVERT_EXPR
, flags
));
8456 /* -- a unary operator & that is applied to an lvalue that
8457 designates an object with thread or automatic storage
8459 t
= TREE_OPERAND (t
, 0);
8461 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
8462 any checking here, as we might dereference the pointer later. If
8463 we remove this code, also remove check_automatic_or_tls. */
8464 i
= check_automatic_or_tls (t
);
8469 if (flags
& tf_error
)
8470 error ("address-of an object %qE with thread local or "
8471 "automatic storage is not a constant expression", t
);
8475 return potential_constant_expression_1 (t
, any
, flags
);
8481 /* -- a class member access unless its postfix-expression is
8482 of literal type or of pointer to literal type. */
8483 /* This test would be redundant, as it follows from the
8484 postfix-expression being a potential constant expression. */
8485 return potential_constant_expression_1 (TREE_OPERAND (t
, 0),
8488 case EXPR_PACK_EXPANSION
:
8489 return potential_constant_expression_1 (PACK_EXPANSION_PATTERN (t
),
8494 tree x
= TREE_OPERAND (t
, 0);
8496 if (is_this_parameter (x
))
8498 if (DECL_CONTEXT (x
)
8499 && !DECL_DECLARED_CONSTEXPR_P (DECL_CONTEXT (x
)))
8501 if (flags
& tf_error
)
8502 error ("use of %<this%> in a constant expression");
8505 if (want_rval
&& DECL_CONTEXT (x
)
8506 && DECL_CONSTRUCTOR_P (DECL_CONTEXT (x
)))
8508 if (flags
& tf_error
)
8509 sorry ("use of the value of the object being constructed "
8510 "in a constant expression");
8515 return potential_constant_expression_1 (x
, rval
, flags
);
8519 case DYNAMIC_CAST_EXPR
:
8520 case PSEUDO_DTOR_EXPR
:
8521 case PREINCREMENT_EXPR
:
8522 case POSTINCREMENT_EXPR
:
8523 case PREDECREMENT_EXPR
:
8524 case POSTDECREMENT_EXPR
:
8528 case VEC_DELETE_EXPR
:
8532 /* GCC internal stuff. */
8535 case WITH_CLEANUP_EXPR
:
8536 case CLEANUP_POINT_EXPR
:
8537 case MUST_NOT_THROW_EXPR
:
8538 case TRY_CATCH_EXPR
:
8539 case STATEMENT_LIST
:
8540 /* Don't bother trying to define a subset of statement-expressions to
8541 be constant-expressions, at least for now. */
8545 case TRANSACTION_EXPR
:
8550 if (flags
& tf_error
)
8551 error ("expression %qE is not a constant-expression", t
);
8555 /* -- a typeid expression whose operand is of polymorphic
8558 tree e
= TREE_OPERAND (t
, 0);
8559 if (!TYPE_P (e
) && !type_dependent_expression_p (e
)
8560 && TYPE_POLYMORPHIC_P (TREE_TYPE (e
)))
8562 if (flags
& tf_error
)
8563 error ("typeid-expression is not a constant expression "
8564 "because %qE is of polymorphic type", e
);
8571 /* -- a subtraction where both operands are pointers. */
8572 if (TYPE_PTR_P (TREE_OPERAND (t
, 0))
8573 && TYPE_PTR_P (TREE_OPERAND (t
, 1)))
8575 if (flags
& tf_error
)
8576 error ("difference of two pointer expressions is not "
8577 "a constant expression");
8589 /* -- a relational or equality operator where at least
8590 one of the operands is a pointer. */
8591 if (TYPE_PTR_P (TREE_OPERAND (t
, 0))
8592 || TYPE_PTR_P (TREE_OPERAND (t
, 1)))
8594 if (flags
& tf_error
)
8595 error ("pointer comparison expression is not a "
8596 "constant expression");
8604 if (TYPE_P (TREE_OPERAND (t
, 0)))
8606 /* else fall through. */
8612 case FIX_TRUNC_EXPR
:
8616 case TRUTH_NOT_EXPR
:
8617 case FIXED_CONVERT_EXPR
:
8618 case UNARY_PLUS_EXPR
:
8619 return potential_constant_expression_1 (TREE_OPERAND (t
, 0), rval
,
8623 case CONST_CAST_EXPR
:
8624 case STATIC_CAST_EXPR
:
8625 case REINTERPRET_CAST_EXPR
:
8626 case IMPLICIT_CONV_EXPR
:
8627 if (cxx_dialect
< cxx0x
8628 && !dependent_type_p (TREE_TYPE (t
))
8629 && !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
)))
8630 /* In C++98, a conversion to non-integral type can't be part of a
8631 constant expression. */
8633 if (flags
& tf_error
)
8634 error ("cast to non-integral type %qT in a constant expression",
8639 return (potential_constant_expression_1
8640 (TREE_OPERAND (t
, 0),
8641 TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
, flags
));
8644 case NON_DEPENDENT_EXPR
:
8645 /* For convenience. */
8647 return potential_constant_expression_1 (TREE_OPERAND (t
, 0),
8651 return potential_constant_expression_1 (TREE_OPERAND (t
, 1),
8655 if (!literal_type_p (TREE_TYPE (t
)))
8657 if (flags
& tf_error
)
8659 error ("temporary of non-literal type %qT in a "
8660 "constant expression", TREE_TYPE (t
));
8661 explain_non_literal_class (TREE_TYPE (t
));
8666 return potential_constant_expression_1 (TREE_OPERAND (t
, 1),
8671 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
8672 constructor_elt
*ce
;
8673 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
8674 if (!potential_constant_expression_1 (ce
->value
, want_rval
, flags
))
8681 gcc_assert (TREE_PURPOSE (t
) == NULL_TREE
8682 || DECL_P (TREE_PURPOSE (t
)));
8683 if (!potential_constant_expression_1 (TREE_VALUE (t
), want_rval
,
8686 if (TREE_CHAIN (t
) == NULL_TREE
)
8688 return potential_constant_expression_1 (TREE_CHAIN (t
), want_rval
,
8692 case TRUNC_DIV_EXPR
:
8694 case FLOOR_DIV_EXPR
:
8695 case ROUND_DIV_EXPR
:
8696 case TRUNC_MOD_EXPR
:
8698 case ROUND_MOD_EXPR
:
8700 tree denom
= TREE_OPERAND (t
, 1);
8701 if (!potential_constant_expression_1 (denom
, rval
, flags
))
8703 /* We can't call cxx_eval_outermost_constant_expr on an expression
8704 that hasn't been through fold_non_dependent_expr yet. */
8705 if (!processing_template_decl
)
8706 denom
= cxx_eval_outermost_constant_expr (denom
, true);
8707 if (integer_zerop (denom
))
8709 if (flags
& tf_error
)
8710 error ("division by zero is not a constant-expression");
8716 return potential_constant_expression_1 (TREE_OPERAND (t
, 0),
8723 /* check_return_expr sometimes wraps a TARGET_EXPR in a
8724 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
8725 introduced by build_call_a. */
8726 tree op0
= TREE_OPERAND (t
, 0);
8727 tree op1
= TREE_OPERAND (t
, 1);
8729 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
8730 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
8731 return potential_constant_expression_1 (op0
, want_rval
, flags
);
8736 /* If the first operand is the non-short-circuit constant, look at
8737 the second operand; otherwise we only care about the first one for
8739 case TRUTH_AND_EXPR
:
8740 case TRUTH_ANDIF_EXPR
:
8741 tmp
= boolean_true_node
;
8744 case TRUTH_ORIF_EXPR
:
8745 tmp
= boolean_false_node
;
8748 tree op
= TREE_OPERAND (t
, 0);
8749 if (!potential_constant_expression_1 (op
, rval
, flags
))
8751 if (!processing_template_decl
)
8752 op
= cxx_eval_outermost_constant_expr (op
, true);
8753 if (tree_int_cst_equal (op
, tmp
))
8754 return potential_constant_expression_1 (TREE_OPERAND (t
, 1), rval
, flags
);
8761 case POINTER_PLUS_EXPR
:
8763 case EXACT_DIV_EXPR
:
8773 case TRUTH_XOR_EXPR
:
8774 case UNORDERED_EXPR
:
8787 case ARRAY_RANGE_REF
:
8791 for (i
= 0; i
< 2; ++i
)
8792 if (!potential_constant_expression_1 (TREE_OPERAND (t
, i
),
8799 for (i
= 0; i
< 3; ++i
)
8800 if (!potential_constant_expression_1 (TREE_OPERAND (t
, i
),
8807 /* If the condition is a known constant, we know which of the legs we
8808 care about; otherwise we only require that the condition and
8809 either of the legs be potentially constant. */
8810 tmp
= TREE_OPERAND (t
, 0);
8811 if (!potential_constant_expression_1 (tmp
, rval
, flags
))
8813 if (!processing_template_decl
)
8814 tmp
= cxx_eval_outermost_constant_expr (tmp
, true);
8815 if (integer_zerop (tmp
))
8816 return potential_constant_expression_1 (TREE_OPERAND (t
, 2),
8818 else if (TREE_CODE (tmp
) == INTEGER_CST
)
8819 return potential_constant_expression_1 (TREE_OPERAND (t
, 1),
8821 for (i
= 1; i
< 3; ++i
)
8822 if (potential_constant_expression_1 (TREE_OPERAND (t
, i
),
8823 want_rval
, tf_none
))
8825 if (flags
& tf_error
)
8826 error ("expression %qE is not a constant-expression", t
);
8830 if (VEC_INIT_EXPR_IS_CONSTEXPR (t
))
8832 if (flags
& tf_error
)
8834 error ("non-constant array initialization");
8835 diagnose_non_constexpr_vec_init (t
);
8840 if (objc_is_property_ref (t
))
8843 sorry ("unexpected AST of kind %s", tree_code_name
[TREE_CODE (t
)]);
8849 /* The main entry point to the above. */
8852 potential_constant_expression (tree t
)
8854 return potential_constant_expression_1 (t
, false, tf_none
);
8857 /* As above, but require a constant rvalue. */
8860 potential_rvalue_constant_expression (tree t
)
8862 return potential_constant_expression_1 (t
, true, tf_none
);
8865 /* Like above, but complain about non-constant expressions. */
8868 require_potential_constant_expression (tree t
)
8870 return potential_constant_expression_1 (t
, false, tf_warning_or_error
);
8873 /* Cross product of the above. */
8876 require_potential_rvalue_constant_expression (tree t
)
8878 return potential_constant_expression_1 (t
, true, tf_warning_or_error
);
8881 /* Constructor for a lambda expression. */
8884 build_lambda_expr (void)
8886 tree lambda
= make_node (LAMBDA_EXPR
);
8887 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda
) = CPLD_NONE
;
8888 LAMBDA_EXPR_CAPTURE_LIST (lambda
) = NULL_TREE
;
8889 LAMBDA_EXPR_THIS_CAPTURE (lambda
) = NULL_TREE
;
8890 LAMBDA_EXPR_PENDING_PROXIES (lambda
) = NULL
;
8891 LAMBDA_EXPR_RETURN_TYPE (lambda
) = NULL_TREE
;
8892 LAMBDA_EXPR_MUTABLE_P (lambda
) = false;
8896 /* Create the closure object for a LAMBDA_EXPR. */
8899 build_lambda_object (tree lambda_expr
)
8901 /* Build aggregate constructor call.
8902 - cp_parser_braced_list
8903 - cp_parser_functional_cast */
8904 vec
<constructor_elt
, va_gc
> *elts
= NULL
;
8905 tree node
, expr
, type
;
8906 location_t saved_loc
;
8908 if (processing_template_decl
)
8911 /* Make sure any error messages refer to the lambda-introducer. */
8912 saved_loc
= input_location
;
8913 input_location
= LAMBDA_EXPR_LOCATION (lambda_expr
);
8915 for (node
= LAMBDA_EXPR_CAPTURE_LIST (lambda_expr
);
8917 node
= TREE_CHAIN (node
))
8919 tree field
= TREE_PURPOSE (node
);
8920 tree val
= TREE_VALUE (node
);
8922 if (field
== error_mark_node
)
8924 expr
= error_mark_node
;
8931 /* Mere mortals can't copy arrays with aggregate initialization, so
8932 do some magic to make it work here. */
8933 if (TREE_CODE (TREE_TYPE (field
)) == ARRAY_TYPE
)
8934 val
= build_array_copy (val
);
8935 else if (DECL_NORMAL_CAPTURE_P (field
)
8936 && TREE_CODE (TREE_TYPE (field
)) != REFERENCE_TYPE
)
8938 /* "the entities that are captured by copy are used to
8939 direct-initialize each corresponding non-static data
8940 member of the resulting closure object."
8942 There's normally no way to express direct-initialization
8943 from an element of a CONSTRUCTOR, so we build up a special
8944 TARGET_EXPR to bypass the usual copy-initialization. */
8945 val
= force_rvalue (val
, tf_warning_or_error
);
8946 if (TREE_CODE (val
) == TARGET_EXPR
)
8947 TARGET_EXPR_DIRECT_INIT_P (val
) = true;
8950 CONSTRUCTOR_APPEND_ELT (elts
, DECL_NAME (field
), val
);
8953 expr
= build_constructor (init_list_type_node
, elts
);
8954 CONSTRUCTOR_IS_DIRECT_INIT (expr
) = 1;
8956 /* N2927: "[The closure] class type is not an aggregate."
8957 But we briefly treat it as an aggregate to make this simpler. */
8958 type
= LAMBDA_EXPR_CLOSURE (lambda_expr
);
8959 CLASSTYPE_NON_AGGREGATE (type
) = 0;
8960 expr
= finish_compound_literal (type
, expr
, tf_warning_or_error
);
8961 CLASSTYPE_NON_AGGREGATE (type
) = 1;
8964 input_location
= saved_loc
;
8968 /* Return an initialized RECORD_TYPE for LAMBDA.
8969 LAMBDA must have its explicit captures already. */
8972 begin_lambda_type (tree lambda
)
8977 /* Unique name. This is just like an unnamed class, but we cannot use
8978 make_anon_name because of certain checks against TYPE_ANONYMOUS_P. */
8980 name
= make_lambda_name ();
8982 /* Create the new RECORD_TYPE for this lambda. */
8983 type
= xref_tag (/*tag_code=*/record_type
,
8985 /*scope=*/ts_lambda
,
8986 /*template_header_p=*/false);
8989 /* Designate it as a struct so that we can use aggregate initialization. */
8990 CLASSTYPE_DECLARED_CLASS (type
) = false;
8992 /* Cross-reference the expression and the type. */
8993 LAMBDA_EXPR_CLOSURE (lambda
) = type
;
8994 CLASSTYPE_LAMBDA_EXPR (type
) = lambda
;
8996 /* Clear base types. */
8997 xref_basetypes (type
, /*bases=*/NULL_TREE
);
8999 /* Start the class. */
9000 type
= begin_class_definition (type
);
9001 if (type
== error_mark_node
)
9002 return error_mark_node
;
9007 /* Returns the type to use for the return type of the operator() of a
9011 lambda_return_type (tree expr
)
9013 if (expr
== NULL_TREE
)
9014 return void_type_node
;
9015 if (type_unknown_p (expr
)
9016 || BRACE_ENCLOSED_INITIALIZER_P (expr
))
9018 cxx_incomplete_type_error (expr
, TREE_TYPE (expr
));
9019 return void_type_node
;
9021 gcc_checking_assert (!type_dependent_expression_p (expr
));
9022 return cv_unqualified (type_decays_to (unlowered_expr_type (expr
)));
9025 /* Given a LAMBDA_EXPR or closure type LAMBDA, return the op() of the
9029 lambda_function (tree lambda
)
9032 if (TREE_CODE (lambda
) == LAMBDA_EXPR
)
9033 type
= LAMBDA_EXPR_CLOSURE (lambda
);
9036 gcc_assert (LAMBDA_TYPE_P (type
));
9037 /* Don't let debug_tree cause instantiation. */
9038 if (CLASSTYPE_TEMPLATE_INSTANTIATION (type
)
9039 && !COMPLETE_OR_OPEN_TYPE_P (type
))
9041 lambda
= lookup_member (type
, ansi_opname (CALL_EXPR
),
9042 /*protect=*/0, /*want_type=*/false,
9043 tf_warning_or_error
);
9045 lambda
= BASELINK_FUNCTIONS (lambda
);
9049 /* Returns the type to use for the FIELD_DECL corresponding to the
9051 The caller should add REFERENCE_TYPE for capture by reference. */
9054 lambda_capture_field_type (tree expr
)
9057 if (!TREE_TYPE (expr
) || WILDCARD_TYPE_P (TREE_TYPE (expr
)))
9059 type
= cxx_make_type (DECLTYPE_TYPE
);
9060 DECLTYPE_TYPE_EXPR (type
) = expr
;
9061 DECLTYPE_FOR_LAMBDA_CAPTURE (type
) = true;
9062 SET_TYPE_STRUCTURAL_EQUALITY (type
);
9065 type
= non_reference (unlowered_expr_type (expr
));
9069 /* Insert the deduced return type for an auto function. */
9072 apply_deduced_return_type (tree fco
, tree return_type
)
9076 if (return_type
== error_mark_node
)
9079 if (LAMBDA_FUNCTION_P (fco
))
9081 tree lambda
= CLASSTYPE_LAMBDA_EXPR (current_class_type
);
9082 LAMBDA_EXPR_RETURN_TYPE (lambda
) = return_type
;
9085 if (DECL_CONV_FN_P (fco
))
9086 DECL_NAME (fco
) = mangle_conv_op_name_for_type (return_type
);
9088 TREE_TYPE (fco
) = change_return_type (return_type
, TREE_TYPE (fco
));
9090 result
= DECL_RESULT (fco
);
9091 if (result
== NULL_TREE
)
9093 if (TREE_TYPE (result
) == return_type
)
9096 /* We already have a DECL_RESULT from start_preparsed_function.
9097 Now we need to redo the work it and allocate_struct_function
9098 did to reflect the new type. */
9099 gcc_assert (current_function_decl
== fco
);
9100 result
= build_decl (input_location
, RESULT_DECL
, NULL_TREE
,
9101 TYPE_MAIN_VARIANT (return_type
));
9102 DECL_ARTIFICIAL (result
) = 1;
9103 DECL_IGNORED_P (result
) = 1;
9104 cp_apply_type_quals_to_decl (cp_type_quals (return_type
),
9107 DECL_RESULT (fco
) = result
;
9109 if (!processing_template_decl
)
9111 bool aggr
= aggregate_value_p (result
, fco
);
9112 #ifdef PCC_STATIC_STRUCT_RETURN
9113 cfun
->returns_pcc_struct
= aggr
;
9115 cfun
->returns_struct
= aggr
;
9120 /* DECL is a local variable or parameter from the surrounding scope of a
9121 lambda-expression. Returns the decltype for a use of the capture field
9122 for DECL even if it hasn't been captured yet. */
9125 capture_decltype (tree decl
)
9127 tree lam
= CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (current_function_decl
));
9128 /* FIXME do lookup instead of list walk? */
9129 tree cap
= value_member (decl
, LAMBDA_EXPR_CAPTURE_LIST (lam
));
9133 type
= TREE_TYPE (TREE_PURPOSE (cap
));
9135 switch (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lam
))
9138 error ("%qD is not captured", decl
);
9139 return error_mark_node
;
9142 type
= TREE_TYPE (decl
);
9143 if (TREE_CODE (type
) == REFERENCE_TYPE
9144 && TREE_CODE (TREE_TYPE (type
)) != FUNCTION_TYPE
)
9145 type
= TREE_TYPE (type
);
9148 case CPLD_REFERENCE
:
9149 type
= TREE_TYPE (decl
);
9150 if (TREE_CODE (type
) != REFERENCE_TYPE
)
9151 type
= build_reference_type (TREE_TYPE (decl
));
9158 if (TREE_CODE (type
) != REFERENCE_TYPE
)
9160 if (!LAMBDA_EXPR_MUTABLE_P (lam
))
9161 type
= cp_build_qualified_type (type
, (cp_type_quals (type
)
9163 type
= build_reference_type (type
);
9168 /* Returns true iff DECL is a lambda capture proxy variable created by
9169 build_capture_proxy. */
9172 is_capture_proxy (tree decl
)
9174 return (TREE_CODE (decl
) == VAR_DECL
9175 && DECL_HAS_VALUE_EXPR_P (decl
)
9176 && !DECL_ANON_UNION_VAR_P (decl
)
9177 && LAMBDA_FUNCTION_P (DECL_CONTEXT (decl
)));
9180 /* Returns true iff DECL is a capture proxy for a normal capture
9181 (i.e. without explicit initializer). */
9184 is_normal_capture_proxy (tree decl
)
9186 if (!is_capture_proxy (decl
))
9187 /* It's not a capture proxy. */
9190 /* It is a capture proxy, is it a normal capture? */
9191 tree val
= DECL_VALUE_EXPR (decl
);
9192 if (val
== error_mark_node
)
9195 gcc_assert (TREE_CODE (val
) == COMPONENT_REF
);
9196 val
= TREE_OPERAND (val
, 1);
9197 return DECL_NORMAL_CAPTURE_P (val
);
9200 /* VAR is a capture proxy created by build_capture_proxy; add it to the
9201 current function, which is the operator() for the appropriate lambda. */
9204 insert_capture_proxy (tree var
)
9206 cp_binding_level
*b
;
9210 /* Put the capture proxy in the extra body block so that it won't clash
9211 with a later local variable. */
9212 b
= current_binding_level
;
9213 for (skip
= 0; ; ++skip
)
9215 cp_binding_level
*n
= b
->level_chain
;
9216 if (n
->kind
== sk_function_parms
)
9220 pushdecl_with_scope (var
, b
, false);
9222 /* And put a DECL_EXPR in the STATEMENT_LIST for the same block. */
9223 var
= build_stmt (DECL_SOURCE_LOCATION (var
), DECL_EXPR
, var
);
9224 stmt_list
= (*stmt_list_stack
)[stmt_list_stack
->length () - 1 - skip
];
9225 gcc_assert (stmt_list
);
9226 append_to_statement_list_force (var
, &stmt_list
);
9229 /* We've just finished processing a lambda; if the containing scope is also
9230 a lambda, insert any capture proxies that were created while processing
9231 the nested lambda. */
9234 insert_pending_capture_proxies (void)
9237 vec
<tree
, va_gc
> *proxies
;
9240 if (!current_function_decl
|| !LAMBDA_FUNCTION_P (current_function_decl
))
9243 lam
= CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (current_function_decl
));
9244 proxies
= LAMBDA_EXPR_PENDING_PROXIES (lam
);
9245 for (i
= 0; i
< vec_safe_length (proxies
); ++i
)
9247 tree var
= (*proxies
)[i
];
9248 insert_capture_proxy (var
);
9250 release_tree_vector (LAMBDA_EXPR_PENDING_PROXIES (lam
));
9251 LAMBDA_EXPR_PENDING_PROXIES (lam
) = NULL
;
9254 /* Given REF, a COMPONENT_REF designating a field in the lambda closure,
9255 return the type we want the proxy to have: the type of the field itself,
9256 with added const-qualification if the lambda isn't mutable and the
9257 capture is by value. */
9260 lambda_proxy_type (tree ref
)
9263 if (REFERENCE_REF_P (ref
))
9264 ref
= TREE_OPERAND (ref
, 0);
9265 type
= TREE_TYPE (ref
);
9266 if (type
&& !WILDCARD_TYPE_P (type
))
9268 type
= cxx_make_type (DECLTYPE_TYPE
);
9269 DECLTYPE_TYPE_EXPR (type
) = ref
;
9270 DECLTYPE_FOR_LAMBDA_PROXY (type
) = true;
9271 SET_TYPE_STRUCTURAL_EQUALITY (type
);
9275 /* MEMBER is a capture field in a lambda closure class. Now that we're
9276 inside the operator(), build a placeholder var for future lookups and
9280 build_capture_proxy (tree member
)
9282 tree var
, object
, fn
, closure
, name
, lam
, type
;
9284 closure
= DECL_CONTEXT (member
);
9285 fn
= lambda_function (closure
);
9286 lam
= CLASSTYPE_LAMBDA_EXPR (closure
);
9288 /* The proxy variable forwards to the capture field. */
9289 object
= build_fold_indirect_ref (DECL_ARGUMENTS (fn
));
9290 object
= finish_non_static_data_member (member
, object
, NULL_TREE
);
9291 if (REFERENCE_REF_P (object
))
9292 object
= TREE_OPERAND (object
, 0);
9294 /* Remove the __ inserted by add_capture. */
9295 name
= get_identifier (IDENTIFIER_POINTER (DECL_NAME (member
)) + 2);
9297 type
= lambda_proxy_type (object
);
9298 var
= build_decl (input_location
, VAR_DECL
, name
, type
);
9299 SET_DECL_VALUE_EXPR (var
, object
);
9300 DECL_HAS_VALUE_EXPR_P (var
) = 1;
9301 DECL_ARTIFICIAL (var
) = 1;
9302 TREE_USED (var
) = 1;
9303 DECL_CONTEXT (var
) = fn
;
9305 if (name
== this_identifier
)
9307 gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (lam
) == member
);
9308 LAMBDA_EXPR_THIS_CAPTURE (lam
) = var
;
9311 if (fn
== current_function_decl
)
9312 insert_capture_proxy (var
);
9314 vec_safe_push (LAMBDA_EXPR_PENDING_PROXIES (lam
), var
);
9319 /* From an ID and INITIALIZER, create a capture (by reference if
9320 BY_REFERENCE_P is true), add it to the capture-list for LAMBDA,
9324 add_capture (tree lambda
, tree id
, tree initializer
, bool by_reference_p
,
9325 bool explicit_init_p
)
9328 tree type
, member
, name
;
9330 type
= lambda_capture_field_type (initializer
);
9333 type
= build_reference_type (type
);
9334 if (!real_lvalue_p (initializer
))
9335 error ("cannot capture %qE by reference", initializer
);
9338 /* Capture by copy requires a complete type. */
9339 type
= complete_type (type
);
9341 /* Add __ to the beginning of the field name so that user code
9342 won't find the field with name lookup. We can't just leave the name
9343 unset because template instantiation uses the name to find
9344 instantiated fields. */
9345 buf
= (char *) alloca (IDENTIFIER_LENGTH (id
) + 3);
9346 buf
[1] = buf
[0] = '_';
9347 memcpy (buf
+ 2, IDENTIFIER_POINTER (id
),
9348 IDENTIFIER_LENGTH (id
) + 1);
9349 name
= get_identifier (buf
);
9351 /* If TREE_TYPE isn't set, we're still in the introducer, so check
9353 if (!LAMBDA_EXPR_CLOSURE (lambda
))
9355 if (IDENTIFIER_MARKED (name
))
9357 pedwarn (input_location
, 0,
9358 "already captured %qD in lambda expression", id
);
9361 IDENTIFIER_MARKED (name
) = true;
9364 /* Make member variable. */
9365 member
= build_lang_decl (FIELD_DECL
, name
, type
);
9367 if (!explicit_init_p
)
9368 /* Normal captures are invisible to name lookup but uses are replaced
9369 with references to the capture field; we implement this by only
9370 really making them invisible in unevaluated context; see
9371 qualify_lookup. For now, let's make explicitly initialized captures
9373 DECL_NORMAL_CAPTURE_P (member
) = true;
9375 if (id
== this_identifier
)
9376 LAMBDA_EXPR_THIS_CAPTURE (lambda
) = member
;
9378 /* Add it to the appropriate closure class if we've started it. */
9379 if (current_class_type
9380 && current_class_type
== LAMBDA_EXPR_CLOSURE (lambda
))
9381 finish_member_declaration (member
);
9383 LAMBDA_EXPR_CAPTURE_LIST (lambda
)
9384 = tree_cons (member
, initializer
, LAMBDA_EXPR_CAPTURE_LIST (lambda
));
9386 if (LAMBDA_EXPR_CLOSURE (lambda
))
9387 return build_capture_proxy (member
);
9388 /* For explicit captures we haven't started the function yet, so we wait
9389 and build the proxy from cp_parser_lambda_body. */
9393 /* Register all the capture members on the list CAPTURES, which is the
9394 LAMBDA_EXPR_CAPTURE_LIST for the lambda after the introducer. */
9397 register_capture_members (tree captures
)
9399 if (captures
== NULL_TREE
)
9402 register_capture_members (TREE_CHAIN (captures
));
9403 /* We set this in add_capture to avoid duplicates. */
9404 IDENTIFIER_MARKED (DECL_NAME (TREE_PURPOSE (captures
))) = false;
9405 finish_member_declaration (TREE_PURPOSE (captures
));
9408 /* Similar to add_capture, except this works on a stack of nested lambdas.
9409 BY_REFERENCE_P in this case is derived from the default capture mode.
9410 Returns the capture for the lambda at the bottom of the stack. */
9413 add_default_capture (tree lambda_stack
, tree id
, tree initializer
)
9415 bool this_capture_p
= (id
== this_identifier
);
9417 tree var
= NULL_TREE
;
9419 tree saved_class_type
= current_class_type
;
9423 for (node
= lambda_stack
;
9425 node
= TREE_CHAIN (node
))
9427 tree lambda
= TREE_VALUE (node
);
9429 current_class_type
= LAMBDA_EXPR_CLOSURE (lambda
);
9430 var
= add_capture (lambda
,
9435 && (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda
)
9436 == CPLD_REFERENCE
)),
9437 /*explicit_init_p=*/false);
9438 initializer
= convert_from_reference (var
);
9441 current_class_type
= saved_class_type
;
9446 /* Return the capture pertaining to a use of 'this' in LAMBDA, in the form of an
9447 INDIRECT_REF, possibly adding it through default capturing. */
9450 lambda_expr_this_capture (tree lambda
)
9454 tree this_capture
= LAMBDA_EXPR_THIS_CAPTURE (lambda
);
9456 /* In unevaluated context this isn't an odr-use, so just return the
9458 if (cp_unevaluated_operand
)
9459 return lookup_name (this_identifier
);
9461 /* Try to default capture 'this' if we can. */
9463 && LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda
) != CPLD_NONE
)
9465 tree lambda_stack
= NULL_TREE
;
9466 tree init
= NULL_TREE
;
9468 /* If we are in a lambda function, we can move out until we hit:
9469 1. a non-lambda function or NSDMI,
9470 2. a lambda function capturing 'this', or
9471 3. a non-default capturing lambda function. */
9472 for (tree tlambda
= lambda
; ;)
9474 lambda_stack
= tree_cons (NULL_TREE
,
9478 if (LAMBDA_EXPR_EXTRA_SCOPE (tlambda
)
9479 && TREE_CODE (LAMBDA_EXPR_EXTRA_SCOPE (tlambda
)) == FIELD_DECL
)
9481 /* In an NSDMI, we don't have a function to look up the decl in,
9482 but the fake 'this' pointer that we're using for parsing is
9484 init
= scope_chain
->x_current_class_ptr
;
9486 (init
&& (TREE_TYPE (TREE_TYPE (init
))
9487 == current_nonlambda_class_type ()));
9491 tree closure_decl
= TYPE_NAME (LAMBDA_EXPR_CLOSURE (tlambda
));
9492 tree containing_function
= decl_function_context (closure_decl
);
9494 if (containing_function
== NULL_TREE
)
9495 /* We ran out of scopes; there's no 'this' to capture. */
9498 if (!LAMBDA_FUNCTION_P (containing_function
))
9500 /* We found a non-lambda function. */
9501 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (containing_function
))
9502 /* First parameter is 'this'. */
9503 init
= DECL_ARGUMENTS (containing_function
);
9508 = CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (containing_function
));
9510 if (LAMBDA_EXPR_THIS_CAPTURE (tlambda
))
9512 /* An outer lambda has already captured 'this'. */
9513 init
= LAMBDA_EXPR_THIS_CAPTURE (tlambda
);
9517 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (tlambda
) == CPLD_NONE
)
9518 /* An outer lambda won't let us capture 'this'. */
9523 this_capture
= add_default_capture (lambda_stack
,
9524 /*id=*/this_identifier
,
9530 error ("%<this%> was not captured for this lambda function");
9531 result
= error_mark_node
;
9535 /* To make sure that current_class_ref is for the lambda. */
9536 gcc_assert (TYPE_MAIN_VARIANT (TREE_TYPE (current_class_ref
))
9537 == LAMBDA_EXPR_CLOSURE (lambda
));
9539 result
= this_capture
;
9541 /* If 'this' is captured, each use of 'this' is transformed into an
9542 access to the corresponding unnamed data member of the closure
9543 type cast (_expr.cast_ 5.4) to the type of 'this'. [ The cast
9544 ensures that the transformed expression is an rvalue. ] */
9545 result
= rvalue (result
);
9551 /* We don't want to capture 'this' until we know we need it, i.e. after
9552 overload resolution has chosen a non-static member function. At that
9553 point we call this function to turn a dummy object into a use of the
9557 maybe_resolve_dummy (tree object
)
9559 if (!is_dummy_object (object
))
9562 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (object
));
9563 gcc_assert (TREE_CODE (type
) != POINTER_TYPE
);
9565 if (type
!= current_class_type
9566 && current_class_type
9567 && LAMBDA_TYPE_P (current_class_type
)
9568 && DERIVED_FROM_P (type
, current_nonlambda_class_type ()))
9570 /* In a lambda, need to go through 'this' capture. */
9571 tree lam
= CLASSTYPE_LAMBDA_EXPR (current_class_type
);
9572 tree cap
= lambda_expr_this_capture (lam
);
9573 object
= build_x_indirect_ref (EXPR_LOCATION (object
), cap
,
9574 RO_NULL
, tf_warning_or_error
);
9580 /* Returns the method basetype of the innermost non-lambda function, or
9581 NULL_TREE if none. */
9584 nonlambda_method_basetype (void)
9587 if (!current_class_ref
)
9590 type
= current_class_type
;
9591 if (!LAMBDA_TYPE_P (type
))
9594 /* Find the nearest enclosing non-lambda function. */
9595 fn
= TYPE_NAME (type
);
9597 fn
= decl_function_context (fn
);
9598 while (fn
&& LAMBDA_FUNCTION_P (fn
));
9600 if (!fn
|| !DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
9603 return TYPE_METHOD_BASETYPE (TREE_TYPE (fn
));
9606 /* If the closure TYPE has a static op(), also add a conversion to function
9610 maybe_add_lambda_conv_op (tree type
)
9612 bool nested
= (current_function_decl
!= NULL_TREE
);
9613 tree callop
= lambda_function (type
);
9614 tree rettype
, name
, fntype
, fn
, body
, compound_stmt
;
9615 tree thistype
, stattype
, statfn
, convfn
, call
, arg
;
9616 vec
<tree
, va_gc
> *argvec
;
9618 if (LAMBDA_EXPR_CAPTURE_LIST (CLASSTYPE_LAMBDA_EXPR (type
)) != NULL_TREE
)
9621 if (processing_template_decl
)
9624 stattype
= build_function_type (TREE_TYPE (TREE_TYPE (callop
)),
9625 FUNCTION_ARG_CHAIN (callop
));
9627 /* First build up the conversion op. */
9629 rettype
= build_pointer_type (stattype
);
9630 name
= mangle_conv_op_name_for_type (rettype
);
9631 thistype
= cp_build_qualified_type (type
, TYPE_QUAL_CONST
);
9632 fntype
= build_method_type_directly (thistype
, rettype
, void_list_node
);
9633 fn
= convfn
= build_lang_decl (FUNCTION_DECL
, name
, fntype
);
9634 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (callop
);
9636 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
9637 && DECL_ALIGN (fn
) < 2 * BITS_PER_UNIT
)
9638 DECL_ALIGN (fn
) = 2 * BITS_PER_UNIT
;
9640 SET_OVERLOADED_OPERATOR_CODE (fn
, TYPE_EXPR
);
9641 grokclassfn (type
, fn
, NO_SPECIAL
);
9642 set_linkage_according_to_type (type
, fn
);
9643 rest_of_decl_compilation (fn
, toplevel_bindings_p (), at_eof
);
9644 DECL_IN_AGGR_P (fn
) = 1;
9645 DECL_ARTIFICIAL (fn
) = 1;
9646 DECL_NOT_REALLY_EXTERN (fn
) = 1;
9647 DECL_DECLARED_INLINE_P (fn
) = 1;
9648 DECL_ARGUMENTS (fn
) = build_this_parm (fntype
, TYPE_QUAL_CONST
);
9650 DECL_INTERFACE_KNOWN (fn
) = 1;
9652 add_method (type
, fn
, NULL_TREE
);
9654 /* Generic thunk code fails for varargs; we'll complain in mark_used if
9655 the conversion op is used. */
9656 if (varargs_function_p (callop
))
9658 DECL_DELETED_FN (fn
) = 1;
9662 /* Now build up the thunk to be returned. */
9664 name
= get_identifier ("_FUN");
9665 fn
= statfn
= build_lang_decl (FUNCTION_DECL
, name
, stattype
);
9666 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (callop
);
9667 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
9668 && DECL_ALIGN (fn
) < 2 * BITS_PER_UNIT
)
9669 DECL_ALIGN (fn
) = 2 * BITS_PER_UNIT
;
9670 grokclassfn (type
, fn
, NO_SPECIAL
);
9671 set_linkage_according_to_type (type
, fn
);
9672 rest_of_decl_compilation (fn
, toplevel_bindings_p (), at_eof
);
9673 DECL_IN_AGGR_P (fn
) = 1;
9674 DECL_ARTIFICIAL (fn
) = 1;
9675 DECL_NOT_REALLY_EXTERN (fn
) = 1;
9676 DECL_DECLARED_INLINE_P (fn
) = 1;
9677 DECL_STATIC_FUNCTION_P (fn
) = 1;
9678 DECL_ARGUMENTS (fn
) = copy_list (DECL_CHAIN (DECL_ARGUMENTS (callop
)));
9679 for (arg
= DECL_ARGUMENTS (fn
); arg
; arg
= DECL_CHAIN (arg
))
9681 /* Avoid duplicate -Wshadow warnings. */
9682 DECL_NAME (arg
) = NULL_TREE
;
9683 DECL_CONTEXT (arg
) = fn
;
9686 DECL_INTERFACE_KNOWN (fn
) = 1;
9688 add_method (type
, fn
, NULL_TREE
);
9691 push_function_context ();
9693 /* Still increment function_depth so that we don't GC in the
9694 middle of an expression. */
9697 /* Generate the body of the thunk. */
9699 start_preparsed_function (statfn
, NULL_TREE
,
9700 SF_PRE_PARSED
| SF_INCLASS_INLINE
);
9701 if (DECL_ONE_ONLY (statfn
))
9703 /* Put the thunk in the same comdat group as the call op. */
9704 symtab_add_to_same_comdat_group
9705 ((symtab_node
) cgraph_get_create_node (statfn
),
9706 (symtab_node
) cgraph_get_create_node (callop
));
9708 body
= begin_function_body ();
9709 compound_stmt
= begin_compound_stmt (0);
9711 arg
= build1 (NOP_EXPR
, TREE_TYPE (DECL_ARGUMENTS (callop
)),
9713 argvec
= make_tree_vector ();
9714 argvec
->quick_push (arg
);
9715 for (arg
= DECL_ARGUMENTS (statfn
); arg
; arg
= DECL_CHAIN (arg
))
9717 mark_exp_read (arg
);
9718 vec_safe_push (argvec
, arg
);
9720 call
= build_call_a (callop
, argvec
->length (), argvec
->address ());
9721 CALL_FROM_THUNK_P (call
) = 1;
9722 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (call
)))
9723 call
= build_cplus_new (TREE_TYPE (call
), call
, tf_warning_or_error
);
9724 call
= convert_from_reference (call
);
9725 finish_return_stmt (call
);
9727 finish_compound_stmt (compound_stmt
);
9728 finish_function_body (body
);
9730 expand_or_defer_fn (finish_function (2));
9732 /* Generate the body of the conversion op. */
9734 start_preparsed_function (convfn
, NULL_TREE
,
9735 SF_PRE_PARSED
| SF_INCLASS_INLINE
);
9736 body
= begin_function_body ();
9737 compound_stmt
= begin_compound_stmt (0);
9739 /* decl_needed_p needs to see that it's used. */
9740 TREE_USED (statfn
) = 1;
9741 finish_return_stmt (decay_conversion (statfn
, tf_warning_or_error
));
9743 finish_compound_stmt (compound_stmt
);
9744 finish_function_body (body
);
9746 expand_or_defer_fn (finish_function (2));
9749 pop_function_context ();
9754 /* Returns true iff VAL is a lambda-related declaration which should
9755 be ignored by unqualified lookup. */
9758 is_lambda_ignored_entity (tree val
)
9760 /* In unevaluated context, look past normal capture proxies. */
9761 if (cp_unevaluated_operand
&& is_normal_capture_proxy (val
))
9764 /* Always ignore lambda fields, their names are only for debugging. */
9765 if (TREE_CODE (val
) == FIELD_DECL
9766 && CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (val
)))
9769 /* None of the lookups that use qualify_lookup want the op() from the
9770 lambda; they want the one from the enclosing class. */
9771 if (TREE_CODE (val
) == FUNCTION_DECL
&& LAMBDA_FUNCTION_P (val
))
9777 #include "gt-cp-semantics.h"