1 /* Perform the semantic phase of parsing, i.e., the process of
2 building tree structure, checking semantic consistency, and
3 building RTL. These routines are used both during actual parsing
4 and during the instantiation of template functions.
6 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
7 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
8 Written by Mark Mitchell (mmitchell@usa.net) based on code found
9 formerly in parse.y and pt.c.
11 This file is part of GCC.
13 GCC is free software; you can redistribute it and/or modify it
14 under the terms of the GNU General Public License as published by
15 the Free Software Foundation; either version 3, or (at your option)
18 GCC is distributed in the hope that it will be useful, but
19 WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 General Public License for more details.
23 You should have received a copy of the GNU General Public License
24 along with GCC; see the file COPYING3. If not see
25 <http://www.gnu.org/licenses/>. */
29 #include "coretypes.h"
33 #include "c-family/c-common.h"
34 #include "c-family/c-objc.h"
35 #include "tree-inline.h"
36 #include "tree-mudflap.h"
41 #include "diagnostic.h"
43 #include "tree-iterator.h"
49 /* There routines provide a modular interface to perform many parsing
50 operations. They may therefore be used during actual parsing, or
51 during template instantiation, which may be regarded as a
52 degenerate form of parsing. */
54 static tree
maybe_convert_cond (tree
);
55 static tree
finalize_nrv_r (tree
*, int *, void *);
56 static tree
capture_decltype (tree
);
57 static tree
thisify_lambda_field (tree
);
60 /* Deferred Access Checking Overview
61 ---------------------------------
63 Most C++ expressions and declarations require access checking
64 to be performed during parsing. However, in several cases,
65 this has to be treated differently.
67 For member declarations, access checking has to be deferred
68 until more information about the declaration is known. For
80 When we are parsing the function return type `A::X', we don't
81 really know if this is allowed until we parse the function name.
83 Furthermore, some contexts require that access checking is
84 never performed at all. These include class heads, and template
87 Typical use of access checking functions is described here:
89 1. When we enter a context that requires certain access checking
90 mode, the function `push_deferring_access_checks' is called with
91 DEFERRING argument specifying the desired mode. Access checking
92 may be performed immediately (dk_no_deferred), deferred
93 (dk_deferred), or not performed (dk_no_check).
95 2. When a declaration such as a type, or a variable, is encountered,
96 the function `perform_or_defer_access_check' is called. It
97 maintains a VEC of all deferred checks.
99 3. The global `current_class_type' or `current_function_decl' is then
100 setup by the parser. `enforce_access' relies on these information
103 4. Upon exiting the context mentioned in step 1,
104 `perform_deferred_access_checks' is called to check all declaration
105 stored in the VEC. `pop_deferring_access_checks' is then
106 called to restore the previous access checking mode.
108 In case of parsing error, we simply call `pop_deferring_access_checks'
109 without `perform_deferred_access_checks'. */
111 typedef struct GTY(()) deferred_access
{
112 /* A VEC representing name-lookups for which we have deferred
113 checking access controls. We cannot check the accessibility of
114 names used in a decl-specifier-seq until we know what is being
115 declared because code like:
122 A::B* A::f() { return 0; }
124 is valid, even though `A::B' is not generally accessible. */
125 VEC (deferred_access_check
,gc
)* GTY(()) deferred_access_checks
;
127 /* The current mode of access checks. */
128 enum deferring_kind deferring_access_checks_kind
;
131 DEF_VEC_O (deferred_access
);
132 DEF_VEC_ALLOC_O (deferred_access
,gc
);
134 /* Data for deferred access checking. */
135 static GTY(()) VEC(deferred_access
,gc
) *deferred_access_stack
;
136 static GTY(()) unsigned deferred_access_no_check
;
138 /* Save the current deferred access states and start deferred
139 access checking iff DEFER_P is true. */
142 push_deferring_access_checks (deferring_kind deferring
)
144 /* For context like template instantiation, access checking
145 disabling applies to all nested context. */
146 if (deferred_access_no_check
|| deferring
== dk_no_check
)
147 deferred_access_no_check
++;
150 deferred_access
*ptr
;
152 ptr
= VEC_safe_push (deferred_access
, gc
, deferred_access_stack
, NULL
);
153 ptr
->deferred_access_checks
= NULL
;
154 ptr
->deferring_access_checks_kind
= deferring
;
158 /* Resume deferring access checks again after we stopped doing
162 resume_deferring_access_checks (void)
164 if (!deferred_access_no_check
)
165 VEC_last (deferred_access
, deferred_access_stack
)
166 ->deferring_access_checks_kind
= dk_deferred
;
169 /* Stop deferring access checks. */
172 stop_deferring_access_checks (void)
174 if (!deferred_access_no_check
)
175 VEC_last (deferred_access
, deferred_access_stack
)
176 ->deferring_access_checks_kind
= dk_no_deferred
;
179 /* Discard the current deferred access checks and restore the
183 pop_deferring_access_checks (void)
185 if (deferred_access_no_check
)
186 deferred_access_no_check
--;
188 VEC_pop (deferred_access
, deferred_access_stack
);
191 /* Returns a TREE_LIST representing the deferred checks.
192 The TREE_PURPOSE of each node is the type through which the
193 access occurred; the TREE_VALUE is the declaration named.
196 VEC (deferred_access_check
,gc
)*
197 get_deferred_access_checks (void)
199 if (deferred_access_no_check
)
202 return (VEC_last (deferred_access
, deferred_access_stack
)
203 ->deferred_access_checks
);
206 /* Take current deferred checks and combine with the
207 previous states if we also defer checks previously.
208 Otherwise perform checks now. */
211 pop_to_parent_deferring_access_checks (void)
213 if (deferred_access_no_check
)
214 deferred_access_no_check
--;
217 VEC (deferred_access_check
,gc
) *checks
;
218 deferred_access
*ptr
;
220 checks
= (VEC_last (deferred_access
, deferred_access_stack
)
221 ->deferred_access_checks
);
223 VEC_pop (deferred_access
, deferred_access_stack
);
224 ptr
= VEC_last (deferred_access
, deferred_access_stack
);
225 if (ptr
->deferring_access_checks_kind
== dk_no_deferred
)
228 perform_access_checks (checks
);
232 /* Merge with parent. */
234 deferred_access_check
*chk
, *probe
;
236 FOR_EACH_VEC_ELT (deferred_access_check
, checks
, i
, chk
)
238 FOR_EACH_VEC_ELT (deferred_access_check
,
239 ptr
->deferred_access_checks
, j
, probe
)
241 if (probe
->binfo
== chk
->binfo
&&
242 probe
->decl
== chk
->decl
&&
243 probe
->diag_decl
== chk
->diag_decl
)
246 /* Insert into parent's checks. */
247 VEC_safe_push (deferred_access_check
, gc
,
248 ptr
->deferred_access_checks
, chk
);
255 /* Perform the access checks in CHECKS. The TREE_PURPOSE of each node
256 is the BINFO indicating the qualifying scope used to access the
257 DECL node stored in the TREE_VALUE of the node. */
260 perform_access_checks (VEC (deferred_access_check
,gc
)* checks
)
263 deferred_access_check
*chk
;
268 FOR_EACH_VEC_ELT (deferred_access_check
, checks
, i
, chk
)
269 enforce_access (chk
->binfo
, chk
->decl
, chk
->diag_decl
);
272 /* Perform the deferred access checks.
274 After performing the checks, we still have to keep the list
275 `deferred_access_stack->deferred_access_checks' since we may want
276 to check access for them again later in a different context.
283 A::X A::a, x; // No error for `A::a', error for `x'
285 We have to perform deferred access of `A::X', first with `A::a',
289 perform_deferred_access_checks (void)
291 perform_access_checks (get_deferred_access_checks ());
294 /* Defer checking the accessibility of DECL, when looked up in
295 BINFO. DIAG_DECL is the declaration to use to print diagnostics. */
298 perform_or_defer_access_check (tree binfo
, tree decl
, tree diag_decl
)
301 deferred_access
*ptr
;
302 deferred_access_check
*chk
;
303 deferred_access_check
*new_access
;
306 /* Exit if we are in a context that no access checking is performed.
308 if (deferred_access_no_check
)
311 gcc_assert (TREE_CODE (binfo
) == TREE_BINFO
);
313 ptr
= VEC_last (deferred_access
, deferred_access_stack
);
315 /* If we are not supposed to defer access checks, just check now. */
316 if (ptr
->deferring_access_checks_kind
== dk_no_deferred
)
318 enforce_access (binfo
, decl
, diag_decl
);
322 /* See if we are already going to perform this check. */
323 FOR_EACH_VEC_ELT (deferred_access_check
,
324 ptr
->deferred_access_checks
, i
, chk
)
326 if (chk
->decl
== decl
&& chk
->binfo
== binfo
&&
327 chk
->diag_decl
== diag_decl
)
332 /* If not, record the check. */
334 VEC_safe_push (deferred_access_check
, gc
,
335 ptr
->deferred_access_checks
, 0);
336 new_access
->binfo
= binfo
;
337 new_access
->decl
= decl
;
338 new_access
->diag_decl
= diag_decl
;
341 /* Used by build_over_call in LOOKUP_SPECULATIVE mode: return whether DECL
342 is accessible in BINFO, and possibly complain if not. If we're not
343 checking access, everything is accessible. */
346 speculative_access_check (tree binfo
, tree decl
, tree diag_decl
,
349 if (deferred_access_no_check
)
352 /* If we're checking for implicit delete, we don't want access
354 if (!accessible_p (binfo
, decl
, true))
356 /* Unless we're under maybe_explain_implicit_delete. */
358 enforce_access (binfo
, decl
, diag_decl
);
365 /* Returns nonzero if the current statement is a full expression,
366 i.e. temporaries created during that statement should be destroyed
367 at the end of the statement. */
370 stmts_are_full_exprs_p (void)
372 return current_stmt_tree ()->stmts_are_full_exprs_p
;
375 /* T is a statement. Add it to the statement-tree. This is the C++
376 version. The C/ObjC frontends have a slightly different version of
382 enum tree_code code
= TREE_CODE (t
);
384 if (EXPR_P (t
) && code
!= LABEL_EXPR
)
386 if (!EXPR_HAS_LOCATION (t
))
387 SET_EXPR_LOCATION (t
, input_location
);
389 /* When we expand a statement-tree, we must know whether or not the
390 statements are full-expressions. We record that fact here. */
391 STMT_IS_FULL_EXPR_P (t
) = stmts_are_full_exprs_p ();
394 /* Add T to the statement-tree. Non-side-effect statements need to be
395 recorded during statement expressions. */
396 append_to_statement_list_force (t
, &cur_stmt_list
);
401 /* Returns the stmt_tree to which statements are currently being added. */
404 current_stmt_tree (void)
407 ? &cfun
->language
->base
.x_stmt_tree
408 : &scope_chain
->x_stmt_tree
);
411 /* If statements are full expressions, wrap STMT in a CLEANUP_POINT_EXPR. */
414 maybe_cleanup_point_expr (tree expr
)
416 if (!processing_template_decl
&& stmts_are_full_exprs_p ())
417 expr
= fold_build_cleanup_point_expr (TREE_TYPE (expr
), expr
);
421 /* Like maybe_cleanup_point_expr except have the type of the new expression be
422 void so we don't need to create a temporary variable to hold the inner
423 expression. The reason why we do this is because the original type might be
424 an aggregate and we cannot create a temporary variable for that type. */
427 maybe_cleanup_point_expr_void (tree expr
)
429 if (!processing_template_decl
&& stmts_are_full_exprs_p ())
430 expr
= fold_build_cleanup_point_expr (void_type_node
, expr
);
436 /* Create a declaration statement for the declaration given by the DECL. */
439 add_decl_expr (tree decl
)
441 tree r
= build_stmt (input_location
, DECL_EXPR
, decl
);
442 if (DECL_INITIAL (decl
)
443 || (DECL_SIZE (decl
) && TREE_SIDE_EFFECTS (DECL_SIZE (decl
))))
444 r
= maybe_cleanup_point_expr_void (r
);
448 /* Finish a scope. */
451 do_poplevel (tree stmt_list
)
455 if (stmts_are_full_exprs_p ())
456 block
= poplevel (kept_level_p (), 1, 0);
458 stmt_list
= pop_stmt_list (stmt_list
);
460 if (!processing_template_decl
)
462 stmt_list
= c_build_bind_expr (input_location
, block
, stmt_list
);
463 /* ??? See c_end_compound_stmt re statement expressions. */
469 /* Begin a new scope. */
472 do_pushlevel (scope_kind sk
)
474 tree ret
= push_stmt_list ();
475 if (stmts_are_full_exprs_p ())
476 begin_scope (sk
, NULL
);
480 /* Queue a cleanup. CLEANUP is an expression/statement to be executed
481 when the current scope is exited. EH_ONLY is true when this is not
482 meant to apply to normal control flow transfer. */
485 push_cleanup (tree decl
, tree cleanup
, bool eh_only
)
487 tree stmt
= build_stmt (input_location
, CLEANUP_STMT
, NULL
, cleanup
, decl
);
488 CLEANUP_EH_ONLY (stmt
) = eh_only
;
490 CLEANUP_BODY (stmt
) = push_stmt_list ();
493 /* Begin a conditional that might contain a declaration. When generating
494 normal code, we want the declaration to appear before the statement
495 containing the conditional. When generating template code, we want the
496 conditional to be rendered as the raw DECL_EXPR. */
499 begin_cond (tree
*cond_p
)
501 if (processing_template_decl
)
502 *cond_p
= push_stmt_list ();
505 /* Finish such a conditional. */
508 finish_cond (tree
*cond_p
, tree expr
)
510 if (processing_template_decl
)
512 tree cond
= pop_stmt_list (*cond_p
);
513 if (TREE_CODE (cond
) == DECL_EXPR
)
516 if (check_for_bare_parameter_packs (expr
))
517 *cond_p
= error_mark_node
;
522 /* If *COND_P specifies a conditional with a declaration, transform the
525 for (; A x = 42;) { }
527 while (true) { A x = 42; if (!x) break; }
528 for (;;) { A x = 42; if (!x) break; }
529 The statement list for BODY will be empty if the conditional did
530 not declare anything. */
533 simplify_loop_decl_cond (tree
*cond_p
, tree body
)
537 if (!TREE_SIDE_EFFECTS (body
))
541 *cond_p
= boolean_true_node
;
543 if_stmt
= begin_if_stmt ();
544 cond
= cp_build_unary_op (TRUTH_NOT_EXPR
, cond
, 0, tf_warning_or_error
);
545 finish_if_stmt_cond (cond
, if_stmt
);
546 finish_break_stmt ();
547 finish_then_clause (if_stmt
);
548 finish_if_stmt (if_stmt
);
551 /* Finish a goto-statement. */
554 finish_goto_stmt (tree destination
)
556 if (TREE_CODE (destination
) == IDENTIFIER_NODE
)
557 destination
= lookup_label (destination
);
559 /* We warn about unused labels with -Wunused. That means we have to
560 mark the used labels as used. */
561 if (TREE_CODE (destination
) == LABEL_DECL
)
562 TREE_USED (destination
) = 1;
565 destination
= mark_rvalue_use (destination
);
566 if (!processing_template_decl
)
568 destination
= cp_convert (ptr_type_node
, destination
);
569 if (error_operand_p (destination
))
572 /* We don't inline calls to functions with computed gotos.
573 Those functions are typically up to some funny business,
574 and may be depending on the labels being at particular
575 addresses, or some such. */
576 DECL_UNINLINABLE (current_function_decl
) = 1;
579 check_goto (destination
);
581 return add_stmt (build_stmt (input_location
, GOTO_EXPR
, destination
));
584 /* COND is the condition-expression for an if, while, etc.,
585 statement. Convert it to a boolean value, if appropriate.
586 In addition, verify sequence points if -Wsequence-point is enabled. */
589 maybe_convert_cond (tree cond
)
591 /* Empty conditions remain empty. */
595 /* Wait until we instantiate templates before doing conversion. */
596 if (processing_template_decl
)
599 if (warn_sequence_point
)
600 verify_sequence_points (cond
);
602 /* Do the conversion. */
603 cond
= convert_from_reference (cond
);
605 if (TREE_CODE (cond
) == MODIFY_EXPR
606 && !TREE_NO_WARNING (cond
)
609 warning (OPT_Wparentheses
,
610 "suggest parentheses around assignment used as truth value");
611 TREE_NO_WARNING (cond
) = 1;
614 return condition_conversion (cond
);
617 /* Finish an expression-statement, whose EXPRESSION is as indicated. */
620 finish_expr_stmt (tree expr
)
624 if (expr
!= NULL_TREE
)
626 if (!processing_template_decl
)
628 if (warn_sequence_point
)
629 verify_sequence_points (expr
);
630 expr
= convert_to_void (expr
, ICV_STATEMENT
, tf_warning_or_error
);
632 else if (!type_dependent_expression_p (expr
))
633 convert_to_void (build_non_dependent_expr (expr
), ICV_STATEMENT
,
634 tf_warning_or_error
);
636 if (check_for_bare_parameter_packs (expr
))
637 expr
= error_mark_node
;
639 /* Simplification of inner statement expressions, compound exprs,
640 etc can result in us already having an EXPR_STMT. */
641 if (TREE_CODE (expr
) != CLEANUP_POINT_EXPR
)
643 if (TREE_CODE (expr
) != EXPR_STMT
)
644 expr
= build_stmt (input_location
, EXPR_STMT
, expr
);
645 expr
= maybe_cleanup_point_expr_void (expr
);
657 /* Begin an if-statement. Returns a newly created IF_STMT if
664 scope
= do_pushlevel (sk_block
);
665 r
= build_stmt (input_location
, IF_STMT
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
666 TREE_CHAIN (r
) = scope
;
667 begin_cond (&IF_COND (r
));
671 /* Process the COND of an if-statement, which may be given by
675 finish_if_stmt_cond (tree cond
, tree if_stmt
)
677 finish_cond (&IF_COND (if_stmt
), maybe_convert_cond (cond
));
679 THEN_CLAUSE (if_stmt
) = push_stmt_list ();
682 /* Finish the then-clause of an if-statement, which may be given by
686 finish_then_clause (tree if_stmt
)
688 THEN_CLAUSE (if_stmt
) = pop_stmt_list (THEN_CLAUSE (if_stmt
));
692 /* Begin the else-clause of an if-statement. */
695 begin_else_clause (tree if_stmt
)
697 ELSE_CLAUSE (if_stmt
) = push_stmt_list ();
700 /* Finish the else-clause of an if-statement, which may be given by
704 finish_else_clause (tree if_stmt
)
706 ELSE_CLAUSE (if_stmt
) = pop_stmt_list (ELSE_CLAUSE (if_stmt
));
709 /* Finish an if-statement. */
712 finish_if_stmt (tree if_stmt
)
714 tree scope
= TREE_CHAIN (if_stmt
);
715 TREE_CHAIN (if_stmt
) = NULL
;
716 add_stmt (do_poplevel (scope
));
720 /* Begin a while-statement. Returns a newly created WHILE_STMT if
724 begin_while_stmt (void)
727 r
= build_stmt (input_location
, WHILE_STMT
, NULL_TREE
, NULL_TREE
);
729 WHILE_BODY (r
) = do_pushlevel (sk_block
);
730 begin_cond (&WHILE_COND (r
));
734 /* Process the COND of a while-statement, which may be given by
738 finish_while_stmt_cond (tree cond
, tree while_stmt
)
740 finish_cond (&WHILE_COND (while_stmt
), maybe_convert_cond (cond
));
741 simplify_loop_decl_cond (&WHILE_COND (while_stmt
), WHILE_BODY (while_stmt
));
744 /* Finish a while-statement, which may be given by WHILE_STMT. */
747 finish_while_stmt (tree while_stmt
)
749 WHILE_BODY (while_stmt
) = do_poplevel (WHILE_BODY (while_stmt
));
753 /* Begin a do-statement. Returns a newly created DO_STMT if
759 tree r
= build_stmt (input_location
, DO_STMT
, NULL_TREE
, NULL_TREE
);
761 DO_BODY (r
) = push_stmt_list ();
765 /* Finish the body of a do-statement, which may be given by DO_STMT. */
768 finish_do_body (tree do_stmt
)
770 tree body
= DO_BODY (do_stmt
) = pop_stmt_list (DO_BODY (do_stmt
));
772 if (TREE_CODE (body
) == STATEMENT_LIST
&& STATEMENT_LIST_TAIL (body
))
773 body
= STATEMENT_LIST_TAIL (body
)->stmt
;
775 if (IS_EMPTY_STMT (body
))
776 warning (OPT_Wempty_body
,
777 "suggest explicit braces around empty body in %<do%> statement");
780 /* Finish a do-statement, which may be given by DO_STMT, and whose
781 COND is as indicated. */
784 finish_do_stmt (tree cond
, tree do_stmt
)
786 cond
= maybe_convert_cond (cond
);
787 DO_COND (do_stmt
) = cond
;
791 /* Finish a return-statement. The EXPRESSION returned, if any, is as
795 finish_return_stmt (tree expr
)
800 expr
= check_return_expr (expr
, &no_warning
);
802 if (flag_openmp
&& !check_omp_return ())
803 return error_mark_node
;
804 if (!processing_template_decl
)
806 if (warn_sequence_point
)
807 verify_sequence_points (expr
);
809 if (DECL_DESTRUCTOR_P (current_function_decl
)
810 || (DECL_CONSTRUCTOR_P (current_function_decl
)
811 && targetm
.cxx
.cdtor_returns_this ()))
813 /* Similarly, all destructors must run destructors for
814 base-classes before returning. So, all returns in a
815 destructor get sent to the DTOR_LABEL; finish_function emits
816 code to return a value there. */
817 return finish_goto_stmt (cdtor_label
);
821 r
= build_stmt (input_location
, RETURN_EXPR
, expr
);
822 TREE_NO_WARNING (r
) |= no_warning
;
823 r
= maybe_cleanup_point_expr_void (r
);
830 /* Begin the scope of a for-statement or a range-for-statement.
831 Both the returned trees are to be used in a call to
832 begin_for_stmt or begin_range_for_stmt. */
835 begin_for_scope (tree
*init
)
837 tree scope
= NULL_TREE
;
838 if (flag_new_for_scope
> 0)
839 scope
= do_pushlevel (sk_for
);
841 if (processing_template_decl
)
842 *init
= push_stmt_list ();
849 /* Begin a for-statement. Returns a new FOR_STMT.
850 SCOPE and INIT should be the return of begin_for_scope,
854 begin_for_stmt (tree scope
, tree init
)
858 r
= build_stmt (input_location
, FOR_STMT
, NULL_TREE
, NULL_TREE
,
859 NULL_TREE
, NULL_TREE
);
861 if (scope
== NULL_TREE
)
863 gcc_assert (!init
|| !(flag_new_for_scope
> 0));
865 scope
= begin_for_scope (&init
);
867 FOR_INIT_STMT (r
) = init
;
868 TREE_CHAIN (r
) = scope
;
873 /* Finish the for-init-statement of a for-statement, which may be
874 given by FOR_STMT. */
877 finish_for_init_stmt (tree for_stmt
)
879 if (processing_template_decl
)
880 FOR_INIT_STMT (for_stmt
) = pop_stmt_list (FOR_INIT_STMT (for_stmt
));
882 FOR_BODY (for_stmt
) = do_pushlevel (sk_block
);
883 begin_cond (&FOR_COND (for_stmt
));
886 /* Finish the COND of a for-statement, which may be given by
890 finish_for_cond (tree cond
, tree for_stmt
)
892 finish_cond (&FOR_COND (for_stmt
), maybe_convert_cond (cond
));
893 simplify_loop_decl_cond (&FOR_COND (for_stmt
), FOR_BODY (for_stmt
));
896 /* Finish the increment-EXPRESSION in a for-statement, which may be
897 given by FOR_STMT. */
900 finish_for_expr (tree expr
, tree for_stmt
)
904 /* If EXPR is an overloaded function, issue an error; there is no
905 context available to use to perform overload resolution. */
906 if (type_unknown_p (expr
))
908 cxx_incomplete_type_error (expr
, TREE_TYPE (expr
));
909 expr
= error_mark_node
;
911 if (!processing_template_decl
)
913 if (warn_sequence_point
)
914 verify_sequence_points (expr
);
915 expr
= convert_to_void (expr
, ICV_THIRD_IN_FOR
,
916 tf_warning_or_error
);
918 else if (!type_dependent_expression_p (expr
))
919 convert_to_void (build_non_dependent_expr (expr
), ICV_THIRD_IN_FOR
,
920 tf_warning_or_error
);
921 expr
= maybe_cleanup_point_expr_void (expr
);
922 if (check_for_bare_parameter_packs (expr
))
923 expr
= error_mark_node
;
924 FOR_EXPR (for_stmt
) = expr
;
927 /* Finish the body of a for-statement, which may be given by
928 FOR_STMT. The increment-EXPR for the loop must be
930 It can also finish RANGE_FOR_STMT. */
933 finish_for_stmt (tree for_stmt
)
935 if (TREE_CODE (for_stmt
) == RANGE_FOR_STMT
)
936 RANGE_FOR_BODY (for_stmt
) = do_poplevel (RANGE_FOR_BODY (for_stmt
));
938 FOR_BODY (for_stmt
) = do_poplevel (FOR_BODY (for_stmt
));
940 /* Pop the scope for the body of the loop. */
941 if (flag_new_for_scope
> 0)
943 tree scope
= TREE_CHAIN (for_stmt
);
944 TREE_CHAIN (for_stmt
) = NULL
;
945 add_stmt (do_poplevel (scope
));
951 /* Begin a range-for-statement. Returns a new RANGE_FOR_STMT.
952 SCOPE and INIT should be the return of begin_for_scope,
954 To finish it call finish_for_stmt(). */
957 begin_range_for_stmt (tree scope
, tree init
)
961 r
= build_stmt (input_location
, RANGE_FOR_STMT
,
962 NULL_TREE
, NULL_TREE
, NULL_TREE
);
964 if (scope
== NULL_TREE
)
966 gcc_assert (!init
|| !(flag_new_for_scope
> 0));
968 scope
= begin_for_scope (&init
);
971 /* RANGE_FOR_STMTs do not use nor save the init tree, so we
974 pop_stmt_list (init
);
975 TREE_CHAIN (r
) = scope
;
980 /* Finish the head of a range-based for statement, which may
981 be given by RANGE_FOR_STMT. DECL must be the declaration
982 and EXPR must be the loop expression. */
985 finish_range_for_decl (tree range_for_stmt
, tree decl
, tree expr
)
987 RANGE_FOR_DECL (range_for_stmt
) = decl
;
988 RANGE_FOR_EXPR (range_for_stmt
) = expr
;
989 add_stmt (range_for_stmt
);
990 RANGE_FOR_BODY (range_for_stmt
) = do_pushlevel (sk_block
);
993 /* Finish a break-statement. */
996 finish_break_stmt (void)
998 return add_stmt (build_stmt (input_location
, BREAK_STMT
));
1001 /* Finish a continue-statement. */
1004 finish_continue_stmt (void)
1006 return add_stmt (build_stmt (input_location
, CONTINUE_STMT
));
1009 /* Begin a switch-statement. Returns a new SWITCH_STMT if
1013 begin_switch_stmt (void)
1017 r
= build_stmt (input_location
, SWITCH_STMT
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
1019 scope
= do_pushlevel (sk_block
);
1020 TREE_CHAIN (r
) = scope
;
1021 begin_cond (&SWITCH_STMT_COND (r
));
1026 /* Finish the cond of a switch-statement. */
1029 finish_switch_cond (tree cond
, tree switch_stmt
)
1031 tree orig_type
= NULL
;
1032 if (!processing_template_decl
)
1034 /* Convert the condition to an integer or enumeration type. */
1035 cond
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
, cond
, true);
1036 if (cond
== NULL_TREE
)
1038 error ("switch quantity not an integer");
1039 cond
= error_mark_node
;
1041 orig_type
= TREE_TYPE (cond
);
1042 if (cond
!= error_mark_node
)
1046 Integral promotions are performed. */
1047 cond
= perform_integral_promotions (cond
);
1048 cond
= maybe_cleanup_point_expr (cond
);
1051 if (check_for_bare_parameter_packs (cond
))
1052 cond
= error_mark_node
;
1053 else if (!processing_template_decl
&& warn_sequence_point
)
1054 verify_sequence_points (cond
);
1056 finish_cond (&SWITCH_STMT_COND (switch_stmt
), cond
);
1057 SWITCH_STMT_TYPE (switch_stmt
) = orig_type
;
1058 add_stmt (switch_stmt
);
1059 push_switch (switch_stmt
);
1060 SWITCH_STMT_BODY (switch_stmt
) = push_stmt_list ();
1063 /* Finish the body of a switch-statement, which may be given by
1064 SWITCH_STMT. The COND to switch on is indicated. */
1067 finish_switch_stmt (tree switch_stmt
)
1071 SWITCH_STMT_BODY (switch_stmt
) =
1072 pop_stmt_list (SWITCH_STMT_BODY (switch_stmt
));
1076 scope
= TREE_CHAIN (switch_stmt
);
1077 TREE_CHAIN (switch_stmt
) = NULL
;
1078 add_stmt (do_poplevel (scope
));
1081 /* Begin a try-block. Returns a newly-created TRY_BLOCK if
1085 begin_try_block (void)
1087 tree r
= build_stmt (input_location
, TRY_BLOCK
, NULL_TREE
, NULL_TREE
);
1089 TRY_STMTS (r
) = push_stmt_list ();
1093 /* Likewise, for a function-try-block. The block returned in
1094 *COMPOUND_STMT is an artificial outer scope, containing the
1095 function-try-block. */
1098 begin_function_try_block (tree
*compound_stmt
)
1101 /* This outer scope does not exist in the C++ standard, but we need
1102 a place to put __FUNCTION__ and similar variables. */
1103 *compound_stmt
= begin_compound_stmt (0);
1104 r
= begin_try_block ();
1105 FN_TRY_BLOCK_P (r
) = 1;
1109 /* Finish a try-block, which may be given by TRY_BLOCK. */
1112 finish_try_block (tree try_block
)
1114 TRY_STMTS (try_block
) = pop_stmt_list (TRY_STMTS (try_block
));
1115 TRY_HANDLERS (try_block
) = push_stmt_list ();
1118 /* Finish the body of a cleanup try-block, which may be given by
1122 finish_cleanup_try_block (tree try_block
)
1124 TRY_STMTS (try_block
) = pop_stmt_list (TRY_STMTS (try_block
));
1127 /* Finish an implicitly generated try-block, with a cleanup is given
1131 finish_cleanup (tree cleanup
, tree try_block
)
1133 TRY_HANDLERS (try_block
) = cleanup
;
1134 CLEANUP_P (try_block
) = 1;
1137 /* Likewise, for a function-try-block. */
1140 finish_function_try_block (tree try_block
)
1142 finish_try_block (try_block
);
1143 /* FIXME : something queer about CTOR_INITIALIZER somehow following
1144 the try block, but moving it inside. */
1145 in_function_try_handler
= 1;
1148 /* Finish a handler-sequence for a try-block, which may be given by
1152 finish_handler_sequence (tree try_block
)
1154 TRY_HANDLERS (try_block
) = pop_stmt_list (TRY_HANDLERS (try_block
));
1155 check_handlers (TRY_HANDLERS (try_block
));
1158 /* Finish the handler-seq for a function-try-block, given by
1159 TRY_BLOCK. COMPOUND_STMT is the outer block created by
1160 begin_function_try_block. */
1163 finish_function_handler_sequence (tree try_block
, tree compound_stmt
)
1165 in_function_try_handler
= 0;
1166 finish_handler_sequence (try_block
);
1167 finish_compound_stmt (compound_stmt
);
1170 /* Begin a handler. Returns a HANDLER if appropriate. */
1173 begin_handler (void)
1177 r
= build_stmt (input_location
, HANDLER
, NULL_TREE
, NULL_TREE
);
1180 /* Create a binding level for the eh_info and the exception object
1182 HANDLER_BODY (r
) = do_pushlevel (sk_catch
);
1187 /* Finish the handler-parameters for a handler, which may be given by
1188 HANDLER. DECL is the declaration for the catch parameter, or NULL
1189 if this is a `catch (...)' clause. */
1192 finish_handler_parms (tree decl
, tree handler
)
1194 tree type
= NULL_TREE
;
1195 if (processing_template_decl
)
1199 decl
= pushdecl (decl
);
1200 decl
= push_template_decl (decl
);
1201 HANDLER_PARMS (handler
) = decl
;
1202 type
= TREE_TYPE (decl
);
1206 type
= expand_start_catch_block (decl
);
1207 HANDLER_TYPE (handler
) = type
;
1208 if (!processing_template_decl
&& type
)
1209 mark_used (eh_type_info (type
));
1212 /* Finish a handler, which may be given by HANDLER. The BLOCKs are
1213 the return value from the matching call to finish_handler_parms. */
1216 finish_handler (tree handler
)
1218 if (!processing_template_decl
)
1219 expand_end_catch_block ();
1220 HANDLER_BODY (handler
) = do_poplevel (HANDLER_BODY (handler
));
1223 /* Begin a compound statement. FLAGS contains some bits that control the
1224 behavior and context. If BCS_NO_SCOPE is set, the compound statement
1225 does not define a scope. If BCS_FN_BODY is set, this is the outermost
1226 block of a function. If BCS_TRY_BLOCK is set, this is the block
1227 created on behalf of a TRY statement. Returns a token to be passed to
1228 finish_compound_stmt. */
1231 begin_compound_stmt (unsigned int flags
)
1235 if (flags
& BCS_NO_SCOPE
)
1237 r
= push_stmt_list ();
1238 STATEMENT_LIST_NO_SCOPE (r
) = 1;
1240 /* Normally, we try hard to keep the BLOCK for a statement-expression.
1241 But, if it's a statement-expression with a scopeless block, there's
1242 nothing to keep, and we don't want to accidentally keep a block
1243 *inside* the scopeless block. */
1244 keep_next_level (false);
1247 r
= do_pushlevel (flags
& BCS_TRY_BLOCK
? sk_try
: sk_block
);
1249 /* When processing a template, we need to remember where the braces were,
1250 so that we can set up identical scopes when instantiating the template
1251 later. BIND_EXPR is a handy candidate for this.
1252 Note that do_poplevel won't create a BIND_EXPR itself here (and thus
1253 result in nested BIND_EXPRs), since we don't build BLOCK nodes when
1254 processing templates. */
1255 if (processing_template_decl
)
1257 r
= build3 (BIND_EXPR
, NULL
, NULL
, r
, NULL
);
1258 BIND_EXPR_TRY_BLOCK (r
) = (flags
& BCS_TRY_BLOCK
) != 0;
1259 BIND_EXPR_BODY_BLOCK (r
) = (flags
& BCS_FN_BODY
) != 0;
1260 TREE_SIDE_EFFECTS (r
) = 1;
1266 /* Finish a compound-statement, which is given by STMT. */
1269 finish_compound_stmt (tree stmt
)
1271 if (TREE_CODE (stmt
) == BIND_EXPR
)
1273 tree body
= do_poplevel (BIND_EXPR_BODY (stmt
));
1274 /* If the STATEMENT_LIST is empty and this BIND_EXPR isn't special,
1275 discard the BIND_EXPR so it can be merged with the containing
1277 if (TREE_CODE (body
) == STATEMENT_LIST
1278 && STATEMENT_LIST_HEAD (body
) == NULL
1279 && !BIND_EXPR_BODY_BLOCK (stmt
)
1280 && !BIND_EXPR_TRY_BLOCK (stmt
))
1283 BIND_EXPR_BODY (stmt
) = body
;
1285 else if (STATEMENT_LIST_NO_SCOPE (stmt
))
1286 stmt
= pop_stmt_list (stmt
);
1289 /* Destroy any ObjC "super" receivers that may have been
1291 objc_clear_super_receiver ();
1293 stmt
= do_poplevel (stmt
);
1296 /* ??? See c_end_compound_stmt wrt statement expressions. */
1301 /* Finish an asm-statement, whose components are a STRING, some
1302 OUTPUT_OPERANDS, some INPUT_OPERANDS, some CLOBBERS and some
1303 LABELS. Also note whether the asm-statement should be
1304 considered volatile. */
1307 finish_asm_stmt (int volatile_p
, tree string
, tree output_operands
,
1308 tree input_operands
, tree clobbers
, tree labels
)
1312 int ninputs
= list_length (input_operands
);
1313 int noutputs
= list_length (output_operands
);
1315 if (!processing_template_decl
)
1317 const char *constraint
;
1318 const char **oconstraints
;
1319 bool allows_mem
, allows_reg
, is_inout
;
1323 oconstraints
= XALLOCAVEC (const char *, noutputs
);
1325 string
= resolve_asm_operand_names (string
, output_operands
,
1326 input_operands
, labels
);
1328 for (i
= 0, t
= output_operands
; t
; t
= TREE_CHAIN (t
), ++i
)
1330 operand
= TREE_VALUE (t
);
1332 /* ??? Really, this should not be here. Users should be using a
1333 proper lvalue, dammit. But there's a long history of using
1334 casts in the output operands. In cases like longlong.h, this
1335 becomes a primitive form of typechecking -- if the cast can be
1336 removed, then the output operand had a type of the proper width;
1337 otherwise we'll get an error. Gross, but ... */
1338 STRIP_NOPS (operand
);
1340 operand
= mark_lvalue_use (operand
);
1342 if (!lvalue_or_else (operand
, lv_asm
, tf_warning_or_error
))
1343 operand
= error_mark_node
;
1345 if (operand
!= error_mark_node
1346 && (TREE_READONLY (operand
)
1347 || CP_TYPE_CONST_P (TREE_TYPE (operand
))
1348 /* Functions are not modifiable, even though they are
1350 || TREE_CODE (TREE_TYPE (operand
)) == FUNCTION_TYPE
1351 || TREE_CODE (TREE_TYPE (operand
)) == METHOD_TYPE
1352 /* If it's an aggregate and any field is const, then it is
1353 effectively const. */
1354 || (CLASS_TYPE_P (TREE_TYPE (operand
))
1355 && C_TYPE_FIELDS_READONLY (TREE_TYPE (operand
)))))
1356 cxx_readonly_error (operand
, lv_asm
);
1358 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
1359 oconstraints
[i
] = constraint
;
1361 if (parse_output_constraint (&constraint
, i
, ninputs
, noutputs
,
1362 &allows_mem
, &allows_reg
, &is_inout
))
1364 /* If the operand is going to end up in memory,
1365 mark it addressable. */
1366 if (!allows_reg
&& !cxx_mark_addressable (operand
))
1367 operand
= error_mark_node
;
1370 operand
= error_mark_node
;
1372 TREE_VALUE (t
) = operand
;
1375 for (i
= 0, t
= input_operands
; t
; ++i
, t
= TREE_CHAIN (t
))
1377 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
1378 operand
= decay_conversion (TREE_VALUE (t
));
1380 /* If the type of the operand hasn't been determined (e.g.,
1381 because it involves an overloaded function), then issue
1382 an error message. There's no context available to
1383 resolve the overloading. */
1384 if (TREE_TYPE (operand
) == unknown_type_node
)
1386 error ("type of asm operand %qE could not be determined",
1388 operand
= error_mark_node
;
1391 if (parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, 0,
1392 oconstraints
, &allows_mem
, &allows_reg
))
1394 /* If the operand is going to end up in memory,
1395 mark it addressable. */
1396 if (!allows_reg
&& allows_mem
)
1398 /* Strip the nops as we allow this case. FIXME, this really
1399 should be rejected or made deprecated. */
1400 STRIP_NOPS (operand
);
1401 if (!cxx_mark_addressable (operand
))
1402 operand
= error_mark_node
;
1406 operand
= error_mark_node
;
1408 TREE_VALUE (t
) = operand
;
1412 r
= build_stmt (input_location
, ASM_EXPR
, string
,
1413 output_operands
, input_operands
,
1415 ASM_VOLATILE_P (r
) = volatile_p
|| noutputs
== 0;
1416 r
= maybe_cleanup_point_expr_void (r
);
1417 return add_stmt (r
);
1420 /* Finish a label with the indicated NAME. Returns the new label. */
1423 finish_label_stmt (tree name
)
1425 tree decl
= define_label (input_location
, name
);
1427 if (decl
== error_mark_node
)
1428 return error_mark_node
;
1430 add_stmt (build_stmt (input_location
, LABEL_EXPR
, decl
));
1435 /* Finish a series of declarations for local labels. G++ allows users
1436 to declare "local" labels, i.e., labels with scope. This extension
1437 is useful when writing code involving statement-expressions. */
1440 finish_label_decl (tree name
)
1442 if (!at_function_scope_p ())
1444 error ("__label__ declarations are only allowed in function scopes");
1448 add_decl_expr (declare_local_label (name
));
1451 /* When DECL goes out of scope, make sure that CLEANUP is executed. */
1454 finish_decl_cleanup (tree decl
, tree cleanup
)
1456 push_cleanup (decl
, cleanup
, false);
1459 /* If the current scope exits with an exception, run CLEANUP. */
1462 finish_eh_cleanup (tree cleanup
)
1464 push_cleanup (NULL
, cleanup
, true);
1467 /* The MEM_INITS is a list of mem-initializers, in reverse of the
1468 order they were written by the user. Each node is as for
1469 emit_mem_initializers. */
1472 finish_mem_initializers (tree mem_inits
)
1474 /* Reorder the MEM_INITS so that they are in the order they appeared
1475 in the source program. */
1476 mem_inits
= nreverse (mem_inits
);
1478 if (processing_template_decl
)
1482 for (mem
= mem_inits
; mem
; mem
= TREE_CHAIN (mem
))
1484 /* If the TREE_PURPOSE is a TYPE_PACK_EXPANSION, skip the
1485 check for bare parameter packs in the TREE_VALUE, because
1486 any parameter packs in the TREE_VALUE have already been
1487 bound as part of the TREE_PURPOSE. See
1488 make_pack_expansion for more information. */
1489 if (TREE_CODE (TREE_PURPOSE (mem
)) != TYPE_PACK_EXPANSION
1490 && check_for_bare_parameter_packs (TREE_VALUE (mem
)))
1491 TREE_VALUE (mem
) = error_mark_node
;
1494 add_stmt (build_min_nt (CTOR_INITIALIZER
, mem_inits
));
1497 emit_mem_initializers (mem_inits
);
1500 /* Finish a parenthesized expression EXPR. */
1503 finish_parenthesized_expr (tree expr
)
1506 /* This inhibits warnings in c_common_truthvalue_conversion. */
1507 TREE_NO_WARNING (expr
) = 1;
1509 if (TREE_CODE (expr
) == OFFSET_REF
)
1510 /* [expr.unary.op]/3 The qualified id of a pointer-to-member must not be
1511 enclosed in parentheses. */
1512 PTRMEM_OK_P (expr
) = 0;
1514 if (TREE_CODE (expr
) == STRING_CST
)
1515 PAREN_STRING_LITERAL_P (expr
) = 1;
1520 /* Finish a reference to a non-static data member (DECL) that is not
1521 preceded by `.' or `->'. */
1524 finish_non_static_data_member (tree decl
, tree object
, tree qualifying_scope
)
1526 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
);
1530 tree scope
= qualifying_scope
;
1531 if (scope
== NULL_TREE
)
1532 scope
= context_for_name_lookup (decl
);
1533 object
= maybe_dummy_object (scope
, NULL
);
1536 if (object
== error_mark_node
)
1537 return error_mark_node
;
1539 /* DR 613: Can use non-static data members without an associated
1540 object in sizeof/decltype/alignof. */
1541 if (is_dummy_object (object
) && cp_unevaluated_operand
== 0
1542 && (!processing_template_decl
|| !current_class_ref
))
1544 if (current_function_decl
1545 && DECL_STATIC_FUNCTION_P (current_function_decl
))
1546 error ("invalid use of member %q+D in static member function", decl
);
1548 error ("invalid use of non-static data member %q+D", decl
);
1549 error ("from this location");
1551 return error_mark_node
;
1554 if (current_class_ptr
)
1555 TREE_USED (current_class_ptr
) = 1;
1556 if (processing_template_decl
&& !qualifying_scope
)
1558 tree type
= TREE_TYPE (decl
);
1560 if (TREE_CODE (type
) == REFERENCE_TYPE
)
1561 type
= TREE_TYPE (type
);
1564 /* Set the cv qualifiers. */
1565 int quals
= (current_class_ref
1566 ? cp_type_quals (TREE_TYPE (current_class_ref
))
1567 : TYPE_UNQUALIFIED
);
1569 if (DECL_MUTABLE_P (decl
))
1570 quals
&= ~TYPE_QUAL_CONST
;
1572 quals
|= cp_type_quals (TREE_TYPE (decl
));
1573 type
= cp_build_qualified_type (type
, quals
);
1576 return build_min (COMPONENT_REF
, type
, object
, decl
, NULL_TREE
);
1578 /* If PROCESSING_TEMPLATE_DECL is nonzero here, then
1579 QUALIFYING_SCOPE is also non-null. Wrap this in a SCOPE_REF
1581 else if (processing_template_decl
)
1582 return build_qualified_name (TREE_TYPE (decl
),
1585 /*template_p=*/false);
1588 tree access_type
= TREE_TYPE (object
);
1590 perform_or_defer_access_check (TYPE_BINFO (access_type
), decl
,
1593 /* If the data member was named `C::M', convert `*this' to `C'
1595 if (qualifying_scope
)
1597 tree binfo
= NULL_TREE
;
1598 object
= build_scoped_ref (object
, qualifying_scope
,
1602 return build_class_member_access_expr (object
, decl
,
1603 /*access_path=*/NULL_TREE
,
1604 /*preserve_reference=*/false,
1605 tf_warning_or_error
);
1609 /* If we are currently parsing a template and we encountered a typedef
1610 TYPEDEF_DECL that is being accessed though CONTEXT, this function
1611 adds the typedef to a list tied to the current template.
1612 At tempate instantiatin time, that list is walked and access check
1613 performed for each typedef.
1614 LOCATION is the location of the usage point of TYPEDEF_DECL. */
1617 add_typedef_to_current_template_for_access_check (tree typedef_decl
,
1619 location_t location
)
1621 tree template_info
= NULL
;
1622 tree cs
= current_scope ();
1624 if (!is_typedef_decl (typedef_decl
)
1626 || !CLASS_TYPE_P (context
)
1630 if (CLASS_TYPE_P (cs
) || TREE_CODE (cs
) == FUNCTION_DECL
)
1631 template_info
= get_template_info (cs
);
1634 && TI_TEMPLATE (template_info
)
1635 && !currently_open_class (context
))
1636 append_type_to_template_for_access_check (cs
, typedef_decl
,
1640 /* DECL was the declaration to which a qualified-id resolved. Issue
1641 an error message if it is not accessible. If OBJECT_TYPE is
1642 non-NULL, we have just seen `x->' or `x.' and OBJECT_TYPE is the
1643 type of `*x', or `x', respectively. If the DECL was named as
1644 `A::B' then NESTED_NAME_SPECIFIER is `A'. */
1647 check_accessibility_of_qualified_id (tree decl
,
1649 tree nested_name_specifier
)
1652 tree qualifying_type
= NULL_TREE
;
1654 /* If we are parsing a template declaration and if decl is a typedef,
1655 add it to a list tied to the template.
1656 At template instantiation time, that list will be walked and
1657 access check performed. */
1658 add_typedef_to_current_template_for_access_check (decl
,
1659 nested_name_specifier
1660 ? nested_name_specifier
1661 : DECL_CONTEXT (decl
),
1664 /* If we're not checking, return immediately. */
1665 if (deferred_access_no_check
)
1668 /* Determine the SCOPE of DECL. */
1669 scope
= context_for_name_lookup (decl
);
1670 /* If the SCOPE is not a type, then DECL is not a member. */
1671 if (!TYPE_P (scope
))
1673 /* Compute the scope through which DECL is being accessed. */
1675 /* OBJECT_TYPE might not be a class type; consider:
1677 class A { typedef int I; };
1681 In this case, we will have "A::I" as the DECL, but "I" as the
1683 && CLASS_TYPE_P (object_type
)
1684 && DERIVED_FROM_P (scope
, object_type
))
1685 /* If we are processing a `->' or `.' expression, use the type of the
1687 qualifying_type
= object_type
;
1688 else if (nested_name_specifier
)
1690 /* If the reference is to a non-static member of the
1691 current class, treat it as if it were referenced through
1693 if (DECL_NONSTATIC_MEMBER_P (decl
)
1694 && current_class_ptr
1695 && DERIVED_FROM_P (scope
, current_class_type
))
1696 qualifying_type
= current_class_type
;
1697 /* Otherwise, use the type indicated by the
1698 nested-name-specifier. */
1700 qualifying_type
= nested_name_specifier
;
1703 /* Otherwise, the name must be from the current class or one of
1705 qualifying_type
= currently_open_derived_class (scope
);
1708 /* It is possible for qualifying type to be a TEMPLATE_TYPE_PARM
1709 or similar in a default argument value. */
1710 && CLASS_TYPE_P (qualifying_type
)
1711 && !dependent_type_p (qualifying_type
))
1712 perform_or_defer_access_check (TYPE_BINFO (qualifying_type
), decl
,
1716 /* EXPR is the result of a qualified-id. The QUALIFYING_CLASS was the
1717 class named to the left of the "::" operator. DONE is true if this
1718 expression is a complete postfix-expression; it is false if this
1719 expression is followed by '->', '[', '(', etc. ADDRESS_P is true
1720 iff this expression is the operand of '&'. TEMPLATE_P is true iff
1721 the qualified-id was of the form "A::template B". TEMPLATE_ARG_P
1722 is true iff this qualified name appears as a template argument. */
1725 finish_qualified_id_expr (tree qualifying_class
,
1730 bool template_arg_p
)
1732 gcc_assert (TYPE_P (qualifying_class
));
1734 if (error_operand_p (expr
))
1735 return error_mark_node
;
1737 if (DECL_P (expr
) || BASELINK_P (expr
))
1741 check_template_keyword (expr
);
1743 /* If EXPR occurs as the operand of '&', use special handling that
1744 permits a pointer-to-member. */
1745 if (address_p
&& done
)
1747 if (TREE_CODE (expr
) == SCOPE_REF
)
1748 expr
= TREE_OPERAND (expr
, 1);
1749 expr
= build_offset_ref (qualifying_class
, expr
,
1750 /*address_p=*/true);
1754 /* Within the scope of a class, turn references to non-static
1755 members into expression of the form "this->...". */
1757 /* But, within a template argument, we do not want make the
1758 transformation, as there is no "this" pointer. */
1760 else if (TREE_CODE (expr
) == FIELD_DECL
)
1762 push_deferring_access_checks (dk_no_check
);
1763 expr
= finish_non_static_data_member (expr
, NULL_TREE
,
1765 pop_deferring_access_checks ();
1767 else if (BASELINK_P (expr
) && !processing_template_decl
)
1771 /* See if any of the functions are non-static members. */
1772 /* If so, the expression may be relative to 'this'. */
1773 if (!shared_member_p (expr
)
1774 && (ob
= maybe_dummy_object (qualifying_class
, NULL
),
1775 !is_dummy_object (ob
)))
1776 expr
= (build_class_member_access_expr
1779 BASELINK_ACCESS_BINFO (expr
),
1780 /*preserve_reference=*/false,
1781 tf_warning_or_error
));
1783 /* The expression is a qualified name whose address is not
1785 expr
= build_offset_ref (qualifying_class
, expr
, /*address_p=*/false);
1791 /* Begin a statement-expression. The value returned must be passed to
1792 finish_stmt_expr. */
1795 begin_stmt_expr (void)
1797 return push_stmt_list ();
1800 /* Process the final expression of a statement expression. EXPR can be
1801 NULL, if the final expression is empty. Return a STATEMENT_LIST
1802 containing all the statements in the statement-expression, or
1803 ERROR_MARK_NODE if there was an error. */
1806 finish_stmt_expr_expr (tree expr
, tree stmt_expr
)
1808 if (error_operand_p (expr
))
1810 /* The type of the statement-expression is the type of the last
1812 TREE_TYPE (stmt_expr
) = error_mark_node
;
1813 return error_mark_node
;
1816 /* If the last statement does not have "void" type, then the value
1817 of the last statement is the value of the entire expression. */
1820 tree type
= TREE_TYPE (expr
);
1822 if (processing_template_decl
)
1824 expr
= build_stmt (input_location
, EXPR_STMT
, expr
);
1825 expr
= add_stmt (expr
);
1826 /* Mark the last statement so that we can recognize it as such at
1827 template-instantiation time. */
1828 EXPR_STMT_STMT_EXPR_RESULT (expr
) = 1;
1830 else if (VOID_TYPE_P (type
))
1832 /* Just treat this like an ordinary statement. */
1833 expr
= finish_expr_stmt (expr
);
1837 /* It actually has a value we need to deal with. First, force it
1838 to be an rvalue so that we won't need to build up a copy
1839 constructor call later when we try to assign it to something. */
1840 expr
= force_rvalue (expr
);
1841 if (error_operand_p (expr
))
1842 return error_mark_node
;
1844 /* Update for array-to-pointer decay. */
1845 type
= TREE_TYPE (expr
);
1847 /* Wrap it in a CLEANUP_POINT_EXPR and add it to the list like a
1848 normal statement, but don't convert to void or actually add
1850 if (TREE_CODE (expr
) != CLEANUP_POINT_EXPR
)
1851 expr
= maybe_cleanup_point_expr (expr
);
1855 /* The type of the statement-expression is the type of the last
1857 TREE_TYPE (stmt_expr
) = type
;
1863 /* Finish a statement-expression. EXPR should be the value returned
1864 by the previous begin_stmt_expr. Returns an expression
1865 representing the statement-expression. */
1868 finish_stmt_expr (tree stmt_expr
, bool has_no_scope
)
1873 if (error_operand_p (stmt_expr
))
1875 pop_stmt_list (stmt_expr
);
1876 return error_mark_node
;
1879 gcc_assert (TREE_CODE (stmt_expr
) == STATEMENT_LIST
);
1881 type
= TREE_TYPE (stmt_expr
);
1882 result
= pop_stmt_list (stmt_expr
);
1883 TREE_TYPE (result
) = type
;
1885 if (processing_template_decl
)
1887 result
= build_min (STMT_EXPR
, type
, result
);
1888 TREE_SIDE_EFFECTS (result
) = 1;
1889 STMT_EXPR_NO_SCOPE (result
) = has_no_scope
;
1891 else if (CLASS_TYPE_P (type
))
1893 /* Wrap the statement-expression in a TARGET_EXPR so that the
1894 temporary object created by the final expression is destroyed at
1895 the end of the full-expression containing the
1896 statement-expression. */
1897 result
= force_target_expr (type
, result
);
1903 /* Returns the expression which provides the value of STMT_EXPR. */
1906 stmt_expr_value_expr (tree stmt_expr
)
1908 tree t
= STMT_EXPR_STMT (stmt_expr
);
1910 if (TREE_CODE (t
) == BIND_EXPR
)
1911 t
= BIND_EXPR_BODY (t
);
1913 if (TREE_CODE (t
) == STATEMENT_LIST
&& STATEMENT_LIST_TAIL (t
))
1914 t
= STATEMENT_LIST_TAIL (t
)->stmt
;
1916 if (TREE_CODE (t
) == EXPR_STMT
)
1917 t
= EXPR_STMT_EXPR (t
);
1922 /* Return TRUE iff EXPR_STMT is an empty list of
1923 expression statements. */
1926 empty_expr_stmt_p (tree expr_stmt
)
1928 tree body
= NULL_TREE
;
1930 if (expr_stmt
== void_zero_node
)
1935 if (TREE_CODE (expr_stmt
) == EXPR_STMT
)
1936 body
= EXPR_STMT_EXPR (expr_stmt
);
1937 else if (TREE_CODE (expr_stmt
) == STATEMENT_LIST
)
1943 if (TREE_CODE (body
) == STATEMENT_LIST
)
1944 return tsi_end_p (tsi_start (body
));
1946 return empty_expr_stmt_p (body
);
1951 /* Perform Koenig lookup. FN is the postfix-expression representing
1952 the function (or functions) to call; ARGS are the arguments to the
1953 call; if INCLUDE_STD then the `std' namespace is automatically
1954 considered an associated namespace (used in range-based for loops).
1955 Returns the functions to be considered by overload resolution. */
1958 perform_koenig_lookup (tree fn
, VEC(tree
,gc
) *args
, bool include_std
)
1960 tree identifier
= NULL_TREE
;
1961 tree functions
= NULL_TREE
;
1962 tree tmpl_args
= NULL_TREE
;
1963 bool template_id
= false;
1965 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
1967 /* Use a separate flag to handle null args. */
1969 tmpl_args
= TREE_OPERAND (fn
, 1);
1970 fn
= TREE_OPERAND (fn
, 0);
1973 /* Find the name of the overloaded function. */
1974 if (TREE_CODE (fn
) == IDENTIFIER_NODE
)
1976 else if (is_overloaded_fn (fn
))
1979 identifier
= DECL_NAME (get_first_fn (functions
));
1981 else if (DECL_P (fn
))
1984 identifier
= DECL_NAME (fn
);
1987 /* A call to a namespace-scope function using an unqualified name.
1989 Do Koenig lookup -- unless any of the arguments are
1991 if (!any_type_dependent_arguments_p (args
)
1992 && !any_dependent_template_arguments_p (tmpl_args
))
1994 fn
= lookup_arg_dependent (identifier
, functions
, args
, include_std
);
1996 /* The unqualified name could not be resolved. */
1997 fn
= unqualified_fn_lookup_error (identifier
);
2000 if (fn
&& template_id
)
2001 fn
= build2 (TEMPLATE_ID_EXPR
, unknown_type_node
, fn
, tmpl_args
);
2006 /* Generate an expression for `FN (ARGS)'. This may change the
2009 If DISALLOW_VIRTUAL is true, the call to FN will be not generated
2010 as a virtual call, even if FN is virtual. (This flag is set when
2011 encountering an expression where the function name is explicitly
2012 qualified. For example a call to `X::f' never generates a virtual
2015 Returns code for the call. */
2018 finish_call_expr (tree fn
, VEC(tree
,gc
) **args
, bool disallow_virtual
,
2019 bool koenig_p
, tsubst_flags_t complain
)
2023 VEC(tree
,gc
) *orig_args
= NULL
;
2025 if (fn
== error_mark_node
)
2026 return error_mark_node
;
2028 gcc_assert (!TYPE_P (fn
));
2032 if (processing_template_decl
)
2034 /* If the call expression is dependent, build a CALL_EXPR node
2035 with no type; type_dependent_expression_p recognizes
2036 expressions with no type as being dependent. */
2037 if (type_dependent_expression_p (fn
)
2038 || any_type_dependent_arguments_p (*args
)
2039 /* For a non-static member function, we need to specifically
2040 test the type dependency of the "this" pointer because it
2041 is not included in *ARGS even though it is considered to
2042 be part of the list of arguments. Note that this is
2043 related to CWG issues 515 and 1005. */
2044 || ((TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
)
2045 && current_class_ref
2046 && type_dependent_expression_p (current_class_ref
)))
2048 result
= build_nt_call_vec (fn
, *args
);
2049 KOENIG_LOOKUP_P (result
) = koenig_p
;
2054 tree fndecl
= OVL_CURRENT (fn
);
2055 if (TREE_CODE (fndecl
) != FUNCTION_DECL
2056 || !TREE_THIS_VOLATILE (fndecl
))
2062 current_function_returns_abnormally
= 1;
2066 orig_args
= make_tree_vector_copy (*args
);
2067 if (!BASELINK_P (fn
)
2068 && TREE_CODE (fn
) != PSEUDO_DTOR_EXPR
2069 && TREE_TYPE (fn
) != unknown_type_node
)
2070 fn
= build_non_dependent_expr (fn
);
2071 make_args_non_dependent (*args
);
2074 if (is_overloaded_fn (fn
))
2075 fn
= baselink_for_fns (fn
);
2078 if (BASELINK_P (fn
))
2082 /* A call to a member function. From [over.call.func]:
2084 If the keyword this is in scope and refers to the class of
2085 that member function, or a derived class thereof, then the
2086 function call is transformed into a qualified function call
2087 using (*this) as the postfix-expression to the left of the
2088 . operator.... [Otherwise] a contrived object of type T
2089 becomes the implied object argument.
2093 struct A { void f(); };
2094 struct B : public A {};
2095 struct C : public A { void g() { B::f(); }};
2097 "the class of that member function" refers to `A'. But 11.2
2098 [class.access.base] says that we need to convert 'this' to B* as
2099 part of the access, so we pass 'B' to maybe_dummy_object. */
2101 object
= maybe_dummy_object (BINFO_TYPE (BASELINK_ACCESS_BINFO (fn
)),
2104 if (processing_template_decl
)
2106 if (type_dependent_expression_p (object
))
2108 tree ret
= build_nt_call_vec (orig_fn
, orig_args
);
2109 release_tree_vector (orig_args
);
2112 object
= build_non_dependent_expr (object
);
2115 result
= build_new_method_call (object
, fn
, args
, NULL_TREE
,
2117 ? LOOKUP_NONVIRTUAL
: 0),
2121 else if (is_overloaded_fn (fn
))
2123 /* If the function is an overloaded builtin, resolve it. */
2124 if (TREE_CODE (fn
) == FUNCTION_DECL
2125 && (DECL_BUILT_IN_CLASS (fn
) == BUILT_IN_NORMAL
2126 || DECL_BUILT_IN_CLASS (fn
) == BUILT_IN_MD
))
2127 result
= resolve_overloaded_builtin (input_location
, fn
, *args
);
2130 /* A call to a namespace-scope function. */
2131 result
= build_new_function_call (fn
, args
, koenig_p
, complain
);
2133 else if (TREE_CODE (fn
) == PSEUDO_DTOR_EXPR
)
2135 if (!VEC_empty (tree
, *args
))
2136 error ("arguments to destructor are not allowed");
2137 /* Mark the pseudo-destructor call as having side-effects so
2138 that we do not issue warnings about its use. */
2139 result
= build1 (NOP_EXPR
,
2141 TREE_OPERAND (fn
, 0));
2142 TREE_SIDE_EFFECTS (result
) = 1;
2144 else if (CLASS_TYPE_P (TREE_TYPE (fn
)))
2145 /* If the "function" is really an object of class type, it might
2146 have an overloaded `operator ()'. */
2147 result
= build_op_call (fn
, args
, complain
);
2150 /* A call where the function is unknown. */
2151 result
= cp_build_function_call_vec (fn
, args
, complain
);
2153 if (processing_template_decl
&& result
!= error_mark_node
)
2155 if (TREE_CODE (result
) == INDIRECT_REF
)
2156 result
= TREE_OPERAND (result
, 0);
2157 gcc_assert (TREE_CODE (result
) == CALL_EXPR
2158 /* FIXME cp_build_function_call_vec should avoid argument
2159 and return transformations like build_over_call does. */
2160 || TREE_CODE (result
) == TARGET_EXPR
2161 || TREE_CODE (fn
) == PSEUDO_DTOR_EXPR
2163 result
= build_call_vec (TREE_TYPE (result
), orig_fn
, orig_args
);
2164 KOENIG_LOOKUP_P (result
) = koenig_p
;
2165 release_tree_vector (orig_args
);
2166 result
= convert_from_reference (result
);
2172 /* Finish a call to a postfix increment or decrement or EXPR. (Which
2173 is indicated by CODE, which should be POSTINCREMENT_EXPR or
2174 POSTDECREMENT_EXPR.) */
2177 finish_increment_expr (tree expr
, enum tree_code code
)
2179 return build_x_unary_op (code
, expr
, tf_warning_or_error
);
2182 /* Finish a use of `this'. Returns an expression for `this'. */
2185 finish_this_expr (void)
2189 if (current_class_ptr
)
2191 tree type
= TREE_TYPE (current_class_ref
);
2193 /* In a lambda expression, 'this' refers to the captured 'this'. */
2194 if (LAMBDA_TYPE_P (type
))
2195 result
= lambda_expr_this_capture (CLASSTYPE_LAMBDA_EXPR (type
));
2197 result
= current_class_ptr
;
2200 else if (current_function_decl
2201 && DECL_STATIC_FUNCTION_P (current_function_decl
))
2203 error ("%<this%> is unavailable for static member functions");
2204 result
= error_mark_node
;
2208 if (current_function_decl
)
2209 error ("invalid use of %<this%> in non-member function");
2211 error ("invalid use of %<this%> at top level");
2212 result
= error_mark_node
;
2218 /* Finish a pseudo-destructor expression. If SCOPE is NULL, the
2219 expression was of the form `OBJECT.~DESTRUCTOR' where DESTRUCTOR is
2220 the TYPE for the type given. If SCOPE is non-NULL, the expression
2221 was of the form `OBJECT.SCOPE::~DESTRUCTOR'. */
2224 finish_pseudo_destructor_expr (tree object
, tree scope
, tree destructor
)
2226 if (object
== error_mark_node
|| destructor
== error_mark_node
)
2227 return error_mark_node
;
2229 gcc_assert (TYPE_P (destructor
));
2231 if (!processing_template_decl
)
2233 if (scope
== error_mark_node
)
2235 error ("invalid qualifying scope in pseudo-destructor name");
2236 return error_mark_node
;
2238 if (scope
&& TYPE_P (scope
) && !check_dtor_name (scope
, destructor
))
2240 error ("qualified type %qT does not match destructor name ~%qT",
2242 return error_mark_node
;
2246 /* [expr.pseudo] says both:
2248 The type designated by the pseudo-destructor-name shall be
2249 the same as the object type.
2253 The cv-unqualified versions of the object type and of the
2254 type designated by the pseudo-destructor-name shall be the
2257 We implement the more generous second sentence, since that is
2258 what most other compilers do. */
2259 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (object
),
2262 error ("%qE is not of type %qT", object
, destructor
);
2263 return error_mark_node
;
2267 return build3 (PSEUDO_DTOR_EXPR
, void_type_node
, object
, scope
, destructor
);
2270 /* Finish an expression of the form CODE EXPR. */
2273 finish_unary_op_expr (enum tree_code code
, tree expr
)
2275 tree result
= build_x_unary_op (code
, expr
, tf_warning_or_error
);
2276 /* Inside a template, build_x_unary_op does not fold the
2277 expression. So check whether the result is folded before
2278 setting TREE_NEGATED_INT. */
2279 if (code
== NEGATE_EXPR
&& TREE_CODE (expr
) == INTEGER_CST
2280 && TREE_CODE (result
) == INTEGER_CST
2281 && !TYPE_UNSIGNED (TREE_TYPE (result
))
2282 && INT_CST_LT (result
, integer_zero_node
))
2284 /* RESULT may be a cached INTEGER_CST, so we must copy it before
2285 setting TREE_NEGATED_INT. */
2286 result
= copy_node (result
);
2287 TREE_NEGATED_INT (result
) = 1;
2289 if (TREE_OVERFLOW_P (result
) && !TREE_OVERFLOW_P (expr
))
2290 overflow_warning (input_location
, result
);
2295 /* Finish a compound-literal expression. TYPE is the type to which
2296 the CONSTRUCTOR in COMPOUND_LITERAL is being cast. */
2299 finish_compound_literal (tree type
, tree compound_literal
)
2301 if (type
== error_mark_node
)
2302 return error_mark_node
;
2304 if (!TYPE_OBJ_P (type
))
2306 error ("compound literal of non-object type %qT", type
);
2307 return error_mark_node
;
2310 if (processing_template_decl
)
2312 TREE_TYPE (compound_literal
) = type
;
2313 /* Mark the expression as a compound literal. */
2314 TREE_HAS_CONSTRUCTOR (compound_literal
) = 1;
2315 return compound_literal
;
2318 type
= complete_type (type
);
2320 if (TYPE_NON_AGGREGATE_CLASS (type
))
2322 /* Trying to deal with a CONSTRUCTOR instead of a TREE_LIST
2323 everywhere that deals with function arguments would be a pain, so
2324 just wrap it in a TREE_LIST. The parser set a flag so we know
2325 that it came from T{} rather than T({}). */
2326 CONSTRUCTOR_IS_DIRECT_INIT (compound_literal
) = 1;
2327 compound_literal
= build_tree_list (NULL_TREE
, compound_literal
);
2328 return build_functional_cast (type
, compound_literal
, tf_error
);
2331 if (TREE_CODE (type
) == ARRAY_TYPE
2332 && check_array_initializer (NULL_TREE
, type
, compound_literal
))
2333 return error_mark_node
;
2334 compound_literal
= reshape_init (type
, compound_literal
);
2335 if (TREE_CODE (type
) == ARRAY_TYPE
)
2336 cp_complete_array_type (&type
, compound_literal
, false);
2337 compound_literal
= digest_init (type
, compound_literal
);
2338 /* Put static/constant array temporaries in static variables, but always
2339 represent class temporaries with TARGET_EXPR so we elide copies. */
2340 if ((!at_function_scope_p () || CP_TYPE_CONST_P (type
))
2341 && TREE_CODE (type
) == ARRAY_TYPE
2342 && initializer_constant_valid_p (compound_literal
, type
))
2344 tree decl
= create_temporary_var (type
);
2345 DECL_INITIAL (decl
) = compound_literal
;
2346 TREE_STATIC (decl
) = 1;
2347 if (literal_type_p (type
) && CP_TYPE_CONST_NON_VOLATILE_P (type
))
2349 /* 5.19 says that a constant expression can include an
2350 lvalue-rvalue conversion applied to "a glvalue of literal type
2351 that refers to a non-volatile temporary object initialized
2352 with a constant expression". Rather than try to communicate
2353 that this VAR_DECL is a temporary, just mark it constexpr. */
2354 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
2355 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = true;
2356 TREE_CONSTANT (decl
) = true;
2358 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
2359 decl
= pushdecl_top_level (decl
);
2360 DECL_NAME (decl
) = make_anon_name ();
2361 SET_DECL_ASSEMBLER_NAME (decl
, DECL_NAME (decl
));
2365 return get_target_expr (compound_literal
);
2368 /* Return the declaration for the function-name variable indicated by
2372 finish_fname (tree id
)
2376 decl
= fname_decl (input_location
, C_RID_CODE (id
), id
);
2377 if (processing_template_decl
&& current_function_decl
)
2378 decl
= DECL_NAME (decl
);
2382 /* Finish a translation unit. */
2385 finish_translation_unit (void)
2387 /* In case there were missing closebraces,
2388 get us back to the global binding level. */
2390 while (current_namespace
!= global_namespace
)
2393 /* Do file scope __FUNCTION__ et al. */
2394 finish_fname_decls ();
2397 /* Finish a template type parameter, specified as AGGR IDENTIFIER.
2398 Returns the parameter. */
2401 finish_template_type_parm (tree aggr
, tree identifier
)
2403 if (aggr
!= class_type_node
)
2405 permerror (input_location
, "template type parameters must use the keyword %<class%> or %<typename%>");
2406 aggr
= class_type_node
;
2409 return build_tree_list (aggr
, identifier
);
2412 /* Finish a template template parameter, specified as AGGR IDENTIFIER.
2413 Returns the parameter. */
2416 finish_template_template_parm (tree aggr
, tree identifier
)
2418 tree decl
= build_decl (input_location
,
2419 TYPE_DECL
, identifier
, NULL_TREE
);
2420 tree tmpl
= build_lang_decl (TEMPLATE_DECL
, identifier
, NULL_TREE
);
2421 DECL_TEMPLATE_PARMS (tmpl
) = current_template_parms
;
2422 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
2423 DECL_ARTIFICIAL (decl
) = 1;
2424 end_template_decl ();
2426 gcc_assert (DECL_TEMPLATE_PARMS (tmpl
));
2428 check_default_tmpl_args (decl
, DECL_TEMPLATE_PARMS (tmpl
),
2429 /*is_primary=*/true, /*is_partial=*/false,
2432 return finish_template_type_parm (aggr
, tmpl
);
2435 /* ARGUMENT is the default-argument value for a template template
2436 parameter. If ARGUMENT is invalid, issue error messages and return
2437 the ERROR_MARK_NODE. Otherwise, ARGUMENT itself is returned. */
2440 check_template_template_default_arg (tree argument
)
2442 if (TREE_CODE (argument
) != TEMPLATE_DECL
2443 && TREE_CODE (argument
) != TEMPLATE_TEMPLATE_PARM
2444 && TREE_CODE (argument
) != UNBOUND_CLASS_TEMPLATE
)
2446 if (TREE_CODE (argument
) == TYPE_DECL
)
2447 error ("invalid use of type %qT as a default value for a template "
2448 "template-parameter", TREE_TYPE (argument
));
2450 error ("invalid default argument for a template template parameter");
2451 return error_mark_node
;
2457 /* Begin a class definition, as indicated by T. */
2460 begin_class_definition (tree t
, tree attributes
)
2462 if (error_operand_p (t
) || error_operand_p (TYPE_MAIN_DECL (t
)))
2463 return error_mark_node
;
2465 if (processing_template_parmlist
)
2467 error ("definition of %q#T inside template parameter list", t
);
2468 return error_mark_node
;
2471 /* According to the C++ ABI, decimal classes defined in ISO/IEC TR 24733
2472 are passed the same as decimal scalar types. */
2473 if (TREE_CODE (t
) == RECORD_TYPE
2474 && !processing_template_decl
)
2476 tree ns
= TYPE_CONTEXT (t
);
2477 if (ns
&& TREE_CODE (ns
) == NAMESPACE_DECL
2478 && DECL_CONTEXT (ns
) == std_node
2480 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (ns
)), "decimal"))
2482 const char *n
= TYPE_NAME_STRING (t
);
2483 if ((strcmp (n
, "decimal32") == 0)
2484 || (strcmp (n
, "decimal64") == 0)
2485 || (strcmp (n
, "decimal128") == 0))
2486 TYPE_TRANSPARENT_AGGR (t
) = 1;
2490 /* A non-implicit typename comes from code like:
2492 template <typename T> struct A {
2493 template <typename U> struct A<T>::B ...
2495 This is erroneous. */
2496 else if (TREE_CODE (t
) == TYPENAME_TYPE
)
2498 error ("invalid definition of qualified type %qT", t
);
2499 t
= error_mark_node
;
2502 if (t
== error_mark_node
|| ! MAYBE_CLASS_TYPE_P (t
))
2504 t
= make_class_type (RECORD_TYPE
);
2505 pushtag (make_anon_name (), t
, /*tag_scope=*/ts_current
);
2508 if (TYPE_BEING_DEFINED (t
))
2510 t
= make_class_type (TREE_CODE (t
));
2511 pushtag (TYPE_IDENTIFIER (t
), t
, /*tag_scope=*/ts_current
);
2513 maybe_process_partial_specialization (t
);
2515 TYPE_BEING_DEFINED (t
) = 1;
2517 cplus_decl_attributes (&t
, attributes
, (int) ATTR_FLAG_TYPE_IN_PLACE
);
2518 fixup_attribute_variants (t
);
2520 if (flag_pack_struct
)
2523 TYPE_PACKED (t
) = 1;
2524 /* Even though the type is being defined for the first time
2525 here, there might have been a forward declaration, so there
2526 might be cv-qualified variants of T. */
2527 for (v
= TYPE_NEXT_VARIANT (t
); v
; v
= TYPE_NEXT_VARIANT (v
))
2528 TYPE_PACKED (v
) = 1;
2530 /* Reset the interface data, at the earliest possible
2531 moment, as it might have been set via a class foo;
2533 if (! TYPE_ANONYMOUS_P (t
))
2535 struct c_fileinfo
*finfo
= get_fileinfo (input_filename
);
2536 CLASSTYPE_INTERFACE_ONLY (t
) = finfo
->interface_only
;
2537 SET_CLASSTYPE_INTERFACE_UNKNOWN_X
2538 (t
, finfo
->interface_unknown
);
2540 reset_specialization();
2542 /* Make a declaration for this class in its own scope. */
2543 build_self_reference ();
2548 /* Finish the member declaration given by DECL. */
2551 finish_member_declaration (tree decl
)
2553 if (decl
== error_mark_node
|| decl
== NULL_TREE
)
2556 if (decl
== void_type_node
)
2557 /* The COMPONENT was a friend, not a member, and so there's
2558 nothing for us to do. */
2561 /* We should see only one DECL at a time. */
2562 gcc_assert (DECL_CHAIN (decl
) == NULL_TREE
);
2564 /* Set up access control for DECL. */
2566 = (current_access_specifier
== access_private_node
);
2567 TREE_PROTECTED (decl
)
2568 = (current_access_specifier
== access_protected_node
);
2569 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
2571 TREE_PRIVATE (DECL_TEMPLATE_RESULT (decl
)) = TREE_PRIVATE (decl
);
2572 TREE_PROTECTED (DECL_TEMPLATE_RESULT (decl
)) = TREE_PROTECTED (decl
);
2575 /* Mark the DECL as a member of the current class. */
2576 DECL_CONTEXT (decl
) = current_class_type
;
2578 /* Check for bare parameter packs in the member variable declaration. */
2579 if (TREE_CODE (decl
) == FIELD_DECL
)
2581 if (check_for_bare_parameter_packs (TREE_TYPE (decl
)))
2582 TREE_TYPE (decl
) = error_mark_node
;
2583 if (check_for_bare_parameter_packs (DECL_ATTRIBUTES (decl
)))
2584 DECL_ATTRIBUTES (decl
) = NULL_TREE
;
2589 A C language linkage is ignored for the names of class members
2590 and the member function type of class member functions. */
2591 if (DECL_LANG_SPECIFIC (decl
) && DECL_LANGUAGE (decl
) == lang_c
)
2592 SET_DECL_LANGUAGE (decl
, lang_cplusplus
);
2594 /* Put functions on the TYPE_METHODS list and everything else on the
2595 TYPE_FIELDS list. Note that these are built up in reverse order.
2596 We reverse them (to obtain declaration order) in finish_struct. */
2597 if (TREE_CODE (decl
) == FUNCTION_DECL
2598 || DECL_FUNCTION_TEMPLATE_P (decl
))
2600 /* We also need to add this function to the
2601 CLASSTYPE_METHOD_VEC. */
2602 if (add_method (current_class_type
, decl
, NULL_TREE
))
2604 DECL_CHAIN (decl
) = TYPE_METHODS (current_class_type
);
2605 TYPE_METHODS (current_class_type
) = decl
;
2607 maybe_add_class_template_decl_list (current_class_type
, decl
,
2611 /* Enter the DECL into the scope of the class. */
2612 else if ((TREE_CODE (decl
) == USING_DECL
&& !DECL_DEPENDENT_P (decl
))
2613 || pushdecl_class_level (decl
))
2615 /* All TYPE_DECLs go at the end of TYPE_FIELDS. Ordinary fields
2616 go at the beginning. The reason is that lookup_field_1
2617 searches the list in order, and we want a field name to
2618 override a type name so that the "struct stat hack" will
2619 work. In particular:
2621 struct S { enum E { }; int E } s;
2624 is valid. In addition, the FIELD_DECLs must be maintained in
2625 declaration order so that class layout works as expected.
2626 However, we don't need that order until class layout, so we
2627 save a little time by putting FIELD_DECLs on in reverse order
2628 here, and then reversing them in finish_struct_1. (We could
2629 also keep a pointer to the correct insertion points in the
2632 if (TREE_CODE (decl
) == TYPE_DECL
)
2633 TYPE_FIELDS (current_class_type
)
2634 = chainon (TYPE_FIELDS (current_class_type
), decl
);
2637 DECL_CHAIN (decl
) = TYPE_FIELDS (current_class_type
);
2638 TYPE_FIELDS (current_class_type
) = decl
;
2641 maybe_add_class_template_decl_list (current_class_type
, decl
,
2646 note_decl_for_pch (decl
);
2649 /* DECL has been declared while we are building a PCH file. Perform
2650 actions that we might normally undertake lazily, but which can be
2651 performed now so that they do not have to be performed in
2652 translation units which include the PCH file. */
2655 note_decl_for_pch (tree decl
)
2657 gcc_assert (pch_file
);
2659 /* There's a good chance that we'll have to mangle names at some
2660 point, even if only for emission in debugging information. */
2661 if ((TREE_CODE (decl
) == VAR_DECL
2662 || TREE_CODE (decl
) == FUNCTION_DECL
)
2663 && !processing_template_decl
)
2667 /* Finish processing a complete template declaration. The PARMS are
2668 the template parameters. */
2671 finish_template_decl (tree parms
)
2674 end_template_decl ();
2676 end_specialization ();
2679 /* Finish processing a template-id (which names a type) of the form
2680 NAME < ARGS >. Return the TYPE_DECL for the type named by the
2681 template-id. If ENTERING_SCOPE is nonzero we are about to enter
2682 the scope of template-id indicated. */
2685 finish_template_type (tree name
, tree args
, int entering_scope
)
2689 decl
= lookup_template_class (name
, args
,
2690 NULL_TREE
, NULL_TREE
, entering_scope
,
2691 tf_warning_or_error
| tf_user
);
2692 if (decl
!= error_mark_node
)
2693 decl
= TYPE_STUB_DECL (decl
);
2698 /* Finish processing a BASE_CLASS with the indicated ACCESS_SPECIFIER.
2699 Return a TREE_LIST containing the ACCESS_SPECIFIER and the
2700 BASE_CLASS, or NULL_TREE if an error occurred. The
2701 ACCESS_SPECIFIER is one of
2702 access_{default,public,protected_private}_node. For a virtual base
2703 we set TREE_TYPE. */
2706 finish_base_specifier (tree base
, tree access
, bool virtual_p
)
2710 if (base
== error_mark_node
)
2712 error ("invalid base-class specification");
2715 else if (! MAYBE_CLASS_TYPE_P (base
))
2717 error ("%qT is not a class type", base
);
2722 if (cp_type_quals (base
) != 0)
2724 error ("base class %qT has cv qualifiers", base
);
2725 base
= TYPE_MAIN_VARIANT (base
);
2727 result
= build_tree_list (access
, base
);
2729 TREE_TYPE (result
) = integer_type_node
;
2735 /* If FNS is a member function, a set of member functions, or a
2736 template-id referring to one or more member functions, return a
2737 BASELINK for FNS, incorporating the current access context.
2738 Otherwise, return FNS unchanged. */
2741 baselink_for_fns (tree fns
)
2746 if (BASELINK_P (fns
)
2747 || error_operand_p (fns
))
2751 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
2752 fn
= TREE_OPERAND (fn
, 0);
2753 fn
= get_first_fn (fn
);
2754 if (!DECL_FUNCTION_MEMBER_P (fn
))
2757 cl
= currently_open_derived_class (DECL_CONTEXT (fn
));
2759 cl
= DECL_CONTEXT (fn
);
2760 cl
= TYPE_BINFO (cl
);
2761 return build_baselink (cl
, cl
, fns
, /*optype=*/NULL_TREE
);
2764 /* Returns true iff DECL is an automatic variable from a function outside
2768 outer_automatic_var_p (tree decl
)
2770 return ((TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == PARM_DECL
)
2771 && DECL_FUNCTION_SCOPE_P (decl
)
2772 && !TREE_STATIC (decl
)
2773 && DECL_CONTEXT (decl
) != current_function_decl
);
2776 /* Returns true iff DECL is a capture field from a lambda that is not our
2777 immediate context. */
2780 outer_lambda_capture_p (tree decl
)
2782 return (TREE_CODE (decl
) == FIELD_DECL
2783 && LAMBDA_TYPE_P (DECL_CONTEXT (decl
))
2784 && (!current_class_type
2785 || !DERIVED_FROM_P (DECL_CONTEXT (decl
), current_class_type
)));
2788 /* ID_EXPRESSION is a representation of parsed, but unprocessed,
2789 id-expression. (See cp_parser_id_expression for details.) SCOPE,
2790 if non-NULL, is the type or namespace used to explicitly qualify
2791 ID_EXPRESSION. DECL is the entity to which that name has been
2794 *CONSTANT_EXPRESSION_P is true if we are presently parsing a
2795 constant-expression. In that case, *NON_CONSTANT_EXPRESSION_P will
2796 be set to true if this expression isn't permitted in a
2797 constant-expression, but it is otherwise not set by this function.
2798 *ALLOW_NON_CONSTANT_EXPRESSION_P is true if we are parsing a
2799 constant-expression, but a non-constant expression is also
2802 DONE is true if this expression is a complete postfix-expression;
2803 it is false if this expression is followed by '->', '[', '(', etc.
2804 ADDRESS_P is true iff this expression is the operand of '&'.
2805 TEMPLATE_P is true iff the qualified-id was of the form
2806 "A::template B". TEMPLATE_ARG_P is true iff this qualified name
2807 appears as a template argument.
2809 If an error occurs, and it is the kind of error that might cause
2810 the parser to abort a tentative parse, *ERROR_MSG is filled in. It
2811 is the caller's responsibility to issue the message. *ERROR_MSG
2812 will be a string with static storage duration, so the caller need
2815 Return an expression for the entity, after issuing appropriate
2816 diagnostics. This function is also responsible for transforming a
2817 reference to a non-static member into a COMPONENT_REF that makes
2818 the use of "this" explicit.
2820 Upon return, *IDK will be filled in appropriately. */
2822 finish_id_expression (tree id_expression
,
2826 bool integral_constant_expression_p
,
2827 bool allow_non_integral_constant_expression_p
,
2828 bool *non_integral_constant_expression_p
,
2832 bool template_arg_p
,
2833 const char **error_msg
,
2834 location_t location
)
2836 /* Initialize the output parameters. */
2837 *idk
= CP_ID_KIND_NONE
;
2840 if (id_expression
== error_mark_node
)
2841 return error_mark_node
;
2842 /* If we have a template-id, then no further lookup is
2843 required. If the template-id was for a template-class, we
2844 will sometimes have a TYPE_DECL at this point. */
2845 else if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
2846 || TREE_CODE (decl
) == TYPE_DECL
)
2848 /* Look up the name. */
2851 if (decl
== error_mark_node
)
2853 /* Name lookup failed. */
2856 || (!dependent_type_p (scope
)
2857 && !(TREE_CODE (id_expression
) == IDENTIFIER_NODE
2858 && IDENTIFIER_TYPENAME_P (id_expression
)
2859 && dependent_type_p (TREE_TYPE (id_expression
))))))
2861 /* If the qualifying type is non-dependent (and the name
2862 does not name a conversion operator to a dependent
2863 type), issue an error. */
2864 qualified_name_lookup_error (scope
, id_expression
, decl
, location
);
2865 return error_mark_node
;
2869 /* It may be resolved via Koenig lookup. */
2870 *idk
= CP_ID_KIND_UNQUALIFIED
;
2871 return id_expression
;
2874 decl
= id_expression
;
2876 /* If DECL is a variable that would be out of scope under
2877 ANSI/ISO rules, but in scope in the ARM, name lookup
2878 will succeed. Issue a diagnostic here. */
2880 decl
= check_for_out_of_scope_variable (decl
);
2882 /* Remember that the name was used in the definition of
2883 the current class so that we can check later to see if
2884 the meaning would have been different after the class
2885 was entirely defined. */
2886 if (!scope
&& decl
!= error_mark_node
2887 && TREE_CODE (id_expression
) == IDENTIFIER_NODE
)
2888 maybe_note_name_used_in_class (id_expression
, decl
);
2890 /* Disallow uses of local variables from containing functions, except
2891 within lambda-expressions. */
2892 if ((outer_automatic_var_p (decl
)
2893 || outer_lambda_capture_p (decl
))
2894 /* It's not a use (3.2) if we're in an unevaluated context. */
2895 && !cp_unevaluated_operand
)
2897 tree context
= DECL_CONTEXT (decl
);
2898 tree containing_function
= current_function_decl
;
2899 tree lambda_stack
= NULL_TREE
;
2900 tree lambda_expr
= NULL_TREE
;
2901 tree initializer
= decl
;
2903 /* Core issue 696: "[At the July 2009 meeting] the CWG expressed
2904 support for an approach in which a reference to a local
2905 [constant] automatic variable in a nested class or lambda body
2906 would enter the expression as an rvalue, which would reduce
2907 the complexity of the problem"
2909 FIXME update for final resolution of core issue 696. */
2910 if (decl_constant_var_p (decl
))
2911 return integral_constant_value (decl
);
2913 if (TYPE_P (context
))
2915 /* Implicit capture of an explicit capture. */
2916 context
= lambda_function (context
);
2917 initializer
= thisify_lambda_field (decl
);
2920 /* If we are in a lambda function, we can move out until we hit
2922 2. a non-lambda function, or
2923 3. a non-default capturing lambda function. */
2924 while (context
!= containing_function
2925 && LAMBDA_FUNCTION_P (containing_function
))
2927 lambda_expr
= CLASSTYPE_LAMBDA_EXPR
2928 (DECL_CONTEXT (containing_function
));
2930 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr
)
2934 lambda_stack
= tree_cons (NULL_TREE
,
2939 = decl_function_context (containing_function
);
2942 if (context
== containing_function
)
2944 decl
= add_default_capture (lambda_stack
,
2945 /*id=*/DECL_NAME (decl
),
2948 else if (lambda_expr
)
2950 error ("%qD is not captured", decl
);
2951 return error_mark_node
;
2955 error (TREE_CODE (decl
) == VAR_DECL
2956 ? "use of %<auto%> variable from containing function"
2957 : "use of parameter from containing function");
2958 error (" %q+#D declared here", decl
);
2959 return error_mark_node
;
2963 /* Also disallow uses of function parameters outside the function
2964 body, except inside an unevaluated context (i.e. decltype). */
2965 if (TREE_CODE (decl
) == PARM_DECL
2966 && DECL_CONTEXT (decl
) == NULL_TREE
2967 && !cp_unevaluated_operand
)
2969 error ("use of parameter %qD outside function body", decl
);
2970 return error_mark_node
;
2974 /* If we didn't find anything, or what we found was a type,
2975 then this wasn't really an id-expression. */
2976 if (TREE_CODE (decl
) == TEMPLATE_DECL
2977 && !DECL_FUNCTION_TEMPLATE_P (decl
))
2979 *error_msg
= "missing template arguments";
2980 return error_mark_node
;
2982 else if (TREE_CODE (decl
) == TYPE_DECL
2983 || TREE_CODE (decl
) == NAMESPACE_DECL
)
2985 *error_msg
= "expected primary-expression";
2986 return error_mark_node
;
2989 /* If the name resolved to a template parameter, there is no
2990 need to look it up again later. */
2991 if ((TREE_CODE (decl
) == CONST_DECL
&& DECL_TEMPLATE_PARM_P (decl
))
2992 || TREE_CODE (decl
) == TEMPLATE_PARM_INDEX
)
2996 *idk
= CP_ID_KIND_NONE
;
2997 if (TREE_CODE (decl
) == TEMPLATE_PARM_INDEX
)
2998 decl
= TEMPLATE_PARM_DECL (decl
);
2999 r
= convert_from_reference (DECL_INITIAL (decl
));
3001 if (integral_constant_expression_p
3002 && !dependent_type_p (TREE_TYPE (decl
))
3003 && !(INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (r
))))
3005 if (!allow_non_integral_constant_expression_p
)
3006 error ("template parameter %qD of type %qT is not allowed in "
3007 "an integral constant expression because it is not of "
3008 "integral or enumeration type", decl
, TREE_TYPE (decl
));
3009 *non_integral_constant_expression_p
= true;
3013 /* Similarly, we resolve enumeration constants to their
3014 underlying values. */
3015 else if (TREE_CODE (decl
) == CONST_DECL
)
3017 *idk
= CP_ID_KIND_NONE
;
3018 if (!processing_template_decl
)
3020 used_types_insert (TREE_TYPE (decl
));
3021 return DECL_INITIAL (decl
);
3029 /* If the declaration was explicitly qualified indicate
3030 that. The semantics of `A::f(3)' are different than
3031 `f(3)' if `f' is virtual. */
3033 ? CP_ID_KIND_QUALIFIED
3034 : (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
3035 ? CP_ID_KIND_TEMPLATE_ID
3036 : CP_ID_KIND_UNQUALIFIED
));
3041 An id-expression is type-dependent if it contains an
3042 identifier that was declared with a dependent type.
3044 The standard is not very specific about an id-expression that
3045 names a set of overloaded functions. What if some of them
3046 have dependent types and some of them do not? Presumably,
3047 such a name should be treated as a dependent name. */
3048 /* Assume the name is not dependent. */
3049 dependent_p
= false;
3050 if (!processing_template_decl
)
3051 /* No names are dependent outside a template. */
3053 /* A template-id where the name of the template was not resolved
3054 is definitely dependent. */
3055 else if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
3056 && (TREE_CODE (TREE_OPERAND (decl
, 0))
3057 == IDENTIFIER_NODE
))
3059 /* For anything except an overloaded function, just check its
3061 else if (!is_overloaded_fn (decl
))
3063 = dependent_type_p (TREE_TYPE (decl
));
3064 /* For a set of overloaded functions, check each of the
3070 if (BASELINK_P (fns
))
3071 fns
= BASELINK_FUNCTIONS (fns
);
3073 /* For a template-id, check to see if the template
3074 arguments are dependent. */
3075 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
3077 tree args
= TREE_OPERAND (fns
, 1);
3078 dependent_p
= any_dependent_template_arguments_p (args
);
3079 /* The functions are those referred to by the
3081 fns
= TREE_OPERAND (fns
, 0);
3084 /* If there are no dependent template arguments, go through
3085 the overloaded functions. */
3086 while (fns
&& !dependent_p
)
3088 tree fn
= OVL_CURRENT (fns
);
3090 /* Member functions of dependent classes are
3092 if (TREE_CODE (fn
) == FUNCTION_DECL
3093 && type_dependent_expression_p (fn
))
3095 else if (TREE_CODE (fn
) == TEMPLATE_DECL
3096 && dependent_template_p (fn
))
3099 fns
= OVL_NEXT (fns
);
3103 /* If the name was dependent on a template parameter, we will
3104 resolve the name at instantiation time. */
3107 /* Create a SCOPE_REF for qualified names, if the scope is
3113 if (address_p
&& done
)
3114 decl
= finish_qualified_id_expr (scope
, decl
,
3120 tree type
= NULL_TREE
;
3121 if (DECL_P (decl
) && !dependent_scope_p (scope
))
3122 type
= TREE_TYPE (decl
);
3123 decl
= build_qualified_name (type
,
3129 if (TREE_TYPE (decl
))
3130 decl
= convert_from_reference (decl
);
3133 /* A TEMPLATE_ID already contains all the information we
3135 if (TREE_CODE (id_expression
) == TEMPLATE_ID_EXPR
)
3136 return id_expression
;
3137 *idk
= CP_ID_KIND_UNQUALIFIED_DEPENDENT
;
3138 /* If we found a variable, then name lookup during the
3139 instantiation will always resolve to the same VAR_DECL
3140 (or an instantiation thereof). */
3141 if (TREE_CODE (decl
) == VAR_DECL
3142 || TREE_CODE (decl
) == PARM_DECL
)
3143 return convert_from_reference (decl
);
3144 /* The same is true for FIELD_DECL, but we also need to
3145 make sure that the syntax is correct. */
3146 else if (TREE_CODE (decl
) == FIELD_DECL
)
3148 /* Since SCOPE is NULL here, this is an unqualified name.
3149 Access checking has been performed during name lookup
3150 already. Turn off checking to avoid duplicate errors. */
3151 push_deferring_access_checks (dk_no_check
);
3152 decl
= finish_non_static_data_member
3154 /*qualifying_scope=*/NULL_TREE
);
3155 pop_deferring_access_checks ();
3158 return id_expression
;
3161 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
3163 error ("use of namespace %qD as expression", decl
);
3164 return error_mark_node
;
3166 else if (DECL_CLASS_TEMPLATE_P (decl
))
3168 error ("use of class template %qT as expression", decl
);
3169 return error_mark_node
;
3171 else if (TREE_CODE (decl
) == TREE_LIST
)
3173 /* Ambiguous reference to base members. */
3174 error ("request for member %qD is ambiguous in "
3175 "multiple inheritance lattice", id_expression
);
3176 print_candidates (decl
);
3177 return error_mark_node
;
3180 /* Mark variable-like entities as used. Functions are similarly
3181 marked either below or after overload resolution. */
3182 if (TREE_CODE (decl
) == VAR_DECL
3183 || TREE_CODE (decl
) == PARM_DECL
3184 || TREE_CODE (decl
) == RESULT_DECL
)
3187 /* Only certain kinds of names are allowed in constant
3188 expression. Enumerators and template parameters have already
3189 been handled above. */
3190 if (! error_operand_p (decl
)
3191 && integral_constant_expression_p
3192 && ! decl_constant_var_p (decl
)
3193 && ! builtin_valid_in_constant_expr_p (decl
))
3195 if (!allow_non_integral_constant_expression_p
)
3197 error ("%qD cannot appear in a constant-expression", decl
);
3198 return error_mark_node
;
3200 *non_integral_constant_expression_p
= true;
3205 decl
= (adjust_result_of_qualified_name_lookup
3206 (decl
, scope
, current_class_type
));
3208 if (TREE_CODE (decl
) == FUNCTION_DECL
)
3211 if (TREE_CODE (decl
) == FIELD_DECL
|| BASELINK_P (decl
))
3212 decl
= finish_qualified_id_expr (scope
,
3220 tree r
= convert_from_reference (decl
);
3222 /* In a template, return a SCOPE_REF for most qualified-ids
3223 so that we can check access at instantiation time. But if
3224 we're looking at a member of the current instantiation, we
3225 know we have access and building up the SCOPE_REF confuses
3226 non-type template argument handling. */
3227 if (processing_template_decl
&& TYPE_P (scope
)
3228 && !currently_open_class (scope
))
3229 r
= build_qualified_name (TREE_TYPE (r
),
3235 else if (TREE_CODE (decl
) == FIELD_DECL
)
3237 /* Since SCOPE is NULL here, this is an unqualified name.
3238 Access checking has been performed during name lookup
3239 already. Turn off checking to avoid duplicate errors. */
3240 push_deferring_access_checks (dk_no_check
);
3241 decl
= finish_non_static_data_member (decl
, NULL_TREE
,
3242 /*qualifying_scope=*/NULL_TREE
);
3243 pop_deferring_access_checks ();
3245 else if (is_overloaded_fn (decl
))
3249 first_fn
= get_first_fn (decl
);
3250 if (TREE_CODE (first_fn
) == TEMPLATE_DECL
)
3251 first_fn
= DECL_TEMPLATE_RESULT (first_fn
);
3253 if (!really_overloaded_fn (decl
))
3254 mark_used (first_fn
);
3257 && TREE_CODE (first_fn
) == FUNCTION_DECL
3258 && DECL_FUNCTION_MEMBER_P (first_fn
)
3259 && !shared_member_p (decl
))
3261 /* A set of member functions. */
3262 decl
= maybe_dummy_object (DECL_CONTEXT (first_fn
), 0);
3263 return finish_class_member_access_expr (decl
, id_expression
,
3264 /*template_p=*/false,
3265 tf_warning_or_error
);
3268 decl
= baselink_for_fns (decl
);
3272 if (DECL_P (decl
) && DECL_NONLOCAL (decl
)
3273 && DECL_CLASS_SCOPE_P (decl
))
3275 tree context
= context_for_name_lookup (decl
);
3276 if (context
!= current_class_type
)
3278 tree path
= currently_open_derived_class (context
);
3279 perform_or_defer_access_check (TYPE_BINFO (path
),
3284 decl
= convert_from_reference (decl
);
3288 if (TREE_DEPRECATED (decl
))
3289 warn_deprecated_use (decl
, NULL_TREE
);
3294 /* Implement the __typeof keyword: Return the type of EXPR, suitable for
3295 use as a type-specifier. */
3298 finish_typeof (tree expr
)
3302 if (type_dependent_expression_p (expr
))
3304 type
= cxx_make_type (TYPEOF_TYPE
);
3305 TYPEOF_TYPE_EXPR (type
) = expr
;
3306 SET_TYPE_STRUCTURAL_EQUALITY (type
);
3311 expr
= mark_type_use (expr
);
3313 type
= unlowered_expr_type (expr
);
3315 if (!type
|| type
== unknown_type_node
)
3317 error ("type of %qE is unknown", expr
);
3318 return error_mark_node
;
3324 /* Perform C++-specific checks for __builtin_offsetof before calling
3328 finish_offsetof (tree expr
)
3330 if (TREE_CODE (expr
) == PSEUDO_DTOR_EXPR
)
3332 error ("cannot apply %<offsetof%> to destructor %<~%T%>",
3333 TREE_OPERAND (expr
, 2));
3334 return error_mark_node
;
3336 if (TREE_CODE (TREE_TYPE (expr
)) == FUNCTION_TYPE
3337 || TREE_CODE (TREE_TYPE (expr
)) == METHOD_TYPE
3338 || TREE_TYPE (expr
) == unknown_type_node
)
3340 if (TREE_CODE (expr
) == COMPONENT_REF
3341 || TREE_CODE (expr
) == COMPOUND_EXPR
)
3342 expr
= TREE_OPERAND (expr
, 1);
3343 error ("cannot apply %<offsetof%> to member function %qD", expr
);
3344 return error_mark_node
;
3346 if (TREE_CODE (expr
) == INDIRECT_REF
&& REFERENCE_REF_P (expr
))
3347 expr
= TREE_OPERAND (expr
, 0);
3348 return fold_offsetof (expr
, NULL_TREE
);
3351 /* Replace the AGGR_INIT_EXPR at *TP with an equivalent CALL_EXPR. This
3352 function is broken out from the above for the benefit of the tree-ssa
3356 simplify_aggr_init_expr (tree
*tp
)
3358 tree aggr_init_expr
= *tp
;
3360 /* Form an appropriate CALL_EXPR. */
3361 tree fn
= AGGR_INIT_EXPR_FN (aggr_init_expr
);
3362 tree slot
= AGGR_INIT_EXPR_SLOT (aggr_init_expr
);
3363 tree type
= TREE_TYPE (slot
);
3366 enum style_t
{ ctor
, arg
, pcc
} style
;
3368 if (AGGR_INIT_VIA_CTOR_P (aggr_init_expr
))
3370 #ifdef PCC_STATIC_STRUCT_RETURN
3376 gcc_assert (TREE_ADDRESSABLE (type
));
3380 call_expr
= build_call_array_loc (input_location
,
3381 TREE_TYPE (TREE_TYPE (TREE_TYPE (fn
))),
3383 aggr_init_expr_nargs (aggr_init_expr
),
3384 AGGR_INIT_EXPR_ARGP (aggr_init_expr
));
3385 TREE_NOTHROW (call_expr
) = TREE_NOTHROW (aggr_init_expr
);
3389 /* Replace the first argument to the ctor with the address of the
3391 cxx_mark_addressable (slot
);
3392 CALL_EXPR_ARG (call_expr
, 0) =
3393 build1 (ADDR_EXPR
, build_pointer_type (type
), slot
);
3395 else if (style
== arg
)
3397 /* Just mark it addressable here, and leave the rest to
3398 expand_call{,_inline}. */
3399 cxx_mark_addressable (slot
);
3400 CALL_EXPR_RETURN_SLOT_OPT (call_expr
) = true;
3401 call_expr
= build2 (INIT_EXPR
, TREE_TYPE (call_expr
), slot
, call_expr
);
3403 else if (style
== pcc
)
3405 /* If we're using the non-reentrant PCC calling convention, then we
3406 need to copy the returned value out of the static buffer into the
3408 push_deferring_access_checks (dk_no_check
);
3409 call_expr
= build_aggr_init (slot
, call_expr
,
3410 DIRECT_BIND
| LOOKUP_ONLYCONVERTING
,
3411 tf_warning_or_error
);
3412 pop_deferring_access_checks ();
3413 call_expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (slot
), call_expr
, slot
);
3416 if (AGGR_INIT_ZERO_FIRST (aggr_init_expr
))
3418 tree init
= build_zero_init (type
, NULL_TREE
,
3419 /*static_storage_p=*/false);
3420 init
= build2 (INIT_EXPR
, void_type_node
, slot
, init
);
3421 call_expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (call_expr
),
3428 /* Emit all thunks to FN that should be emitted when FN is emitted. */
3431 emit_associated_thunks (tree fn
)
3433 /* When we use vcall offsets, we emit thunks with the virtual
3434 functions to which they thunk. The whole point of vcall offsets
3435 is so that you can know statically the entire set of thunks that
3436 will ever be needed for a given virtual function, thereby
3437 enabling you to output all the thunks with the function itself. */
3438 if (DECL_VIRTUAL_P (fn
)
3439 /* Do not emit thunks for extern template instantiations. */
3440 && ! DECL_REALLY_EXTERN (fn
))
3444 for (thunk
= DECL_THUNKS (fn
); thunk
; thunk
= DECL_CHAIN (thunk
))
3446 if (!THUNK_ALIAS (thunk
))
3448 use_thunk (thunk
, /*emit_p=*/1);
3449 if (DECL_RESULT_THUNK_P (thunk
))
3453 for (probe
= DECL_THUNKS (thunk
);
3454 probe
; probe
= DECL_CHAIN (probe
))
3455 use_thunk (probe
, /*emit_p=*/1);
3459 gcc_assert (!DECL_THUNKS (thunk
));
3464 /* Generate RTL for FN. */
3467 expand_or_defer_fn_1 (tree fn
)
3469 /* When the parser calls us after finishing the body of a template
3470 function, we don't really want to expand the body. */
3471 if (processing_template_decl
)
3473 /* Normally, collection only occurs in rest_of_compilation. So,
3474 if we don't collect here, we never collect junk generated
3475 during the processing of templates until we hit a
3476 non-template function. It's not safe to do this inside a
3477 nested class, though, as the parser may have local state that
3478 is not a GC root. */
3479 if (!function_depth
)
3484 gcc_assert (DECL_SAVED_TREE (fn
));
3486 /* If this is a constructor or destructor body, we have to clone
3488 if (maybe_clone_body (fn
))
3490 /* We don't want to process FN again, so pretend we've written
3491 it out, even though we haven't. */
3492 TREE_ASM_WRITTEN (fn
) = 1;
3493 DECL_SAVED_TREE (fn
) = NULL_TREE
;
3497 /* We make a decision about linkage for these functions at the end
3498 of the compilation. Until that point, we do not want the back
3499 end to output them -- but we do want it to see the bodies of
3500 these functions so that it can inline them as appropriate. */
3501 if (DECL_DECLARED_INLINE_P (fn
) || DECL_IMPLICIT_INSTANTIATION (fn
))
3503 if (DECL_INTERFACE_KNOWN (fn
))
3504 /* We've already made a decision as to how this function will
3508 DECL_EXTERNAL (fn
) = 1;
3509 DECL_NOT_REALLY_EXTERN (fn
) = 1;
3510 note_vague_linkage_fn (fn
);
3511 /* A non-template inline function with external linkage will
3512 always be COMDAT. As we must eventually determine the
3513 linkage of all functions, and as that causes writes to
3514 the data mapped in from the PCH file, it's advantageous
3515 to mark the functions at this point. */
3516 if (!DECL_IMPLICIT_INSTANTIATION (fn
))
3518 /* This function must have external linkage, as
3519 otherwise DECL_INTERFACE_KNOWN would have been
3521 gcc_assert (TREE_PUBLIC (fn
));
3522 comdat_linkage (fn
);
3523 DECL_INTERFACE_KNOWN (fn
) = 1;
3527 import_export_decl (fn
);
3529 /* If the user wants us to keep all inline functions, then mark
3530 this function as needed so that finish_file will make sure to
3531 output it later. Similarly, all dllexport'd functions must
3532 be emitted; there may be callers in other DLLs. */
3533 if ((flag_keep_inline_functions
3534 && DECL_DECLARED_INLINE_P (fn
)
3535 && !DECL_REALLY_EXTERN (fn
))
3536 || (flag_keep_inline_dllexport
3537 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (fn
))))
3541 /* There's no reason to do any of the work here if we're only doing
3542 semantic analysis; this code just generates RTL. */
3543 if (flag_syntax_only
)
3550 expand_or_defer_fn (tree fn
)
3552 if (expand_or_defer_fn_1 (fn
))
3556 /* Expand or defer, at the whim of the compilation unit manager. */
3557 cgraph_finalize_function (fn
, function_depth
> 1);
3558 emit_associated_thunks (fn
);
3571 /* Helper function for walk_tree, used by finalize_nrv below. */
3574 finalize_nrv_r (tree
* tp
, int* walk_subtrees
, void* data
)
3576 struct nrv_data
*dp
= (struct nrv_data
*)data
;
3579 /* No need to walk into types. There wouldn't be any need to walk into
3580 non-statements, except that we have to consider STMT_EXPRs. */
3583 /* Change all returns to just refer to the RESULT_DECL; this is a nop,
3584 but differs from using NULL_TREE in that it indicates that we care
3585 about the value of the RESULT_DECL. */
3586 else if (TREE_CODE (*tp
) == RETURN_EXPR
)
3587 TREE_OPERAND (*tp
, 0) = dp
->result
;
3588 /* Change all cleanups for the NRV to only run when an exception is
3590 else if (TREE_CODE (*tp
) == CLEANUP_STMT
3591 && CLEANUP_DECL (*tp
) == dp
->var
)
3592 CLEANUP_EH_ONLY (*tp
) = 1;
3593 /* Replace the DECL_EXPR for the NRV with an initialization of the
3594 RESULT_DECL, if needed. */
3595 else if (TREE_CODE (*tp
) == DECL_EXPR
3596 && DECL_EXPR_DECL (*tp
) == dp
->var
)
3599 if (DECL_INITIAL (dp
->var
)
3600 && DECL_INITIAL (dp
->var
) != error_mark_node
)
3601 init
= build2 (INIT_EXPR
, void_type_node
, dp
->result
,
3602 DECL_INITIAL (dp
->var
));
3604 init
= build_empty_stmt (EXPR_LOCATION (*tp
));
3605 DECL_INITIAL (dp
->var
) = NULL_TREE
;
3606 SET_EXPR_LOCATION (init
, EXPR_LOCATION (*tp
));
3609 /* And replace all uses of the NRV with the RESULT_DECL. */
3610 else if (*tp
== dp
->var
)
3613 /* Avoid walking into the same tree more than once. Unfortunately, we
3614 can't just use walk_tree_without duplicates because it would only call
3615 us for the first occurrence of dp->var in the function body. */
3616 slot
= htab_find_slot (dp
->visited
, *tp
, INSERT
);
3622 /* Keep iterating. */
3626 /* Called from finish_function to implement the named return value
3627 optimization by overriding all the RETURN_EXPRs and pertinent
3628 CLEANUP_STMTs and replacing all occurrences of VAR with RESULT, the
3629 RESULT_DECL for the function. */
3632 finalize_nrv (tree
*tp
, tree var
, tree result
)
3634 struct nrv_data data
;
3636 /* Copy name from VAR to RESULT. */
3637 DECL_NAME (result
) = DECL_NAME (var
);
3638 /* Don't forget that we take its address. */
3639 TREE_ADDRESSABLE (result
) = TREE_ADDRESSABLE (var
);
3640 /* Finally set DECL_VALUE_EXPR to avoid assigning
3641 a stack slot at -O0 for the original var and debug info
3642 uses RESULT location for VAR. */
3643 SET_DECL_VALUE_EXPR (var
, result
);
3644 DECL_HAS_VALUE_EXPR_P (var
) = 1;
3647 data
.result
= result
;
3648 data
.visited
= htab_create (37, htab_hash_pointer
, htab_eq_pointer
, NULL
);
3649 cp_walk_tree (tp
, finalize_nrv_r
, &data
, 0);
3650 htab_delete (data
.visited
);
3653 /* Create CP_OMP_CLAUSE_INFO for clause C. Returns true if it is invalid. */
3656 cxx_omp_create_clause_info (tree c
, tree type
, bool need_default_ctor
,
3657 bool need_copy_ctor
, bool need_copy_assignment
)
3659 int save_errorcount
= errorcount
;
3662 /* Always allocate 3 elements for simplicity. These are the
3663 function decls for the ctor, dtor, and assignment op.
3664 This layout is known to the three lang hooks,
3665 cxx_omp_clause_default_init, cxx_omp_clause_copy_init,
3666 and cxx_omp_clause_assign_op. */
3667 info
= make_tree_vec (3);
3668 CP_OMP_CLAUSE_INFO (c
) = info
;
3670 if (need_default_ctor
|| need_copy_ctor
)
3672 if (need_default_ctor
)
3673 t
= get_default_ctor (type
);
3675 t
= get_copy_ctor (type
);
3677 if (t
&& !trivial_fn_p (t
))
3678 TREE_VEC_ELT (info
, 0) = t
;
3681 if ((need_default_ctor
|| need_copy_ctor
)
3682 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
3683 TREE_VEC_ELT (info
, 1) = get_dtor (type
);
3685 if (need_copy_assignment
)
3687 t
= get_copy_assign (type
);
3689 if (t
&& !trivial_fn_p (t
))
3690 TREE_VEC_ELT (info
, 2) = t
;
3693 return errorcount
!= save_errorcount
;
3696 /* For all elements of CLAUSES, validate them vs OpenMP constraints.
3697 Remove any elements from the list that are invalid. */
3700 finish_omp_clauses (tree clauses
)
3702 bitmap_head generic_head
, firstprivate_head
, lastprivate_head
;
3703 tree c
, t
, *pc
= &clauses
;
3706 bitmap_obstack_initialize (NULL
);
3707 bitmap_initialize (&generic_head
, &bitmap_default_obstack
);
3708 bitmap_initialize (&firstprivate_head
, &bitmap_default_obstack
);
3709 bitmap_initialize (&lastprivate_head
, &bitmap_default_obstack
);
3711 for (pc
= &clauses
, c
= clauses
; c
; c
= *pc
)
3713 bool remove
= false;
3715 switch (OMP_CLAUSE_CODE (c
))
3717 case OMP_CLAUSE_SHARED
:
3719 goto check_dup_generic
;
3720 case OMP_CLAUSE_PRIVATE
:
3722 goto check_dup_generic
;
3723 case OMP_CLAUSE_REDUCTION
:
3725 goto check_dup_generic
;
3726 case OMP_CLAUSE_COPYPRIVATE
:
3727 name
= "copyprivate";
3728 goto check_dup_generic
;
3729 case OMP_CLAUSE_COPYIN
:
3731 goto check_dup_generic
;
3733 t
= OMP_CLAUSE_DECL (c
);
3734 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
3736 if (processing_template_decl
)
3739 error ("%qD is not a variable in clause %qs", t
, name
);
3741 error ("%qE is not a variable in clause %qs", t
, name
);
3744 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
3745 || bitmap_bit_p (&firstprivate_head
, DECL_UID (t
))
3746 || bitmap_bit_p (&lastprivate_head
, DECL_UID (t
)))
3748 error ("%qD appears more than once in data clauses", t
);
3752 bitmap_set_bit (&generic_head
, DECL_UID (t
));
3755 case OMP_CLAUSE_FIRSTPRIVATE
:
3756 t
= OMP_CLAUSE_DECL (c
);
3757 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
3759 if (processing_template_decl
)
3762 error ("%qD is not a variable in clause %<firstprivate%>", t
);
3764 error ("%qE is not a variable in clause %<firstprivate%>", t
);
3767 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
3768 || bitmap_bit_p (&firstprivate_head
, DECL_UID (t
)))
3770 error ("%qD appears more than once in data clauses", t
);
3774 bitmap_set_bit (&firstprivate_head
, DECL_UID (t
));
3777 case OMP_CLAUSE_LASTPRIVATE
:
3778 t
= OMP_CLAUSE_DECL (c
);
3779 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
3781 if (processing_template_decl
)
3784 error ("%qD is not a variable in clause %<lastprivate%>", t
);
3786 error ("%qE is not a variable in clause %<lastprivate%>", t
);
3789 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
3790 || bitmap_bit_p (&lastprivate_head
, DECL_UID (t
)))
3792 error ("%qD appears more than once in data clauses", t
);
3796 bitmap_set_bit (&lastprivate_head
, DECL_UID (t
));
3800 t
= OMP_CLAUSE_IF_EXPR (c
);
3801 t
= maybe_convert_cond (t
);
3802 if (t
== error_mark_node
)
3804 OMP_CLAUSE_IF_EXPR (c
) = t
;
3807 case OMP_CLAUSE_NUM_THREADS
:
3808 t
= OMP_CLAUSE_NUM_THREADS_EXPR (c
);
3809 if (t
== error_mark_node
)
3811 else if (!type_dependent_expression_p (t
)
3812 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
3814 error ("num_threads expression must be integral");
3819 case OMP_CLAUSE_SCHEDULE
:
3820 t
= OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c
);
3823 else if (t
== error_mark_node
)
3825 else if (!type_dependent_expression_p (t
)
3826 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
3828 error ("schedule chunk size expression must be integral");
3833 case OMP_CLAUSE_NOWAIT
:
3834 case OMP_CLAUSE_ORDERED
:
3835 case OMP_CLAUSE_DEFAULT
:
3836 case OMP_CLAUSE_UNTIED
:
3837 case OMP_CLAUSE_COLLAPSE
:
3845 *pc
= OMP_CLAUSE_CHAIN (c
);
3847 pc
= &OMP_CLAUSE_CHAIN (c
);
3850 for (pc
= &clauses
, c
= clauses
; c
; c
= *pc
)
3852 enum omp_clause_code c_kind
= OMP_CLAUSE_CODE (c
);
3853 bool remove
= false;
3854 bool need_complete_non_reference
= false;
3855 bool need_default_ctor
= false;
3856 bool need_copy_ctor
= false;
3857 bool need_copy_assignment
= false;
3858 bool need_implicitly_determined
= false;
3859 tree type
, inner_type
;
3863 case OMP_CLAUSE_SHARED
:
3865 need_implicitly_determined
= true;
3867 case OMP_CLAUSE_PRIVATE
:
3869 need_complete_non_reference
= true;
3870 need_default_ctor
= true;
3871 need_implicitly_determined
= true;
3873 case OMP_CLAUSE_FIRSTPRIVATE
:
3874 name
= "firstprivate";
3875 need_complete_non_reference
= true;
3876 need_copy_ctor
= true;
3877 need_implicitly_determined
= true;
3879 case OMP_CLAUSE_LASTPRIVATE
:
3880 name
= "lastprivate";
3881 need_complete_non_reference
= true;
3882 need_copy_assignment
= true;
3883 need_implicitly_determined
= true;
3885 case OMP_CLAUSE_REDUCTION
:
3887 need_implicitly_determined
= true;
3889 case OMP_CLAUSE_COPYPRIVATE
:
3890 name
= "copyprivate";
3891 need_copy_assignment
= true;
3893 case OMP_CLAUSE_COPYIN
:
3895 need_copy_assignment
= true;
3898 pc
= &OMP_CLAUSE_CHAIN (c
);
3902 t
= OMP_CLAUSE_DECL (c
);
3903 if (processing_template_decl
3904 && TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
3906 pc
= &OMP_CLAUSE_CHAIN (c
);
3912 case OMP_CLAUSE_LASTPRIVATE
:
3913 if (!bitmap_bit_p (&firstprivate_head
, DECL_UID (t
)))
3914 need_default_ctor
= true;
3917 case OMP_CLAUSE_REDUCTION
:
3918 if (AGGREGATE_TYPE_P (TREE_TYPE (t
))
3919 || POINTER_TYPE_P (TREE_TYPE (t
)))
3921 error ("%qE has invalid type for %<reduction%>", t
);
3924 else if (FLOAT_TYPE_P (TREE_TYPE (t
)))
3926 enum tree_code r_code
= OMP_CLAUSE_REDUCTION_CODE (c
);
3934 error ("%qE has invalid type for %<reduction(%s)%>",
3935 t
, operator_name_info
[r_code
].name
);
3941 case OMP_CLAUSE_COPYIN
:
3942 if (TREE_CODE (t
) != VAR_DECL
|| !DECL_THREAD_LOCAL_P (t
))
3944 error ("%qE must be %<threadprivate%> for %<copyin%>", t
);
3953 if (need_complete_non_reference
)
3955 t
= require_complete_type (t
);
3956 if (t
== error_mark_node
)
3958 else if (TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
)
3960 error ("%qE has reference type for %qs", t
, name
);
3964 if (need_implicitly_determined
)
3966 const char *share_name
= NULL
;
3968 if (TREE_CODE (t
) == VAR_DECL
&& DECL_THREAD_LOCAL_P (t
))
3969 share_name
= "threadprivate";
3970 else switch (cxx_omp_predetermined_sharing (t
))
3972 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
3974 case OMP_CLAUSE_DEFAULT_SHARED
:
3975 share_name
= "shared";
3977 case OMP_CLAUSE_DEFAULT_PRIVATE
:
3978 share_name
= "private";
3985 error ("%qE is predetermined %qs for %qs",
3986 t
, share_name
, name
);
3991 /* We're interested in the base element, not arrays. */
3992 inner_type
= type
= TREE_TYPE (t
);
3993 while (TREE_CODE (inner_type
) == ARRAY_TYPE
)
3994 inner_type
= TREE_TYPE (inner_type
);
3996 /* Check for special function availability by building a call to one.
3997 Save the results, because later we won't be in the right context
3998 for making these queries. */
3999 if (CLASS_TYPE_P (inner_type
)
4000 && (need_default_ctor
|| need_copy_ctor
|| need_copy_assignment
)
4001 && !type_dependent_expression_p (t
)
4002 && cxx_omp_create_clause_info (c
, inner_type
, need_default_ctor
,
4003 need_copy_ctor
, need_copy_assignment
))
4007 *pc
= OMP_CLAUSE_CHAIN (c
);
4009 pc
= &OMP_CLAUSE_CHAIN (c
);
4012 bitmap_obstack_release (NULL
);
4016 /* For all variables in the tree_list VARS, mark them as thread local. */
4019 finish_omp_threadprivate (tree vars
)
4023 /* Mark every variable in VARS to be assigned thread local storage. */
4024 for (t
= vars
; t
; t
= TREE_CHAIN (t
))
4026 tree v
= TREE_PURPOSE (t
);
4028 if (error_operand_p (v
))
4030 else if (TREE_CODE (v
) != VAR_DECL
)
4031 error ("%<threadprivate%> %qD is not file, namespace "
4032 "or block scope variable", v
);
4033 /* If V had already been marked threadprivate, it doesn't matter
4034 whether it had been used prior to this point. */
4035 else if (TREE_USED (v
)
4036 && (DECL_LANG_SPECIFIC (v
) == NULL
4037 || !CP_DECL_THREADPRIVATE_P (v
)))
4038 error ("%qE declared %<threadprivate%> after first use", v
);
4039 else if (! TREE_STATIC (v
) && ! DECL_EXTERNAL (v
))
4040 error ("automatic variable %qE cannot be %<threadprivate%>", v
);
4041 else if (! COMPLETE_TYPE_P (TREE_TYPE (v
)))
4042 error ("%<threadprivate%> %qE has incomplete type", v
);
4043 else if (TREE_STATIC (v
) && TYPE_P (CP_DECL_CONTEXT (v
))
4044 && CP_DECL_CONTEXT (v
) != current_class_type
)
4045 error ("%<threadprivate%> %qE directive not "
4046 "in %qT definition", v
, CP_DECL_CONTEXT (v
));
4049 /* Allocate a LANG_SPECIFIC structure for V, if needed. */
4050 if (DECL_LANG_SPECIFIC (v
) == NULL
)
4052 retrofit_lang_decl (v
);
4054 /* Make sure that DECL_DISCRIMINATOR_P continues to be true
4055 after the allocation of the lang_decl structure. */
4056 if (DECL_DISCRIMINATOR_P (v
))
4057 DECL_LANG_SPECIFIC (v
)->u
.base
.u2sel
= 1;
4060 if (! DECL_THREAD_LOCAL_P (v
))
4062 DECL_TLS_MODEL (v
) = decl_default_tls_model (v
);
4063 /* If rtl has been already set for this var, call
4064 make_decl_rtl once again, so that encode_section_info
4065 has a chance to look at the new decl flags. */
4066 if (DECL_RTL_SET_P (v
))
4069 CP_DECL_THREADPRIVATE_P (v
) = 1;
4074 /* Build an OpenMP structured block. */
4077 begin_omp_structured_block (void)
4079 return do_pushlevel (sk_omp
);
4083 finish_omp_structured_block (tree block
)
4085 return do_poplevel (block
);
4088 /* Similarly, except force the retention of the BLOCK. */
4091 begin_omp_parallel (void)
4093 keep_next_level (true);
4094 return begin_omp_structured_block ();
4098 finish_omp_parallel (tree clauses
, tree body
)
4102 body
= finish_omp_structured_block (body
);
4104 stmt
= make_node (OMP_PARALLEL
);
4105 TREE_TYPE (stmt
) = void_type_node
;
4106 OMP_PARALLEL_CLAUSES (stmt
) = clauses
;
4107 OMP_PARALLEL_BODY (stmt
) = body
;
4109 return add_stmt (stmt
);
4113 begin_omp_task (void)
4115 keep_next_level (true);
4116 return begin_omp_structured_block ();
4120 finish_omp_task (tree clauses
, tree body
)
4124 body
= finish_omp_structured_block (body
);
4126 stmt
= make_node (OMP_TASK
);
4127 TREE_TYPE (stmt
) = void_type_node
;
4128 OMP_TASK_CLAUSES (stmt
) = clauses
;
4129 OMP_TASK_BODY (stmt
) = body
;
4131 return add_stmt (stmt
);
4134 /* Helper function for finish_omp_for. Convert Ith random access iterator
4135 into integral iterator. Return FALSE if successful. */
4138 handle_omp_for_class_iterator (int i
, location_t locus
, tree declv
, tree initv
,
4139 tree condv
, tree incrv
, tree
*body
,
4140 tree
*pre_body
, tree clauses
)
4142 tree diff
, iter_init
, iter_incr
= NULL
, last
;
4143 tree incr_var
= NULL
, orig_pre_body
, orig_body
, c
;
4144 tree decl
= TREE_VEC_ELT (declv
, i
);
4145 tree init
= TREE_VEC_ELT (initv
, i
);
4146 tree cond
= TREE_VEC_ELT (condv
, i
);
4147 tree incr
= TREE_VEC_ELT (incrv
, i
);
4149 location_t elocus
= locus
;
4151 if (init
&& EXPR_HAS_LOCATION (init
))
4152 elocus
= EXPR_LOCATION (init
);
4154 switch (TREE_CODE (cond
))
4160 if (TREE_OPERAND (cond
, 1) == iter
)
4161 cond
= build2 (swap_tree_comparison (TREE_CODE (cond
)),
4162 TREE_TYPE (cond
), iter
, TREE_OPERAND (cond
, 0));
4163 if (TREE_OPERAND (cond
, 0) != iter
)
4164 cond
= error_mark_node
;
4167 tree tem
= build_x_binary_op (TREE_CODE (cond
), iter
, ERROR_MARK
,
4168 TREE_OPERAND (cond
, 1), ERROR_MARK
,
4169 NULL
, tf_warning_or_error
);
4170 if (error_operand_p (tem
))
4175 cond
= error_mark_node
;
4178 if (cond
== error_mark_node
)
4180 error_at (elocus
, "invalid controlling predicate");
4183 diff
= build_x_binary_op (MINUS_EXPR
, TREE_OPERAND (cond
, 1),
4184 ERROR_MARK
, iter
, ERROR_MARK
, NULL
,
4185 tf_warning_or_error
);
4186 if (error_operand_p (diff
))
4188 if (TREE_CODE (TREE_TYPE (diff
)) != INTEGER_TYPE
)
4190 error_at (elocus
, "difference between %qE and %qD does not have integer type",
4191 TREE_OPERAND (cond
, 1), iter
);
4195 switch (TREE_CODE (incr
))
4197 case PREINCREMENT_EXPR
:
4198 case PREDECREMENT_EXPR
:
4199 case POSTINCREMENT_EXPR
:
4200 case POSTDECREMENT_EXPR
:
4201 if (TREE_OPERAND (incr
, 0) != iter
)
4203 incr
= error_mark_node
;
4206 iter_incr
= build_x_unary_op (TREE_CODE (incr
), iter
,
4207 tf_warning_or_error
);
4208 if (error_operand_p (iter_incr
))
4210 else if (TREE_CODE (incr
) == PREINCREMENT_EXPR
4211 || TREE_CODE (incr
) == POSTINCREMENT_EXPR
)
4212 incr
= integer_one_node
;
4214 incr
= integer_minus_one_node
;
4217 if (TREE_OPERAND (incr
, 0) != iter
)
4218 incr
= error_mark_node
;
4219 else if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
4220 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
4222 tree rhs
= TREE_OPERAND (incr
, 1);
4223 if (TREE_OPERAND (rhs
, 0) == iter
)
4225 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs
, 1)))
4227 incr
= error_mark_node
;
4230 iter_incr
= build_x_modify_expr (iter
, TREE_CODE (rhs
),
4231 TREE_OPERAND (rhs
, 1),
4232 tf_warning_or_error
);
4233 if (error_operand_p (iter_incr
))
4235 incr
= TREE_OPERAND (rhs
, 1);
4236 incr
= cp_convert (TREE_TYPE (diff
), incr
);
4237 if (TREE_CODE (rhs
) == MINUS_EXPR
)
4239 incr
= build1 (NEGATE_EXPR
, TREE_TYPE (diff
), incr
);
4240 incr
= fold_if_not_in_template (incr
);
4242 if (TREE_CODE (incr
) != INTEGER_CST
4243 && (TREE_CODE (incr
) != NOP_EXPR
4244 || (TREE_CODE (TREE_OPERAND (incr
, 0))
4249 else if (TREE_OPERAND (rhs
, 1) == iter
)
4251 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs
, 0))) != INTEGER_TYPE
4252 || TREE_CODE (rhs
) != PLUS_EXPR
)
4253 incr
= error_mark_node
;
4256 iter_incr
= build_x_binary_op (PLUS_EXPR
,
4257 TREE_OPERAND (rhs
, 0),
4260 tf_warning_or_error
);
4261 if (error_operand_p (iter_incr
))
4263 iter_incr
= build_x_modify_expr (iter
, NOP_EXPR
,
4265 tf_warning_or_error
);
4266 if (error_operand_p (iter_incr
))
4268 incr
= TREE_OPERAND (rhs
, 0);
4273 incr
= error_mark_node
;
4276 incr
= error_mark_node
;
4279 incr
= error_mark_node
;
4283 if (incr
== error_mark_node
)
4285 error_at (elocus
, "invalid increment expression");
4289 incr
= cp_convert (TREE_TYPE (diff
), incr
);
4290 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
4291 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
4292 && OMP_CLAUSE_DECL (c
) == iter
)
4295 decl
= create_temporary_var (TREE_TYPE (diff
));
4297 add_decl_expr (decl
);
4298 last
= create_temporary_var (TREE_TYPE (diff
));
4300 add_decl_expr (last
);
4301 if (c
&& iter_incr
== NULL
)
4303 incr_var
= create_temporary_var (TREE_TYPE (diff
));
4304 pushdecl (incr_var
);
4305 add_decl_expr (incr_var
);
4307 gcc_assert (stmts_are_full_exprs_p ());
4309 orig_pre_body
= *pre_body
;
4310 *pre_body
= push_stmt_list ();
4312 add_stmt (orig_pre_body
);
4314 finish_expr_stmt (build_x_modify_expr (iter
, NOP_EXPR
, init
,
4315 tf_warning_or_error
));
4316 init
= build_int_cst (TREE_TYPE (diff
), 0);
4317 if (c
&& iter_incr
== NULL
)
4319 finish_expr_stmt (build_x_modify_expr (incr_var
, NOP_EXPR
,
4320 incr
, tf_warning_or_error
));
4322 iter_incr
= build_x_modify_expr (iter
, PLUS_EXPR
, incr
,
4323 tf_warning_or_error
);
4325 finish_expr_stmt (build_x_modify_expr (last
, NOP_EXPR
, init
,
4326 tf_warning_or_error
));
4327 *pre_body
= pop_stmt_list (*pre_body
);
4329 cond
= cp_build_binary_op (elocus
,
4330 TREE_CODE (cond
), decl
, diff
,
4331 tf_warning_or_error
);
4332 incr
= build_modify_expr (elocus
, decl
, NULL_TREE
, PLUS_EXPR
,
4333 elocus
, incr
, NULL_TREE
);
4336 *body
= push_stmt_list ();
4337 iter_init
= build2 (MINUS_EXPR
, TREE_TYPE (diff
), decl
, last
);
4338 iter_init
= build_x_modify_expr (iter
, PLUS_EXPR
, iter_init
,
4339 tf_warning_or_error
);
4340 iter_init
= build1 (NOP_EXPR
, void_type_node
, iter_init
);
4341 finish_expr_stmt (iter_init
);
4342 finish_expr_stmt (build_x_modify_expr (last
, NOP_EXPR
, decl
,
4343 tf_warning_or_error
));
4344 add_stmt (orig_body
);
4345 *body
= pop_stmt_list (*body
);
4349 OMP_CLAUSE_LASTPRIVATE_STMT (c
) = push_stmt_list ();
4350 finish_expr_stmt (iter_incr
);
4351 OMP_CLAUSE_LASTPRIVATE_STMT (c
)
4352 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (c
));
4355 TREE_VEC_ELT (declv
, i
) = decl
;
4356 TREE_VEC_ELT (initv
, i
) = init
;
4357 TREE_VEC_ELT (condv
, i
) = cond
;
4358 TREE_VEC_ELT (incrv
, i
) = incr
;
4363 /* Build and validate an OMP_FOR statement. CLAUSES, BODY, COND, INCR
4364 are directly for their associated operands in the statement. DECL
4365 and INIT are a combo; if DECL is NULL then INIT ought to be a
4366 MODIFY_EXPR, and the DECL should be extracted. PRE_BODY are
4367 optional statements that need to go before the loop into its
4371 finish_omp_for (location_t locus
, tree declv
, tree initv
, tree condv
,
4372 tree incrv
, tree body
, tree pre_body
, tree clauses
)
4374 tree omp_for
= NULL
, orig_incr
= NULL
;
4375 tree decl
, init
, cond
, incr
;
4379 gcc_assert (TREE_VEC_LENGTH (declv
) == TREE_VEC_LENGTH (initv
));
4380 gcc_assert (TREE_VEC_LENGTH (declv
) == TREE_VEC_LENGTH (condv
));
4381 gcc_assert (TREE_VEC_LENGTH (declv
) == TREE_VEC_LENGTH (incrv
));
4382 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
4384 decl
= TREE_VEC_ELT (declv
, i
);
4385 init
= TREE_VEC_ELT (initv
, i
);
4386 cond
= TREE_VEC_ELT (condv
, i
);
4387 incr
= TREE_VEC_ELT (incrv
, i
);
4393 switch (TREE_CODE (init
))
4396 decl
= TREE_OPERAND (init
, 0);
4397 init
= TREE_OPERAND (init
, 1);
4400 if (TREE_CODE (TREE_OPERAND (init
, 1)) == NOP_EXPR
)
4402 decl
= TREE_OPERAND (init
, 0);
4403 init
= TREE_OPERAND (init
, 2);
4413 "expected iteration declaration or initialization");
4418 if (init
&& EXPR_HAS_LOCATION (init
))
4419 elocus
= EXPR_LOCATION (init
);
4423 error_at (elocus
, "missing controlling predicate");
4429 error_at (elocus
, "missing increment expression");
4433 TREE_VEC_ELT (declv
, i
) = decl
;
4434 TREE_VEC_ELT (initv
, i
) = init
;
4437 if (dependent_omp_for_p (declv
, initv
, condv
, incrv
))
4441 stmt
= make_node (OMP_FOR
);
4443 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
4445 /* This is really just a place-holder. We'll be decomposing this
4446 again and going through the cp_build_modify_expr path below when
4447 we instantiate the thing. */
4448 TREE_VEC_ELT (initv
, i
)
4449 = build2 (MODIFY_EXPR
, void_type_node
, TREE_VEC_ELT (declv
, i
),
4450 TREE_VEC_ELT (initv
, i
));
4453 TREE_TYPE (stmt
) = void_type_node
;
4454 OMP_FOR_INIT (stmt
) = initv
;
4455 OMP_FOR_COND (stmt
) = condv
;
4456 OMP_FOR_INCR (stmt
) = incrv
;
4457 OMP_FOR_BODY (stmt
) = body
;
4458 OMP_FOR_PRE_BODY (stmt
) = pre_body
;
4459 OMP_FOR_CLAUSES (stmt
) = clauses
;
4461 SET_EXPR_LOCATION (stmt
, locus
);
4462 return add_stmt (stmt
);
4465 if (processing_template_decl
)
4466 orig_incr
= make_tree_vec (TREE_VEC_LENGTH (incrv
));
4468 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); )
4470 decl
= TREE_VEC_ELT (declv
, i
);
4471 init
= TREE_VEC_ELT (initv
, i
);
4472 cond
= TREE_VEC_ELT (condv
, i
);
4473 incr
= TREE_VEC_ELT (incrv
, i
);
4475 TREE_VEC_ELT (orig_incr
, i
) = incr
;
4478 if (init
&& EXPR_HAS_LOCATION (init
))
4479 elocus
= EXPR_LOCATION (init
);
4483 error_at (elocus
, "expected iteration declaration or initialization");
4487 if (incr
&& TREE_CODE (incr
) == MODOP_EXPR
)
4490 TREE_VEC_ELT (orig_incr
, i
) = incr
;
4491 incr
= cp_build_modify_expr (TREE_OPERAND (incr
, 0),
4492 TREE_CODE (TREE_OPERAND (incr
, 1)),
4493 TREE_OPERAND (incr
, 2),
4494 tf_warning_or_error
);
4497 if (CLASS_TYPE_P (TREE_TYPE (decl
)))
4499 if (handle_omp_for_class_iterator (i
, locus
, declv
, initv
, condv
,
4500 incrv
, &body
, &pre_body
, clauses
))
4505 if (!INTEGRAL_TYPE_P (TREE_TYPE (decl
))
4506 && TREE_CODE (TREE_TYPE (decl
)) != POINTER_TYPE
)
4508 error_at (elocus
, "invalid type for iteration variable %qE", decl
);
4512 if (!processing_template_decl
)
4514 init
= fold_build_cleanup_point_expr (TREE_TYPE (init
), init
);
4515 init
= cp_build_modify_expr (decl
, NOP_EXPR
, init
, tf_warning_or_error
);
4518 init
= build2 (MODIFY_EXPR
, void_type_node
, decl
, init
);
4520 && TREE_SIDE_EFFECTS (cond
)
4521 && COMPARISON_CLASS_P (cond
)
4522 && !processing_template_decl
)
4524 tree t
= TREE_OPERAND (cond
, 0);
4525 if (TREE_SIDE_EFFECTS (t
)
4527 && (TREE_CODE (t
) != NOP_EXPR
4528 || TREE_OPERAND (t
, 0) != decl
))
4529 TREE_OPERAND (cond
, 0)
4530 = fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4532 t
= TREE_OPERAND (cond
, 1);
4533 if (TREE_SIDE_EFFECTS (t
)
4535 && (TREE_CODE (t
) != NOP_EXPR
4536 || TREE_OPERAND (t
, 0) != decl
))
4537 TREE_OPERAND (cond
, 1)
4538 = fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4540 if (decl
== error_mark_node
|| init
== error_mark_node
)
4543 TREE_VEC_ELT (declv
, i
) = decl
;
4544 TREE_VEC_ELT (initv
, i
) = init
;
4545 TREE_VEC_ELT (condv
, i
) = cond
;
4546 TREE_VEC_ELT (incrv
, i
) = incr
;
4550 if (IS_EMPTY_STMT (pre_body
))
4553 omp_for
= c_finish_omp_for (locus
, declv
, initv
, condv
, incrv
,
4556 if (omp_for
== NULL
)
4559 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INCR (omp_for
)); i
++)
4561 decl
= TREE_OPERAND (TREE_VEC_ELT (OMP_FOR_INIT (omp_for
), i
), 0);
4562 incr
= TREE_VEC_ELT (OMP_FOR_INCR (omp_for
), i
);
4564 if (TREE_CODE (incr
) != MODIFY_EXPR
)
4567 if (TREE_SIDE_EFFECTS (TREE_OPERAND (incr
, 1))
4568 && BINARY_CLASS_P (TREE_OPERAND (incr
, 1))
4569 && !processing_template_decl
)
4571 tree t
= TREE_OPERAND (TREE_OPERAND (incr
, 1), 0);
4572 if (TREE_SIDE_EFFECTS (t
)
4574 && (TREE_CODE (t
) != NOP_EXPR
4575 || TREE_OPERAND (t
, 0) != decl
))
4576 TREE_OPERAND (TREE_OPERAND (incr
, 1), 0)
4577 = fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4579 t
= TREE_OPERAND (TREE_OPERAND (incr
, 1), 1);
4580 if (TREE_SIDE_EFFECTS (t
)
4582 && (TREE_CODE (t
) != NOP_EXPR
4583 || TREE_OPERAND (t
, 0) != decl
))
4584 TREE_OPERAND (TREE_OPERAND (incr
, 1), 1)
4585 = fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4589 TREE_VEC_ELT (OMP_FOR_INCR (omp_for
), i
) = TREE_VEC_ELT (orig_incr
, i
);
4591 if (omp_for
!= NULL
)
4592 OMP_FOR_CLAUSES (omp_for
) = clauses
;
4597 finish_omp_atomic (enum tree_code code
, tree lhs
, tree rhs
)
4606 dependent_p
= false;
4609 /* Even in a template, we can detect invalid uses of the atomic
4610 pragma if neither LHS nor RHS is type-dependent. */
4611 if (processing_template_decl
)
4613 dependent_p
= (type_dependent_expression_p (lhs
)
4614 || type_dependent_expression_p (rhs
));
4617 lhs
= build_non_dependent_expr (lhs
);
4618 rhs
= build_non_dependent_expr (rhs
);
4623 stmt
= c_finish_omp_atomic (input_location
, code
, lhs
, rhs
);
4624 if (stmt
== error_mark_node
)
4627 if (processing_template_decl
)
4628 stmt
= build2 (OMP_ATOMIC
, void_type_node
, integer_zero_node
,
4629 build2 (code
, void_type_node
, orig_lhs
, orig_rhs
));
4634 finish_omp_barrier (void)
4636 tree fn
= built_in_decls
[BUILT_IN_GOMP_BARRIER
];
4637 VEC(tree
,gc
) *vec
= make_tree_vector ();
4638 tree stmt
= finish_call_expr (fn
, &vec
, false, false, tf_warning_or_error
);
4639 release_tree_vector (vec
);
4640 finish_expr_stmt (stmt
);
4644 finish_omp_flush (void)
4646 tree fn
= built_in_decls
[BUILT_IN_SYNCHRONIZE
];
4647 VEC(tree
,gc
) *vec
= make_tree_vector ();
4648 tree stmt
= finish_call_expr (fn
, &vec
, false, false, tf_warning_or_error
);
4649 release_tree_vector (vec
);
4650 finish_expr_stmt (stmt
);
4654 finish_omp_taskwait (void)
4656 tree fn
= built_in_decls
[BUILT_IN_GOMP_TASKWAIT
];
4657 VEC(tree
,gc
) *vec
= make_tree_vector ();
4658 tree stmt
= finish_call_expr (fn
, &vec
, false, false, tf_warning_or_error
);
4659 release_tree_vector (vec
);
4660 finish_expr_stmt (stmt
);
4664 init_cp_semantics (void)
4668 /* Build a STATIC_ASSERT for a static assertion with the condition
4669 CONDITION and the message text MESSAGE. LOCATION is the location
4670 of the static assertion in the source code. When MEMBER_P, this
4671 static assertion is a member of a class. */
4673 finish_static_assert (tree condition
, tree message
, location_t location
,
4676 if (check_for_bare_parameter_packs (condition
))
4677 condition
= error_mark_node
;
4679 if (type_dependent_expression_p (condition
)
4680 || value_dependent_expression_p (condition
))
4682 /* We're in a template; build a STATIC_ASSERT and put it in
4686 assertion
= make_node (STATIC_ASSERT
);
4687 STATIC_ASSERT_CONDITION (assertion
) = condition
;
4688 STATIC_ASSERT_MESSAGE (assertion
) = message
;
4689 STATIC_ASSERT_SOURCE_LOCATION (assertion
) = location
;
4692 maybe_add_class_template_decl_list (current_class_type
,
4696 add_stmt (assertion
);
4701 /* Fold the expression and convert it to a boolean value. */
4702 condition
= fold_non_dependent_expr (condition
);
4703 condition
= cp_convert (boolean_type_node
, condition
);
4704 condition
= maybe_constant_value (condition
);
4706 if (TREE_CODE (condition
) == INTEGER_CST
&& !integer_zerop (condition
))
4707 /* Do nothing; the condition is satisfied. */
4711 location_t saved_loc
= input_location
;
4713 input_location
= location
;
4714 if (TREE_CODE (condition
) == INTEGER_CST
4715 && integer_zerop (condition
))
4716 /* Report the error. */
4717 error ("static assertion failed: %E", message
);
4718 else if (condition
&& condition
!= error_mark_node
)
4720 error ("non-constant condition for static assertion");
4721 cxx_constant_value (condition
);
4723 input_location
= saved_loc
;
4727 /* Returns the type of EXPR for cases where we can determine it even though
4728 EXPR is a type-dependent expression. */
4731 describable_type (tree expr
)
4733 tree type
= NULL_TREE
;
4735 if (! type_dependent_expression_p (expr
)
4736 && ! type_unknown_p (expr
))
4738 type
= unlowered_expr_type (expr
);
4739 if (real_lvalue_p (expr
))
4740 type
= build_reference_type (type
);
4746 switch (TREE_CODE (expr
))
4752 return TREE_TYPE (expr
);
4757 case TEMPLATE_PARM_INDEX
:
4759 case STATIC_CAST_EXPR
:
4760 case REINTERPRET_CAST_EXPR
:
4761 case CONST_CAST_EXPR
:
4762 case DYNAMIC_CAST_EXPR
:
4763 type
= TREE_TYPE (expr
);
4768 tree ptrtype
= describable_type (TREE_OPERAND (expr
, 0));
4769 if (ptrtype
&& POINTER_TYPE_P (ptrtype
))
4770 type
= build_reference_type (TREE_TYPE (ptrtype
));
4775 if (TREE_CODE_CLASS (TREE_CODE (expr
)) == tcc_constant
)
4776 type
= TREE_TYPE (expr
);
4780 if (type
&& type_uses_auto (type
))
4786 /* Implements the C++0x decltype keyword. Returns the type of EXPR,
4787 suitable for use as a type-specifier.
4789 ID_EXPRESSION_OR_MEMBER_ACCESS_P is true when EXPR was parsed as an
4790 id-expression or a class member access, FALSE when it was parsed as
4791 a full expression. */
4794 finish_decltype_type (tree expr
, bool id_expression_or_member_access_p
)
4796 tree orig_expr
= expr
;
4797 tree type
= NULL_TREE
;
4799 if (!expr
|| error_operand_p (expr
))
4800 return error_mark_node
;
4803 || TREE_CODE (expr
) == TYPE_DECL
4804 || (TREE_CODE (expr
) == BIT_NOT_EXPR
4805 && TYPE_P (TREE_OPERAND (expr
, 0))))
4807 error ("argument to decltype must be an expression");
4808 return error_mark_node
;
4811 /* FIXME instantiation-dependent */
4812 if (type_dependent_expression_p (expr
)
4813 /* In a template, a COMPONENT_REF has an IDENTIFIER_NODE for op1 even
4814 if it isn't dependent, so that we can check access control at
4815 instantiation time, so defer the decltype as well (PR 42277). */
4816 || (id_expression_or_member_access_p
4817 && processing_template_decl
4818 && TREE_CODE (expr
) == COMPONENT_REF
))
4820 type
= cxx_make_type (DECLTYPE_TYPE
);
4821 DECLTYPE_TYPE_EXPR (type
) = expr
;
4822 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type
)
4823 = id_expression_or_member_access_p
;
4824 SET_TYPE_STRUCTURAL_EQUALITY (type
);
4829 /* The type denoted by decltype(e) is defined as follows: */
4831 expr
= resolve_nondeduced_context (expr
);
4833 /* To get the size of a static data member declared as an array of
4834 unknown bound, we need to instantiate it. */
4835 if (TREE_CODE (expr
) == VAR_DECL
4836 && VAR_HAD_UNKNOWN_BOUND (expr
)
4837 && DECL_TEMPLATE_INSTANTIATION (expr
))
4838 instantiate_decl (expr
, /*defer_ok*/true, /*expl_inst_mem*/false);
4840 if (id_expression_or_member_access_p
)
4842 /* If e is an id-expression or a class member access (5.2.5
4843 [expr.ref]), decltype(e) is defined as the type of the entity
4844 named by e. If there is no such entity, or e names a set of
4845 overloaded functions, the program is ill-formed. */
4846 if (TREE_CODE (expr
) == IDENTIFIER_NODE
)
4847 expr
= lookup_name (expr
);
4849 if (TREE_CODE (expr
) == INDIRECT_REF
)
4850 /* This can happen when the expression is, e.g., "a.b". Just
4851 look at the underlying operand. */
4852 expr
= TREE_OPERAND (expr
, 0);
4854 if (TREE_CODE (expr
) == OFFSET_REF
4855 || TREE_CODE (expr
) == MEMBER_REF
)
4856 /* We're only interested in the field itself. If it is a
4857 BASELINK, we will need to see through it in the next
4859 expr
= TREE_OPERAND (expr
, 1);
4861 if (TREE_CODE (expr
) == BASELINK
)
4862 /* See through BASELINK nodes to the underlying functions. */
4863 expr
= BASELINK_FUNCTIONS (expr
);
4865 if (TREE_CODE (expr
) == TEMPLATE_ID_EXPR
)
4866 expr
= TREE_OPERAND (expr
, 0);
4868 if (TREE_CODE (expr
) == OVERLOAD
)
4870 if (OVL_CHAIN (expr
)
4871 || TREE_CODE (OVL_FUNCTION (expr
)) == TEMPLATE_DECL
)
4873 error ("%qE refers to a set of overloaded functions", orig_expr
);
4874 return error_mark_node
;
4877 /* An overload set containing only one function: just look
4878 at that function. */
4879 expr
= OVL_FUNCTION (expr
);
4882 switch (TREE_CODE (expr
))
4885 if (DECL_BIT_FIELD_TYPE (expr
))
4887 type
= DECL_BIT_FIELD_TYPE (expr
);
4890 /* Fall through for fields that aren't bitfields. */
4897 case TEMPLATE_PARM_INDEX
:
4898 expr
= mark_type_use (expr
);
4899 type
= TREE_TYPE (expr
);
4903 type
= error_mark_node
;
4907 mark_type_use (expr
);
4908 type
= is_bitfield_expr_with_lowered_type (expr
);
4910 type
= TREE_TYPE (TREE_OPERAND (expr
, 1));
4917 /* We can get here when the id-expression refers to an
4919 type
= TREE_TYPE (expr
);
4923 gcc_assert (TYPE_P (expr
) || DECL_P (expr
)
4924 || TREE_CODE (expr
) == SCOPE_REF
);
4925 error ("argument to decltype must be an expression");
4926 return error_mark_node
;
4931 /* Within a lambda-expression:
4933 Every occurrence of decltype((x)) where x is a possibly
4934 parenthesized id-expression that names an entity of
4935 automatic storage duration is treated as if x were
4936 transformed into an access to a corresponding data member
4937 of the closure type that would have been declared if x
4938 were a use of the denoted entity. */
4939 if (outer_automatic_var_p (expr
)
4940 && current_function_decl
4941 && LAMBDA_FUNCTION_P (current_function_decl
))
4942 type
= capture_decltype (expr
);
4943 else if (error_operand_p (expr
))
4944 type
= error_mark_node
;
4945 else if (expr
== current_class_ptr
)
4946 /* If the expression is just "this", we want the
4947 cv-unqualified pointer for the "this" type. */
4948 type
= TYPE_MAIN_VARIANT (TREE_TYPE (expr
));
4951 /* Otherwise, where T is the type of e, if e is an lvalue,
4952 decltype(e) is defined as T&; if an xvalue, T&&; otherwise, T. */
4953 cp_lvalue_kind clk
= lvalue_kind (expr
);
4954 type
= unlowered_expr_type (expr
);
4955 gcc_assert (TREE_CODE (type
) != REFERENCE_TYPE
);
4956 if (clk
!= clk_none
&& !(clk
& clk_class
))
4957 type
= cp_build_reference_type (type
, (clk
& clk_rvalueref
));
4961 if (!type
|| type
== unknown_type_node
)
4963 error ("type of %qE is unknown", expr
);
4964 return error_mark_node
;
4970 /* Called from trait_expr_value to evaluate either __has_nothrow_assign or
4971 __has_nothrow_copy, depending on assign_p. */
4974 classtype_has_nothrow_assign_or_copy_p (tree type
, bool assign_p
)
4981 ix
= lookup_fnfields_1 (type
, ansi_assopname (NOP_EXPR
));
4984 fns
= VEC_index (tree
, CLASSTYPE_METHOD_VEC (type
), ix
);
4986 else if (TYPE_HAS_COPY_CTOR (type
))
4988 /* If construction of the copy constructor was postponed, create
4990 if (CLASSTYPE_LAZY_COPY_CTOR (type
))
4991 lazily_declare_fn (sfk_copy_constructor
, type
);
4992 if (CLASSTYPE_LAZY_MOVE_CTOR (type
))
4993 lazily_declare_fn (sfk_move_constructor
, type
);
4994 fns
= CLASSTYPE_CONSTRUCTORS (type
);
4999 for (; fns
; fns
= OVL_NEXT (fns
))
5001 tree fn
= OVL_CURRENT (fns
);
5005 if (copy_fn_p (fn
) == 0)
5008 else if (copy_fn_p (fn
) <= 0)
5011 if (!TYPE_NOTHROW_P (TREE_TYPE (fn
)))
5018 /* Actually evaluates the trait. */
5021 trait_expr_value (cp_trait_kind kind
, tree type1
, tree type2
)
5023 enum tree_code type_code1
;
5026 type_code1
= TREE_CODE (type1
);
5030 case CPTK_HAS_NOTHROW_ASSIGN
:
5031 type1
= strip_array_types (type1
);
5032 return (!CP_TYPE_CONST_P (type1
) && type_code1
!= REFERENCE_TYPE
5033 && (trait_expr_value (CPTK_HAS_TRIVIAL_ASSIGN
, type1
, type2
)
5034 || (CLASS_TYPE_P (type1
)
5035 && classtype_has_nothrow_assign_or_copy_p (type1
,
5038 case CPTK_HAS_TRIVIAL_ASSIGN
:
5039 /* ??? The standard seems to be missing the "or array of such a class
5040 type" wording for this trait. */
5041 type1
= strip_array_types (type1
);
5042 return (!CP_TYPE_CONST_P (type1
) && type_code1
!= REFERENCE_TYPE
5043 && (trivial_type_p (type1
)
5044 || (CLASS_TYPE_P (type1
)
5045 && TYPE_HAS_TRIVIAL_COPY_ASSIGN (type1
))));
5047 case CPTK_HAS_NOTHROW_CONSTRUCTOR
:
5048 type1
= strip_array_types (type1
);
5049 return (trait_expr_value (CPTK_HAS_TRIVIAL_CONSTRUCTOR
, type1
, type2
)
5050 || (CLASS_TYPE_P (type1
)
5051 && (t
= locate_ctor (type1
))
5052 && TYPE_NOTHROW_P (TREE_TYPE (t
))));
5054 case CPTK_HAS_TRIVIAL_CONSTRUCTOR
:
5055 type1
= strip_array_types (type1
);
5056 return (trivial_type_p (type1
)
5057 || (CLASS_TYPE_P (type1
) && TYPE_HAS_TRIVIAL_DFLT (type1
)));
5059 case CPTK_HAS_NOTHROW_COPY
:
5060 type1
= strip_array_types (type1
);
5061 return (trait_expr_value (CPTK_HAS_TRIVIAL_COPY
, type1
, type2
)
5062 || (CLASS_TYPE_P (type1
)
5063 && classtype_has_nothrow_assign_or_copy_p (type1
, false)));
5065 case CPTK_HAS_TRIVIAL_COPY
:
5066 /* ??? The standard seems to be missing the "or array of such a class
5067 type" wording for this trait. */
5068 type1
= strip_array_types (type1
);
5069 return (trivial_type_p (type1
) || type_code1
== REFERENCE_TYPE
5070 || (CLASS_TYPE_P (type1
) && TYPE_HAS_TRIVIAL_COPY_CTOR (type1
)));
5072 case CPTK_HAS_TRIVIAL_DESTRUCTOR
:
5073 type1
= strip_array_types (type1
);
5074 return (trivial_type_p (type1
) || type_code1
== REFERENCE_TYPE
5075 || (CLASS_TYPE_P (type1
)
5076 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type1
)));
5078 case CPTK_HAS_VIRTUAL_DESTRUCTOR
:
5079 return type_has_virtual_destructor (type1
);
5081 case CPTK_IS_ABSTRACT
:
5082 return (CLASS_TYPE_P (type1
) && CLASSTYPE_PURE_VIRTUALS (type1
));
5084 case CPTK_IS_BASE_OF
:
5085 return (NON_UNION_CLASS_TYPE_P (type1
) && NON_UNION_CLASS_TYPE_P (type2
)
5086 && DERIVED_FROM_P (type1
, type2
));
5089 return (NON_UNION_CLASS_TYPE_P (type1
));
5091 case CPTK_IS_CONVERTIBLE_TO
:
5096 return (NON_UNION_CLASS_TYPE_P (type1
) && CLASSTYPE_EMPTY_P (type1
));
5099 return (type_code1
== ENUMERAL_TYPE
);
5102 return (pod_type_p (type1
));
5104 case CPTK_IS_POLYMORPHIC
:
5105 return (CLASS_TYPE_P (type1
) && TYPE_POLYMORPHIC_P (type1
));
5107 case CPTK_IS_STD_LAYOUT
:
5108 return (std_layout_type_p (type1
));
5110 case CPTK_IS_TRIVIAL
:
5111 return (trivial_type_p (type1
));
5114 return (type_code1
== UNION_TYPE
);
5116 case CPTK_IS_LITERAL_TYPE
:
5117 return (literal_type_p (type1
));
5125 /* Returns true if TYPE is a complete type, an array of unknown bound,
5126 or (possibly cv-qualified) void, returns false otherwise. */
5129 check_trait_type (tree type
)
5131 if (COMPLETE_TYPE_P (type
))
5134 if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
)
5135 && COMPLETE_TYPE_P (TREE_TYPE (type
)))
5138 if (VOID_TYPE_P (type
))
5144 /* Process a trait expression. */
5147 finish_trait_expr (cp_trait_kind kind
, tree type1
, tree type2
)
5149 gcc_assert (kind
== CPTK_HAS_NOTHROW_ASSIGN
5150 || kind
== CPTK_HAS_NOTHROW_CONSTRUCTOR
5151 || kind
== CPTK_HAS_NOTHROW_COPY
5152 || kind
== CPTK_HAS_TRIVIAL_ASSIGN
5153 || kind
== CPTK_HAS_TRIVIAL_CONSTRUCTOR
5154 || kind
== CPTK_HAS_TRIVIAL_COPY
5155 || kind
== CPTK_HAS_TRIVIAL_DESTRUCTOR
5156 || kind
== CPTK_HAS_VIRTUAL_DESTRUCTOR
5157 || kind
== CPTK_IS_ABSTRACT
5158 || kind
== CPTK_IS_BASE_OF
5159 || kind
== CPTK_IS_CLASS
5160 || kind
== CPTK_IS_CONVERTIBLE_TO
5161 || kind
== CPTK_IS_EMPTY
5162 || kind
== CPTK_IS_ENUM
5163 || kind
== CPTK_IS_POD
5164 || kind
== CPTK_IS_POLYMORPHIC
5165 || kind
== CPTK_IS_STD_LAYOUT
5166 || kind
== CPTK_IS_TRIVIAL
5167 || kind
== CPTK_IS_LITERAL_TYPE
5168 || kind
== CPTK_IS_UNION
);
5170 if (kind
== CPTK_IS_CONVERTIBLE_TO
)
5172 sorry ("__is_convertible_to");
5173 return error_mark_node
;
5176 if (type1
== error_mark_node
5177 || ((kind
== CPTK_IS_BASE_OF
|| kind
== CPTK_IS_CONVERTIBLE_TO
)
5178 && type2
== error_mark_node
))
5179 return error_mark_node
;
5181 if (processing_template_decl
)
5183 tree trait_expr
= make_node (TRAIT_EXPR
);
5184 TREE_TYPE (trait_expr
) = boolean_type_node
;
5185 TRAIT_EXPR_TYPE1 (trait_expr
) = type1
;
5186 TRAIT_EXPR_TYPE2 (trait_expr
) = type2
;
5187 TRAIT_EXPR_KIND (trait_expr
) = kind
;
5191 complete_type (type1
);
5193 complete_type (type2
);
5197 case CPTK_HAS_NOTHROW_ASSIGN
:
5198 case CPTK_HAS_TRIVIAL_ASSIGN
:
5199 case CPTK_HAS_NOTHROW_CONSTRUCTOR
:
5200 case CPTK_HAS_TRIVIAL_CONSTRUCTOR
:
5201 case CPTK_HAS_NOTHROW_COPY
:
5202 case CPTK_HAS_TRIVIAL_COPY
:
5203 case CPTK_HAS_TRIVIAL_DESTRUCTOR
:
5204 case CPTK_HAS_VIRTUAL_DESTRUCTOR
:
5205 case CPTK_IS_ABSTRACT
:
5208 case CPTK_IS_POLYMORPHIC
:
5209 case CPTK_IS_STD_LAYOUT
:
5210 case CPTK_IS_TRIVIAL
:
5211 case CPTK_IS_LITERAL_TYPE
:
5212 if (!check_trait_type (type1
))
5214 error ("incomplete type %qT not allowed", type1
);
5215 return error_mark_node
;
5219 case CPTK_IS_BASE_OF
:
5220 if (NON_UNION_CLASS_TYPE_P (type1
) && NON_UNION_CLASS_TYPE_P (type2
)
5221 && !same_type_ignoring_top_level_qualifiers_p (type1
, type2
)
5222 && !COMPLETE_TYPE_P (type2
))
5224 error ("incomplete type %qT not allowed", type2
);
5225 return error_mark_node
;
5234 case CPTK_IS_CONVERTIBLE_TO
:
5239 return (trait_expr_value (kind
, type1
, type2
)
5240 ? boolean_true_node
: boolean_false_node
);
5243 /* Do-nothing variants of functions to handle pragma FLOAT_CONST_DECIMAL64,
5244 which is ignored for C++. */
5247 set_float_const_decimal64 (void)
5252 clear_float_const_decimal64 (void)
5257 float_const_decimal64_p (void)
5263 /* Return true if T is a literal type. */
5266 literal_type_p (tree t
)
5268 if (SCALAR_TYPE_P (t
))
5270 if (CLASS_TYPE_P (t
))
5271 return CLASSTYPE_LITERAL_P (t
);
5272 if (TREE_CODE (t
) == ARRAY_TYPE
)
5273 return literal_type_p (strip_array_types (t
));
5277 /* If DECL is a variable declared `constexpr', require its type
5278 be literal. Return the DECL if OK, otherwise NULL. */
5281 ensure_literal_type_for_constexpr_object (tree decl
)
5283 tree type
= TREE_TYPE (decl
);
5284 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_DECLARED_CONSTEXPR_P (decl
)
5285 && !processing_template_decl
5286 /* The call to complete_type is just for initializer_list. */
5287 && !literal_type_p (complete_type (type
)))
5289 error ("the type %qT of constexpr variable %qD is not literal",
5296 /* Representation of entries in the constexpr function definition table. */
5298 typedef struct GTY(()) constexpr_fundef
{
5303 /* This table holds all constexpr function definitions seen in
5304 the current translation unit. */
5306 static GTY ((param_is (constexpr_fundef
))) htab_t constexpr_fundef_table
;
5308 /* Utility function used for managing the constexpr function table.
5309 Return true if the entries pointed to by P and Q are for the
5310 same constexpr function. */
5313 constexpr_fundef_equal (const void *p
, const void *q
)
5315 const constexpr_fundef
*lhs
= (const constexpr_fundef
*) p
;
5316 const constexpr_fundef
*rhs
= (const constexpr_fundef
*) q
;
5317 return lhs
->decl
== rhs
->decl
;
5320 /* Utility function used for managing the constexpr function table.
5321 Return a hash value for the entry pointed to by Q. */
5323 static inline hashval_t
5324 constexpr_fundef_hash (const void *p
)
5326 const constexpr_fundef
*fundef
= (const constexpr_fundef
*) p
;
5327 return DECL_UID (fundef
->decl
);
5330 /* Return a previously saved definition of function FUN. */
5332 static constexpr_fundef
*
5333 retrieve_constexpr_fundef (tree fun
)
5335 constexpr_fundef fundef
= { NULL
, NULL
};
5336 if (constexpr_fundef_table
== NULL
)
5340 return (constexpr_fundef
*) htab_find (constexpr_fundef_table
, &fundef
);
5343 /* Return true if type expression T is a valid parameter type, or
5344 a valid return type, of a constexpr function. */
5347 valid_type_in_constexpr_fundecl_p (tree t
)
5349 return (literal_type_p (t
)
5350 /* FIXME we allow ref to non-literal; should change standard to
5351 match, or change back if not. */
5352 || TREE_CODE (t
) == REFERENCE_TYPE
);
5355 /* Check whether the parameter and return types of FUN are valid for a
5356 constexpr function, and complain if COMPLAIN. */
5359 is_valid_constexpr_fn (tree fun
, bool complain
)
5361 tree parm
= FUNCTION_FIRST_USER_PARM (fun
);
5363 for (; parm
!= NULL
; parm
= TREE_CHAIN (parm
))
5364 if (!valid_type_in_constexpr_fundecl_p (TREE_TYPE (parm
)))
5368 error ("invalid type for parameter %d of constexpr "
5369 "function %q+#D", DECL_PARM_INDEX (parm
), fun
);
5372 if (!DECL_CONSTRUCTOR_P (fun
))
5374 tree rettype
= TREE_TYPE (TREE_TYPE (fun
));
5375 if (!valid_type_in_constexpr_fundecl_p (rettype
))
5379 error ("invalid return type %qT of constexpr function %q+D",
5383 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
5384 && !CLASSTYPE_LITERAL_P (DECL_CONTEXT (fun
)))
5388 error ("enclosing class of %q+#D is not a literal type", fun
);
5395 /* Return non-null if FUN certainly designates a valid constexpr function
5396 declaration. Otherwise return NULL. Issue appropriate diagnostics
5397 if necessary. Note that we only check the declaration, not the body
5401 validate_constexpr_fundecl (tree fun
)
5403 constexpr_fundef entry
;
5404 constexpr_fundef
**slot
;
5406 if (processing_template_decl
|| !DECL_DECLARED_CONSTEXPR_P (fun
))
5408 else if (DECL_CLONED_FUNCTION_P (fun
))
5409 /* We already checked the original function. */
5412 if (!is_valid_constexpr_fn (fun
, !DECL_TEMPLATE_INSTANTIATION (fun
)))
5414 DECL_DECLARED_CONSTEXPR_P (fun
) = false;
5418 /* Create the constexpr function table if necessary. */
5419 if (constexpr_fundef_table
== NULL
)
5420 constexpr_fundef_table
= htab_create_ggc (101,
5421 constexpr_fundef_hash
,
5422 constexpr_fundef_equal
,
5426 slot
= (constexpr_fundef
**)
5427 htab_find_slot (constexpr_fundef_table
, &entry
, INSERT
);
5430 *slot
= ggc_alloc_constexpr_fundef ();
5436 /* Subroutine of build_constexpr_constructor_member_initializers.
5437 The expression tree T represents a data member initialization
5438 in a (constexpr) constructor definition. Build a pairing of
5439 the data member with its initializer, and prepend that pair
5440 to the existing initialization pair INITS. */
5443 build_data_member_initialization (tree t
, VEC(constructor_elt
,gc
) **vec
)
5446 if (TREE_CODE (t
) == CLEANUP_POINT_EXPR
)
5447 t
= TREE_OPERAND (t
, 0);
5448 if (TREE_CODE (t
) == EXPR_STMT
)
5449 t
= TREE_OPERAND (t
, 0);
5450 if (t
== error_mark_node
)
5452 if (TREE_CODE (t
) == STATEMENT_LIST
)
5454 tree_stmt_iterator i
;
5455 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
5457 if (! build_data_member_initialization (tsi_stmt (i
), vec
))
5462 if (TREE_CODE (t
) == CLEANUP_STMT
)
5464 /* We can't see a CLEANUP_STMT in a constructor for a literal class,
5465 but we can in a constexpr constructor for a non-literal class. Just
5466 ignore it; either all the initialization will be constant, in which
5467 case the cleanup can't run, or it can't be constexpr.
5468 Still recurse into CLEANUP_BODY. */
5469 return build_data_member_initialization (CLEANUP_BODY (t
), vec
);
5471 if (TREE_CODE (t
) == CONVERT_EXPR
)
5472 t
= TREE_OPERAND (t
, 0);
5473 if (TREE_CODE (t
) == INIT_EXPR
5474 || TREE_CODE (t
) == MODIFY_EXPR
)
5476 member
= TREE_OPERAND (t
, 0);
5477 init
= unshare_expr (TREE_OPERAND (t
, 1));
5481 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
5482 member
= CALL_EXPR_ARG (t
, 0);
5483 /* We don't use build_cplus_new here because it complains about
5484 abstract bases. Leaving the call unwrapped means that it has the
5485 wrong type, but cxx_eval_constant_expression doesn't care. */
5486 init
= unshare_expr (t
);
5488 if (TREE_CODE (member
) == INDIRECT_REF
)
5489 member
= TREE_OPERAND (member
, 0);
5490 if (TREE_CODE (member
) == NOP_EXPR
)
5494 if (TREE_CODE (op
) == ADDR_EXPR
)
5496 gcc_assert (same_type_ignoring_top_level_qualifiers_p
5497 (TREE_TYPE (TREE_TYPE (op
)),
5498 TREE_TYPE (TREE_TYPE (member
))));
5499 /* Initializing a cv-qualified member; we need to look through
5505 /* We don't put out anything for an empty base. */
5506 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member
))));
5507 /* But if the initializer isn't constexpr, leave it in so we
5509 if (potential_constant_expression (init
))
5513 if (TREE_CODE (member
) == ADDR_EXPR
)
5514 member
= TREE_OPERAND (member
, 0);
5515 if (TREE_CODE (member
) == COMPONENT_REF
5516 /* If we're initializing a member of a subaggregate, it's a vtable
5517 pointer. Leave it as COMPONENT_REF so we remember the path to get
5519 && TREE_CODE (TREE_OPERAND (member
, 0)) != COMPONENT_REF
)
5520 member
= TREE_OPERAND (member
, 1);
5521 CONSTRUCTOR_APPEND_ELT (*vec
, member
, init
);
5525 /* Make sure that there are no statements after LAST in the constructor
5526 body represented by LIST. */
5529 check_constexpr_ctor_body (tree last
, tree list
)
5532 if (TREE_CODE (list
) == STATEMENT_LIST
)
5534 tree_stmt_iterator i
= tsi_last (list
);
5535 for (; !tsi_end_p (i
); tsi_prev (&i
))
5537 tree t
= tsi_stmt (i
);
5540 if (TREE_CODE (t
) == BIND_EXPR
)
5542 if (!check_constexpr_ctor_body (last
, BIND_EXPR_BODY (t
)))
5547 /* We currently allow typedefs and static_assert.
5548 FIXME allow them in the standard, too. */
5549 if (TREE_CODE (t
) != STATIC_ASSERT
)
5556 else if (list
!= last
5557 && TREE_CODE (list
) != STATIC_ASSERT
)
5561 error ("constexpr constructor does not have empty body");
5562 DECL_DECLARED_CONSTEXPR_P (current_function_decl
) = false;
5567 /* Build compile-time evalable representations of member-initializer list
5568 for a constexpr constructor. */
5571 build_constexpr_constructor_member_initializers (tree type
, tree body
)
5573 VEC(constructor_elt
,gc
) *vec
= NULL
;
5575 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
5576 || TREE_CODE (body
) == EH_SPEC_BLOCK
)
5577 body
= TREE_OPERAND (body
, 0);
5578 if (TREE_CODE (body
) == STATEMENT_LIST
)
5579 body
= STATEMENT_LIST_HEAD (body
)->stmt
;
5580 body
= BIND_EXPR_BODY (body
);
5581 if (TREE_CODE (body
) == CLEANUP_POINT_EXPR
)
5583 body
= TREE_OPERAND (body
, 0);
5584 if (TREE_CODE (body
) == EXPR_STMT
)
5585 body
= TREE_OPERAND (body
, 0);
5586 if (TREE_CODE (body
) == INIT_EXPR
5587 && (same_type_ignoring_top_level_qualifiers_p
5588 (TREE_TYPE (TREE_OPERAND (body
, 0)),
5589 current_class_type
)))
5592 return TREE_OPERAND (body
, 1);
5594 ok
= build_data_member_initialization (body
, &vec
);
5596 else if (TREE_CODE (body
) == STATEMENT_LIST
)
5598 tree_stmt_iterator i
;
5599 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
5601 ok
= build_data_member_initialization (tsi_stmt (i
), &vec
);
5607 gcc_assert (errorcount
> 0);
5609 return build_constructor (type
, vec
);
5611 return error_mark_node
;
5614 /* Subroutine of register_constexpr_fundef. BODY is the body of a function
5615 declared to be constexpr, or a sub-statement thereof. Returns the
5616 return value if suitable, error_mark_node for a statement not allowed in
5617 a constexpr function, or NULL_TREE if no return value was found. */
5620 constexpr_fn_retval (tree body
)
5622 switch (TREE_CODE (body
))
5624 case STATEMENT_LIST
:
5626 tree_stmt_iterator i
;
5627 tree expr
= NULL_TREE
;
5628 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
5630 tree s
= constexpr_fn_retval (tsi_stmt (i
));
5631 if (s
== error_mark_node
)
5632 return error_mark_node
;
5633 else if (s
== NULL_TREE
)
5634 /* Keep iterating. */;
5636 /* Multiple return statements. */
5637 return error_mark_node
;
5645 return unshare_expr (TREE_OPERAND (body
, 0));
5648 if (TREE_CODE (DECL_EXPR_DECL (body
)) == USING_DECL
)
5650 return error_mark_node
;
5656 return error_mark_node
;
5660 /* We are processing the definition of the constexpr function FUN.
5661 Check that its BODY fulfills the propriate requirements and
5662 enter it in the constexpr function definition table.
5663 For constructor BODY is actually the TREE_LIST of the
5664 member-initializer list. */
5667 register_constexpr_fundef (tree fun
, tree body
)
5669 constexpr_fundef
*fundef
= retrieve_constexpr_fundef (fun
);
5670 gcc_assert (fundef
!= NULL
&& fundef
->body
== NULL
);
5672 if (DECL_CONSTRUCTOR_P (fun
))
5673 body
= build_constexpr_constructor_member_initializers
5674 (DECL_CONTEXT (fun
), body
);
5677 if (TREE_CODE (body
) == BIND_EXPR
)
5678 body
= BIND_EXPR_BODY (body
);
5679 if (TREE_CODE (body
) == EH_SPEC_BLOCK
)
5680 body
= EH_SPEC_STMTS (body
);
5681 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
5682 body
= TREE_OPERAND (body
, 0);
5683 if (TREE_CODE (body
) == CLEANUP_POINT_EXPR
)
5684 body
= TREE_OPERAND (body
, 0);
5685 body
= constexpr_fn_retval (body
);
5686 if (body
== NULL_TREE
|| body
== error_mark_node
)
5688 error ("body of constexpr function %qD not a return-statement", fun
);
5689 DECL_DECLARED_CONSTEXPR_P (fun
) = false;
5694 if (!potential_rvalue_constant_expression (body
))
5696 DECL_DECLARED_CONSTEXPR_P (fun
) = false;
5697 if (!DECL_TEMPLATE_INSTANTIATION (fun
))
5698 require_potential_rvalue_constant_expression (body
);
5701 fundef
->body
= body
;
5705 /* Objects of this type represent calls to constexpr functions
5706 along with the bindings of parameters to their arguments, for
5707 the purpose of compile time evaluation. */
5709 typedef struct GTY(()) constexpr_call
{
5710 /* Description of the constexpr function definition. */
5711 constexpr_fundef
*fundef
;
5712 /* Parameter bindings enironment. A TREE_LIST where each TREE_PURPOSE
5713 is a parameter _DECL and the TREE_VALUE is the value of the parameter.
5714 Note: This arrangement is made to accomodate the use of
5715 iterative_hash_template_arg (see pt.c). If you change this
5716 representation, also change the hash calculation in
5717 cxx_eval_call_expression. */
5719 /* Result of the call.
5720 NULL means the call is being evaluated.
5721 error_mark_node means that the evaluation was erroneous;
5722 otherwise, the actuall value of the call. */
5724 /* The hash of this call; we remember it here to avoid having to
5725 recalculate it when expanding the hash table. */
5729 /* A table of all constexpr calls that have been evaluated by the
5730 compiler in this translation unit. */
5732 static GTY ((param_is (constexpr_call
))) htab_t constexpr_call_table
;
5734 static tree
cxx_eval_constant_expression (const constexpr_call
*, tree
,
5735 bool, bool, bool *);
5737 /* Compute a hash value for a constexpr call representation. */
5740 constexpr_call_hash (const void *p
)
5742 const constexpr_call
*info
= (const constexpr_call
*) p
;
5746 /* Return 1 if the objects pointed to by P and Q represent calls
5747 to the same constexpr function with the same arguments.
5748 Otherwise, return 0. */
5751 constexpr_call_equal (const void *p
, const void *q
)
5753 const constexpr_call
*lhs
= (const constexpr_call
*) p
;
5754 const constexpr_call
*rhs
= (const constexpr_call
*) q
;
5759 if (!constexpr_fundef_equal (lhs
->fundef
, rhs
->fundef
))
5761 lhs_bindings
= lhs
->bindings
;
5762 rhs_bindings
= rhs
->bindings
;
5763 while (lhs_bindings
!= NULL
&& rhs_bindings
!= NULL
)
5765 tree lhs_arg
= TREE_VALUE (lhs_bindings
);
5766 tree rhs_arg
= TREE_VALUE (rhs_bindings
);
5767 gcc_assert (TREE_TYPE (lhs_arg
) == TREE_TYPE (rhs_arg
));
5768 if (!cp_tree_equal (lhs_arg
, rhs_arg
))
5770 lhs_bindings
= TREE_CHAIN (lhs_bindings
);
5771 rhs_bindings
= TREE_CHAIN (rhs_bindings
);
5773 return lhs_bindings
== rhs_bindings
;
5776 /* Initialize the constexpr call table, if needed. */
5779 maybe_initialize_constexpr_call_table (void)
5781 if (constexpr_call_table
== NULL
)
5782 constexpr_call_table
= htab_create_ggc (101,
5783 constexpr_call_hash
,
5784 constexpr_call_equal
,
5788 /* Return true if T designates the implied `this' parameter. */
5791 is_this_parameter (tree t
)
5793 return t
== current_class_ptr
;
5796 /* We have an expression tree T that represents a call, either CALL_EXPR
5797 or AGGR_INIT_EXPR. If the call is lexically to a named function,
5798 retrun the _DECL for that function. */
5801 get_function_named_in_call (tree t
)
5804 switch (TREE_CODE (t
))
5807 fun
= CALL_EXPR_FN (t
);
5810 case AGGR_INIT_EXPR
:
5811 fun
= AGGR_INIT_EXPR_FN (t
);
5818 if (TREE_CODE (fun
) == ADDR_EXPR
5819 && TREE_CODE (TREE_OPERAND (fun
, 0)) == FUNCTION_DECL
)
5820 fun
= TREE_OPERAND (fun
, 0);
5824 /* We have an expression tree T that represents a call, either CALL_EXPR
5825 or AGGR_INIT_EXPR. Return the Nth argument. */
5828 get_nth_callarg (tree t
, int n
)
5830 switch (TREE_CODE (t
))
5833 return CALL_EXPR_ARG (t
, n
);
5835 case AGGR_INIT_EXPR
:
5836 return AGGR_INIT_EXPR_ARG (t
, n
);
5844 /* Look up the binding of the function parameter T in a constexpr
5845 function call context CALL. */
5848 lookup_parameter_binding (const constexpr_call
*call
, tree t
)
5850 tree b
= purpose_member (t
, call
->bindings
);
5851 return TREE_VALUE (b
);
5854 /* Attempt to evaluate T which represents a call to a builtin function.
5855 We assume here that all builtin functions evaluate to scalar types
5856 represented by _CST nodes. */
5859 cxx_eval_builtin_function_call (const constexpr_call
*call
, tree t
,
5860 bool allow_non_constant
, bool addr
,
5861 bool *non_constant_p
)
5863 const int nargs
= call_expr_nargs (t
);
5864 tree
*args
= (tree
*) alloca (nargs
* sizeof (tree
));
5867 for (i
= 0; i
< nargs
; ++i
)
5869 args
[i
] = cxx_eval_constant_expression (call
, CALL_EXPR_ARG (t
, i
),
5870 allow_non_constant
, addr
,
5872 if (allow_non_constant
&& *non_constant_p
)
5875 if (*non_constant_p
)
5877 new_call
= build_call_array_loc (EXPR_LOCATION (t
), TREE_TYPE (t
),
5878 CALL_EXPR_FN (t
), nargs
, args
);
5879 return fold (new_call
);
5882 /* TEMP is the constant value of a temporary object of type TYPE. Adjust
5883 the type of the value to match. */
5886 adjust_temp_type (tree type
, tree temp
)
5888 if (TREE_TYPE (temp
) == type
)
5890 /* Avoid wrapping an aggregate value in a NOP_EXPR. */
5891 if (TREE_CODE (temp
) == CONSTRUCTOR
)
5892 return build_constructor (type
, CONSTRUCTOR_ELTS (temp
));
5893 gcc_assert (SCALAR_TYPE_P (type
));
5894 return cp_fold_convert (type
, temp
);
5897 /* Subroutine of cxx_eval_call_expression.
5898 We are processing a call expression (either CALL_EXPR or
5899 AGGR_INIT_EXPR) in the call context of OLD_CALL. Evaluate
5900 all arguments and bind their values to correspondings
5901 parameters, making up the NEW_CALL context. */
5904 cxx_bind_parameters_in_call (const constexpr_call
*old_call
, tree t
,
5905 constexpr_call
*new_call
,
5906 bool allow_non_constant
,
5907 bool *non_constant_p
)
5909 const int nargs
= call_expr_nargs (t
);
5910 tree fun
= new_call
->fundef
->decl
;
5911 tree parms
= DECL_ARGUMENTS (fun
);
5913 for (i
= 0; i
< nargs
; ++i
)
5916 tree type
= parms
? TREE_TYPE (parms
) : void_type_node
;
5917 /* For member function, the first argument is a pointer to the implied
5918 object. And for an object contruction, don't bind `this' before
5919 it is fully constructed. */
5920 if (i
== 0 && DECL_CONSTRUCTOR_P (fun
))
5922 x
= get_nth_callarg (t
, i
);
5923 arg
= cxx_eval_constant_expression (old_call
, x
, allow_non_constant
,
5924 TREE_CODE (type
) == REFERENCE_TYPE
,
5926 /* Don't VERIFY_CONSTANT here. */
5927 if (*non_constant_p
&& allow_non_constant
)
5929 /* Just discard ellipsis args after checking their constantitude. */
5932 if (*non_constant_p
)
5933 /* Don't try to adjust the type of non-constant args. */
5936 /* Make sure the binding has the same type as the parm. */
5937 if (TREE_CODE (type
) != REFERENCE_TYPE
)
5938 arg
= adjust_temp_type (type
, arg
);
5939 new_call
->bindings
= tree_cons (parms
, arg
, new_call
->bindings
);
5941 parms
= TREE_CHAIN (parms
);
5945 /* Variables and functions to manage constexpr call expansion context.
5946 These do not need to be marked for PCH or GC. */
5948 /* FIXME remember and print actual constant arguments. */
5949 static VEC(tree
,heap
) *call_stack
= NULL
;
5950 static int call_stack_tick
;
5951 static int last_cx_error_tick
;
5954 push_cx_call_context (tree call
)
5957 if (!EXPR_HAS_LOCATION (call
))
5958 SET_EXPR_LOCATION (call
, input_location
);
5959 VEC_safe_push (tree
, heap
, call_stack
, call
);
5960 if (VEC_length (tree
, call_stack
) > (unsigned) max_constexpr_depth
)
5966 pop_cx_call_context (void)
5969 VEC_pop (tree
, call_stack
);
5973 cx_error_context (void)
5975 VEC(tree
,heap
) *r
= NULL
;
5976 if (call_stack_tick
!= last_cx_error_tick
5977 && !VEC_empty (tree
, call_stack
))
5979 last_cx_error_tick
= call_stack_tick
;
5983 /* Subroutine of cxx_eval_constant_expression.
5984 Evaluate the call expression tree T in the context of OLD_CALL expression
5988 cxx_eval_call_expression (const constexpr_call
*old_call
, tree t
,
5989 bool allow_non_constant
, bool addr
,
5990 bool *non_constant_p
)
5992 location_t loc
= EXPR_LOC_OR_HERE (t
);
5993 tree fun
= get_function_named_in_call (t
);
5995 constexpr_call new_call
= { NULL
, NULL
, NULL
, 0 };
5996 constexpr_call
**slot
;
5997 constexpr_call
*entry
;
6000 if (TREE_CODE (fun
) != FUNCTION_DECL
)
6002 /* Might be a constexpr function pointer. */
6003 fun
= cxx_eval_constant_expression (old_call
, fun
, allow_non_constant
,
6004 /*addr*/false, non_constant_p
);
6005 if (TREE_CODE (fun
) == ADDR_EXPR
)
6006 fun
= TREE_OPERAND (fun
, 0);
6008 if (TREE_CODE (fun
) != FUNCTION_DECL
)
6010 if (!allow_non_constant
)
6011 error_at (loc
, "expression %qE does not designate a constexpr "
6013 *non_constant_p
= true;
6016 if (DECL_CLONED_FUNCTION_P (fun
))
6017 fun
= DECL_CLONED_FUNCTION (fun
);
6018 if (is_builtin_fn (fun
))
6019 return cxx_eval_builtin_function_call (old_call
, t
, allow_non_constant
,
6020 addr
, non_constant_p
);
6021 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
6023 if (!allow_non_constant
)
6025 error_at (loc
, "%qD is not a constexpr function", fun
);
6026 if (DECL_TEMPLATE_INSTANTIATION (fun
)
6027 && DECL_DECLARED_CONSTEXPR_P (DECL_TEMPLATE_RESULT
6028 (DECL_TI_TEMPLATE (fun
))))
6029 is_valid_constexpr_fn (fun
, true);
6031 *non_constant_p
= true;
6035 /* Shortcut trivial copy constructor/op=. */
6036 if (call_expr_nargs (t
) == 2 && trivial_fn_p (fun
))
6038 tree arg
= convert_from_reference (get_nth_callarg (t
, 1));
6039 return cxx_eval_constant_expression (old_call
, arg
, allow_non_constant
,
6040 addr
, non_constant_p
);
6043 /* If in direct recursive call, optimize definition search. */
6044 if (old_call
!= NULL
&& old_call
->fundef
->decl
== fun
)
6045 new_call
.fundef
= old_call
->fundef
;
6048 new_call
.fundef
= retrieve_constexpr_fundef (fun
);
6049 if (new_call
.fundef
== NULL
|| new_call
.fundef
->body
== NULL
)
6051 if (!allow_non_constant
)
6052 error_at (loc
, "%qD used before its definition", fun
);
6053 *non_constant_p
= true;
6057 cxx_bind_parameters_in_call (old_call
, t
, &new_call
,
6058 allow_non_constant
, non_constant_p
);
6059 if (*non_constant_p
)
6062 depth_ok
= push_cx_call_context (t
);
6065 = iterative_hash_template_arg (new_call
.bindings
,
6066 constexpr_fundef_hash (new_call
.fundef
));
6068 /* If we have seen this call before, we are done. */
6069 maybe_initialize_constexpr_call_table ();
6070 slot
= (constexpr_call
**)
6071 htab_find_slot (constexpr_call_table
, &new_call
, INSERT
);
6075 /* We need to keep a pointer to the entry, not just the slot, as the
6076 slot can move in the call to cxx_eval_builtin_function_call. */
6077 *slot
= entry
= ggc_alloc_constexpr_call ();
6080 /* Calls which are in progress have their result set to NULL
6081 so that we can detect circular dependencies. */
6082 else if (entry
->result
== NULL
)
6084 if (!allow_non_constant
)
6085 error ("call has circular dependency");
6086 *non_constant_p
= true;
6087 entry
->result
= result
= error_mark_node
;
6092 if (!allow_non_constant
)
6093 error ("constexpr evaluation depth exceeds maximum of %d (use "
6094 "-fconstexpr-depth= to increase the maximum)",
6095 max_constexpr_depth
);
6096 *non_constant_p
= true;
6097 entry
->result
= result
= error_mark_node
;
6101 result
= entry
->result
;
6102 if (!result
|| (result
== error_mark_node
&& !allow_non_constant
))
6103 result
= (cxx_eval_constant_expression
6104 (&new_call
, new_call
.fundef
->body
,
6105 allow_non_constant
, addr
,
6107 if (result
== error_mark_node
)
6108 *non_constant_p
= true;
6109 if (*non_constant_p
)
6110 entry
->result
= result
= error_mark_node
;
6113 /* If this was a call to initialize an object, set the type of
6114 the CONSTRUCTOR to the type of that object. */
6115 if (DECL_CONSTRUCTOR_P (fun
))
6117 tree ob_arg
= get_nth_callarg (t
, 0);
6118 STRIP_NOPS (ob_arg
);
6119 gcc_assert (TREE_CODE (TREE_TYPE (ob_arg
)) == POINTER_TYPE
6120 && CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (ob_arg
))));
6121 result
= adjust_temp_type (TREE_TYPE (TREE_TYPE (ob_arg
)),
6124 entry
->result
= result
;
6128 pop_cx_call_context ();
6129 return unshare_expr (result
);
6132 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
6135 reduced_constant_expression_p (tree t
)
6137 if (TREE_OVERFLOW_P (t
))
6138 /* Integer overflow makes this not a constant expression. */
6140 /* FIXME are we calling this too much? */
6141 return initializer_constant_valid_p (t
, TREE_TYPE (t
)) != NULL_TREE
;
6144 /* Some expressions may have constant operands but are not constant
6145 themselves, such as 1/0. Call this function (or rather, the macro
6146 following it) to check for that condition.
6148 We only call this in places that require an arithmetic constant, not in
6149 places where we might have a non-constant expression that can be a
6150 component of a constant expression, such as the address of a constexpr
6151 variable that might be dereferenced later. */
6154 verify_constant (tree t
, bool allow_non_constant
, bool *non_constant_p
)
6156 if (!*non_constant_p
&& !reduced_constant_expression_p (t
))
6158 if (!allow_non_constant
)
6160 /* If T was already folded to a _CST with TREE_OVERFLOW set,
6161 printing the folded constant isn't helpful. */
6162 if (TREE_OVERFLOW_P (t
))
6164 permerror (input_location
, "overflow in constant expression");
6165 /* If we're being permissive (and are in an enforcing
6166 context), consider this constant. */
6167 if (flag_permissive
)
6171 error ("%q+E is not a constant expression", t
);
6173 *non_constant_p
= true;
6175 return *non_constant_p
;
6177 #define VERIFY_CONSTANT(X) \
6179 if (verify_constant ((X), allow_non_constant, non_constant_p)) \
6183 /* Subroutine of cxx_eval_constant_expression.
6184 Attempt to reduce the unary expression tree T to a compile time value.
6185 If successful, return the value. Otherwise issue a diagnostic
6186 and return error_mark_node. */
6189 cxx_eval_unary_expression (const constexpr_call
*call
, tree t
,
6190 bool allow_non_constant
, bool addr
,
6191 bool *non_constant_p
)
6194 tree orig_arg
= TREE_OPERAND (t
, 0);
6195 tree arg
= cxx_eval_constant_expression (call
, orig_arg
, allow_non_constant
,
6196 addr
, non_constant_p
);
6197 VERIFY_CONSTANT (arg
);
6198 if (arg
== orig_arg
)
6200 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), arg
);
6201 VERIFY_CONSTANT (r
);
6205 /* Subroutine of cxx_eval_constant_expression.
6206 Like cxx_eval_unary_expression, except for binary expressions. */
6209 cxx_eval_binary_expression (const constexpr_call
*call
, tree t
,
6210 bool allow_non_constant
, bool addr
,
6211 bool *non_constant_p
)
6214 tree orig_lhs
= TREE_OPERAND (t
, 0);
6215 tree orig_rhs
= TREE_OPERAND (t
, 1);
6217 lhs
= cxx_eval_constant_expression (call
, orig_lhs
,
6218 allow_non_constant
, addr
,
6220 VERIFY_CONSTANT (lhs
);
6221 rhs
= cxx_eval_constant_expression (call
, orig_rhs
,
6222 allow_non_constant
, addr
,
6224 VERIFY_CONSTANT (rhs
);
6225 if (lhs
== orig_lhs
&& rhs
== orig_rhs
)
6227 r
= fold_build2 (TREE_CODE (t
), TREE_TYPE (t
), lhs
, rhs
);
6228 VERIFY_CONSTANT (r
);
6232 /* Subroutine of cxx_eval_constant_expression.
6233 Attempt to evaluate condition expressions. Dead branches are not
6237 cxx_eval_conditional_expression (const constexpr_call
*call
, tree t
,
6238 bool allow_non_constant
, bool addr
,
6239 bool *non_constant_p
)
6241 tree val
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 0),
6242 allow_non_constant
, addr
,
6244 VERIFY_CONSTANT (val
);
6245 if (val
== boolean_true_node
)
6246 return cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 1),
6247 allow_non_constant
, addr
,
6249 gcc_assert (val
== boolean_false_node
);
6250 /* Don't VERIFY_CONSTANT here. */
6251 return cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 2),
6252 allow_non_constant
, addr
,
6256 /* Subroutine of cxx_eval_constant_expression.
6257 Attempt to reduce a reference to an array slot. */
6260 cxx_eval_array_reference (const constexpr_call
*call
, tree t
,
6261 bool allow_non_constant
, bool addr
,
6262 bool *non_constant_p
)
6264 tree oldary
= TREE_OPERAND (t
, 0);
6265 tree ary
= cxx_eval_constant_expression (call
, oldary
,
6266 allow_non_constant
, addr
,
6271 if (*non_constant_p
)
6273 oldidx
= TREE_OPERAND (t
, 1);
6274 index
= cxx_eval_constant_expression (call
, oldidx
,
6275 allow_non_constant
, false,
6277 VERIFY_CONSTANT (index
);
6278 if (addr
&& ary
== oldary
&& index
== oldidx
)
6281 return build4 (ARRAY_REF
, TREE_TYPE (t
), ary
, index
, NULL
, NULL
);
6282 len
= (TREE_CODE (ary
) == CONSTRUCTOR
6283 ? CONSTRUCTOR_NELTS (ary
)
6284 : (unsigned)TREE_STRING_LENGTH (ary
));
6285 if (compare_tree_int (index
, len
) >= 0)
6287 if (!allow_non_constant
)
6288 error ("array subscript out of bound");
6289 *non_constant_p
= true;
6292 i
= tree_low_cst (index
, 0);
6293 if (TREE_CODE (ary
) == CONSTRUCTOR
)
6294 return VEC_index (constructor_elt
, CONSTRUCTOR_ELTS (ary
), i
)->value
;
6296 return build_int_cst (cv_unqualified (TREE_TYPE (TREE_TYPE (ary
))),
6297 TREE_STRING_POINTER (ary
)[i
]);
6298 /* Don't VERIFY_CONSTANT here. */
6301 /* Subroutine of cxx_eval_constant_expression.
6302 Attempt to reduce a field access of a value of class type. */
6305 cxx_eval_component_reference (const constexpr_call
*call
, tree t
,
6306 bool allow_non_constant
, bool addr
,
6307 bool *non_constant_p
)
6309 unsigned HOST_WIDE_INT i
;
6312 tree part
= TREE_OPERAND (t
, 1);
6313 tree orig_whole
= TREE_OPERAND (t
, 0);
6314 tree whole
= cxx_eval_constant_expression (call
, orig_whole
,
6315 allow_non_constant
, addr
,
6317 if (whole
== orig_whole
)
6320 return fold_build3 (COMPONENT_REF
, TREE_TYPE (t
),
6321 whole
, part
, NULL_TREE
);
6322 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
6324 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
6326 if (!allow_non_constant
)
6327 error ("%qE is not a constant expression", orig_whole
);
6328 *non_constant_p
= true;
6330 if (*non_constant_p
)
6332 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
6337 if (TREE_CODE (TREE_TYPE (whole
)) == UNION_TYPE
)
6339 /* FIXME Mike Miller wants this to be OK. */
6340 if (!allow_non_constant
)
6341 error ("accessing %qD member instead of initialized %qD member in "
6342 "constant expression", part
, CONSTRUCTOR_ELT (whole
, 0)->index
);
6343 *non_constant_p
= true;
6347 return error_mark_node
;
6350 /* Subroutine of cxx_eval_constant_expression.
6351 Attempt to reduce a field access of a value of class type that is
6352 expressed as a BIT_FIELD_REF. */
6355 cxx_eval_bit_field_ref (const constexpr_call
*call
, tree t
,
6356 bool allow_non_constant
, bool addr
,
6357 bool *non_constant_p
)
6359 tree orig_whole
= TREE_OPERAND (t
, 0);
6360 tree whole
= cxx_eval_constant_expression (call
, orig_whole
,
6361 allow_non_constant
, addr
,
6363 tree start
, field
, value
;
6364 unsigned HOST_WIDE_INT i
;
6366 if (whole
== orig_whole
)
6368 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
6370 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
6372 if (!allow_non_constant
)
6373 error ("%qE is not a constant expression", orig_whole
);
6374 *non_constant_p
= true;
6376 if (*non_constant_p
)
6379 start
= TREE_OPERAND (t
, 2);
6380 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
6382 if (bit_position (field
) == start
)
6386 return error_mark_node
;
6389 /* Subroutine of cxx_eval_constant_expression.
6390 Evaluate a short-circuited logical expression T in the context
6391 of a given constexpr CALL. BAILOUT_VALUE is the value for
6392 early return. CONTINUE_VALUE is used here purely for
6393 sanity check purposes. */
6396 cxx_eval_logical_expression (const constexpr_call
*call
, tree t
,
6397 tree bailout_value
, tree continue_value
,
6398 bool allow_non_constant
, bool addr
,
6399 bool *non_constant_p
)
6402 tree lhs
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 0),
6403 allow_non_constant
, addr
,
6405 VERIFY_CONSTANT (lhs
);
6406 if (lhs
== bailout_value
)
6408 gcc_assert (lhs
== continue_value
);
6409 r
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 1),
6410 allow_non_constant
, addr
, non_constant_p
);
6411 VERIFY_CONSTANT (r
);
6415 /* REF is a COMPONENT_REF designating a particular field. V is a vector of
6416 CONSTRUCTOR elements to initialize (part of) an object containing that
6417 field. Return a pointer to the constructor_elt corresponding to the
6418 initialization of the field. */
6420 static constructor_elt
*
6421 base_field_constructor_elt (VEC(constructor_elt
,gc
) *v
, tree ref
)
6423 tree aggr
= TREE_OPERAND (ref
, 0);
6424 tree field
= TREE_OPERAND (ref
, 1);
6426 constructor_elt
*ce
;
6428 gcc_assert (TREE_CODE (ref
) == COMPONENT_REF
);
6430 if (TREE_CODE (aggr
) == COMPONENT_REF
)
6432 constructor_elt
*base_ce
6433 = base_field_constructor_elt (v
, aggr
);
6434 v
= CONSTRUCTOR_ELTS (base_ce
->value
);
6437 for (i
= 0; VEC_iterate (constructor_elt
, v
, i
, ce
); ++i
)
6438 if (ce
->index
== field
)
6445 /* Subroutine of cxx_eval_constant_expression.
6446 The expression tree T denotes a C-style array or a C-style
6447 aggregate. Reduce it to a constant expression. */
6450 cxx_eval_bare_aggregate (const constexpr_call
*call
, tree t
,
6451 bool allow_non_constant
, bool addr
,
6452 bool *non_constant_p
)
6454 VEC(constructor_elt
,gc
) *v
= CONSTRUCTOR_ELTS (t
);
6455 VEC(constructor_elt
,gc
) *n
= VEC_alloc (constructor_elt
, gc
,
6456 VEC_length (constructor_elt
, v
));
6457 constructor_elt
*ce
;
6459 bool changed
= false;
6460 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t
));
6461 for (i
= 0; VEC_iterate (constructor_elt
, v
, i
, ce
); ++i
)
6463 tree elt
= cxx_eval_constant_expression (call
, ce
->value
,
6464 allow_non_constant
, addr
,
6466 /* Don't VERIFY_CONSTANT here. */
6467 if (allow_non_constant
&& *non_constant_p
)
6469 if (elt
!= ce
->value
)
6471 if (TREE_CODE (ce
->index
) == COMPONENT_REF
)
6473 /* This is an initialization of a vfield inside a base
6474 subaggregate that we already initialized; push this
6475 initialization into the previous initialization. */
6476 constructor_elt
*inner
= base_field_constructor_elt (n
, ce
->index
);
6480 CONSTRUCTOR_APPEND_ELT (n
, ce
->index
, elt
);
6482 if (*non_constant_p
|| !changed
)
6485 VEC_free (constructor_elt
, gc
, n
);
6488 t
= build_constructor (TREE_TYPE (t
), n
);
6489 TREE_CONSTANT (t
) = true;
6493 /* Subroutine of cxx_eval_constant_expression.
6494 The expression tree T is a VEC_INIT_EXPR which denotes the desired
6495 initialization of a non-static data member of array type. Reduce it to a
6498 Note that apart from value-initialization (when VALUE_INIT is true),
6499 this is only intended to support value-initialization and the
6500 initializations done by defaulted constructors for classes with
6501 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
6502 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
6503 for the copy/move constructor. */
6506 cxx_eval_vec_init_1 (const constexpr_call
*call
, tree atype
, tree init
,
6507 bool value_init
, bool allow_non_constant
, bool addr
,
6508 bool *non_constant_p
)
6510 tree elttype
= TREE_TYPE (atype
);
6511 int max
= tree_low_cst (array_type_nelts (atype
), 0);
6512 VEC(constructor_elt
,gc
) *n
= VEC_alloc (constructor_elt
, gc
, max
+ 1);
6515 /* For the default constructor, build up a call to the default
6516 constructor of the element type. We only need to handle class types
6517 here, as for a constructor to be constexpr, all members must be
6518 initialized, which for a defaulted default constructor means they must
6519 be of a class type with a constexpr default constructor. */
6524 VEC(tree
,gc
) *argvec
= make_tree_vector ();
6525 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
6526 &argvec
, elttype
, LOOKUP_NORMAL
,
6527 tf_warning_or_error
);
6528 release_tree_vector (argvec
);
6529 init
= cxx_eval_constant_expression (call
, init
, allow_non_constant
,
6530 addr
, non_constant_p
);
6533 if (*non_constant_p
&& !allow_non_constant
)
6536 for (i
= 0; i
<= max
; ++i
)
6538 tree idx
= build_int_cst (size_type_node
, i
);
6540 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
6542 /* A multidimensional array; recurse. */
6544 eltinit
= NULL_TREE
;
6546 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
6547 tf_warning_or_error
);
6548 eltinit
= cxx_eval_vec_init_1 (call
, elttype
, eltinit
, value_init
,
6549 allow_non_constant
, addr
,
6552 else if (value_init
)
6554 eltinit
= build_value_init (elttype
, tf_warning_or_error
);
6555 eltinit
= cxx_eval_constant_expression
6556 (call
, eltinit
, allow_non_constant
, addr
, non_constant_p
);
6558 else if (TREE_CODE (init
) == CONSTRUCTOR
)
6560 /* Initializing an element using the call to the default
6561 constructor we just built above. */
6562 eltinit
= unshare_expr (init
);
6566 /* Copying an element. */
6567 VEC(tree
,gc
) *argvec
;
6568 gcc_assert (same_type_ignoring_top_level_qualifiers_p
6569 (atype
, TREE_TYPE (init
)));
6570 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
6571 tf_warning_or_error
);
6572 if (!real_lvalue_p (init
))
6573 eltinit
= move (eltinit
);
6574 argvec
= make_tree_vector ();
6575 VEC_quick_push (tree
, argvec
, eltinit
);
6576 eltinit
= (build_special_member_call
6577 (NULL_TREE
, complete_ctor_identifier
, &argvec
,
6578 elttype
, LOOKUP_NORMAL
, tf_warning_or_error
));
6579 release_tree_vector (argvec
);
6580 eltinit
= cxx_eval_constant_expression
6581 (call
, eltinit
, allow_non_constant
, addr
, non_constant_p
);
6583 if (*non_constant_p
&& !allow_non_constant
)
6585 CONSTRUCTOR_APPEND_ELT (n
, idx
, eltinit
);
6588 if (!*non_constant_p
)
6590 init
= build_constructor (TREE_TYPE (atype
), n
);
6591 TREE_CONSTANT (init
) = true;
6596 VEC_free (constructor_elt
, gc
, n
);
6601 cxx_eval_vec_init (const constexpr_call
*call
, tree t
,
6602 bool allow_non_constant
, bool addr
,
6603 bool *non_constant_p
)
6605 tree atype
= TREE_TYPE (t
);
6606 tree init
= VEC_INIT_EXPR_INIT (t
);
6607 tree r
= cxx_eval_vec_init_1 (call
, atype
, init
,
6608 VEC_INIT_EXPR_VALUE_INIT (t
),
6609 allow_non_constant
, addr
, non_constant_p
);
6610 if (*non_constant_p
)
6616 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
6617 match. We want to be less strict for simple *& folding; if we have a
6618 non-const temporary that we access through a const pointer, that should
6619 work. We handle this here rather than change fold_indirect_ref_1
6620 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
6621 don't really make sense outside of constant expression evaluation. Also
6622 we want to allow folding to COMPONENT_REF, which could cause trouble
6623 with TBAA in fold_indirect_ref_1. */
6626 cxx_eval_indirect_ref (const constexpr_call
*call
, tree t
,
6627 bool allow_non_constant
, bool addr
,
6628 bool *non_constant_p
)
6630 tree orig_op0
= TREE_OPERAND (t
, 0);
6631 tree op0
= cxx_eval_constant_expression (call
, orig_op0
, allow_non_constant
,
6632 /*addr*/false, non_constant_p
);
6633 tree type
, sub
, subtype
, r
;
6636 /* Don't VERIFY_CONSTANT here. */
6637 if (*non_constant_p
)
6640 type
= TREE_TYPE (t
);
6646 subtype
= TREE_TYPE (sub
);
6647 gcc_assert (POINTER_TYPE_P (subtype
));
6649 if (TREE_CODE (sub
) == ADDR_EXPR
)
6651 tree op
= TREE_OPERAND (sub
, 0);
6652 tree optype
= TREE_TYPE (op
);
6654 if (same_type_ignoring_top_level_qualifiers_p (optype
, type
))
6656 /* Also handle conversion to an empty base class, which
6657 is represented with a NOP_EXPR. */
6658 else if (!addr
&& is_empty_class (type
)
6659 && CLASS_TYPE_P (optype
)
6660 && DERIVED_FROM_P (type
, optype
))
6665 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
6666 else if (RECORD_OR_UNION_TYPE_P (optype
))
6668 tree field
= TYPE_FIELDS (optype
);
6669 for (; field
; field
= DECL_CHAIN (field
))
6670 if (TREE_CODE (field
) == FIELD_DECL
6671 && integer_zerop (byte_position (field
))
6672 && (same_type_ignoring_top_level_qualifiers_p
6673 (TREE_TYPE (field
), type
)))
6675 r
= fold_build3 (COMPONENT_REF
, type
, op
, field
, NULL_TREE
);
6680 else if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
6681 && TREE_CODE (TREE_OPERAND (sub
, 1)) == INTEGER_CST
)
6683 tree op00
= TREE_OPERAND (sub
, 0);
6684 tree op01
= TREE_OPERAND (sub
, 1);
6687 if (TREE_CODE (op00
) == ADDR_EXPR
)
6690 op00
= TREE_OPERAND (op00
, 0);
6691 op00type
= TREE_TYPE (op00
);
6693 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
6694 if (RECORD_OR_UNION_TYPE_P (op00type
))
6696 tree field
= TYPE_FIELDS (op00type
);
6697 for (; field
; field
= DECL_CHAIN (field
))
6698 if (TREE_CODE (field
) == FIELD_DECL
6699 && tree_int_cst_equal (byte_position (field
), op01
)
6700 && (same_type_ignoring_top_level_qualifiers_p
6701 (TREE_TYPE (field
), type
)))
6703 r
= fold_build3 (COMPONENT_REF
, type
, op00
,
6711 /* Let build_fold_indirect_ref handle the cases it does fine with. */
6713 r
= build_fold_indirect_ref (op0
);
6714 if (TREE_CODE (r
) != INDIRECT_REF
)
6715 r
= cxx_eval_constant_expression (call
, r
, allow_non_constant
,
6716 addr
, non_constant_p
);
6717 else if (TREE_CODE (sub
) == ADDR_EXPR
6718 || TREE_CODE (sub
) == POINTER_PLUS_EXPR
)
6720 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
6721 (TREE_TYPE (TREE_TYPE (sub
)), TREE_TYPE (t
)));
6722 /* FIXME Mike Miller wants this to be OK. */
6723 if (!allow_non_constant
)
6724 error ("accessing value of %qE through a %qT glvalue in a "
6725 "constant expression", build_fold_indirect_ref (sub
),
6727 *non_constant_p
= true;
6731 /* If we're pulling out the value of an empty base, make sure
6732 that the whole object is constant and then return an empty
6736 VERIFY_CONSTANT (r
);
6737 r
= build_constructor (TREE_TYPE (t
), NULL
);
6738 TREE_CONSTANT (r
) = true;
6741 if (TREE_CODE (r
) == INDIRECT_REF
&& TREE_OPERAND (r
, 0) == orig_op0
)
6746 /* Complain about R, a VAR_DECL, not being usable in a constant expression.
6747 Shared between potential_constant_expression and
6748 cxx_eval_constant_expression. */
6751 non_const_var_error (tree r
)
6753 tree type
= TREE_TYPE (r
);
6754 error ("the value of %qD is not usable in a constant "
6756 if (DECL_DECLARED_CONSTEXPR_P (r
))
6757 inform (DECL_SOURCE_LOCATION (r
),
6758 "%qD used in its own initializer", r
);
6759 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
6761 if (!CP_TYPE_CONST_P (type
))
6762 inform (DECL_SOURCE_LOCATION (r
),
6763 "%q#D is not const", r
);
6764 else if (CP_TYPE_VOLATILE_P (type
))
6765 inform (DECL_SOURCE_LOCATION (r
),
6766 "%q#D is volatile", r
);
6767 else if (!DECL_INITIAL (r
))
6768 inform (DECL_SOURCE_LOCATION (r
),
6769 "%qD was not initialized with a constant "
6776 if (cxx_dialect
>= cxx0x
&& !DECL_DECLARED_CONSTEXPR_P (r
))
6777 inform (DECL_SOURCE_LOCATION (r
),
6778 "%qD was not declared %<constexpr%>", r
);
6780 inform (DECL_SOURCE_LOCATION (r
),
6781 "%qD does not have integral or enumeration type",
6786 /* Attempt to reduce the expression T to a constant value.
6787 On failure, issue diagnostic and return error_mark_node. */
6788 /* FIXME unify with c_fully_fold */
6791 cxx_eval_constant_expression (const constexpr_call
*call
, tree t
,
6792 bool allow_non_constant
, bool addr
,
6793 bool *non_constant_p
)
6797 if (t
== error_mark_node
)
6799 *non_constant_p
= true;
6802 if (CONSTANT_CLASS_P (t
))
6804 if (TREE_CODE (t
) == PTRMEM_CST
)
6805 t
= cplus_expand_constant (t
);
6808 if (TREE_CODE (t
) != NOP_EXPR
6809 && reduced_constant_expression_p (t
))
6812 switch (TREE_CODE (t
))
6817 /* else fall through. */
6819 r
= integral_constant_value (t
);
6820 if (TREE_CODE (r
) == TARGET_EXPR
6821 && TREE_CODE (TARGET_EXPR_INITIAL (r
)) == CONSTRUCTOR
)
6822 r
= TARGET_EXPR_INITIAL (r
);
6825 if (!allow_non_constant
)
6826 non_const_var_error (r
);
6827 *non_constant_p
= true;
6836 if (call
&& DECL_CONTEXT (t
) == call
->fundef
->decl
)
6837 r
= lookup_parameter_binding (call
, t
);
6839 /* Defer in case this is only used for its type. */;
6842 if (!allow_non_constant
)
6843 error ("%qE is not a constant expression", t
);
6844 *non_constant_p
= true;
6849 case AGGR_INIT_EXPR
:
6850 r
= cxx_eval_call_expression (call
, t
, allow_non_constant
, addr
,
6856 /* Pass false for 'addr' because these codes indicate
6857 initialization of a temporary. */
6858 r
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 1),
6859 allow_non_constant
, false,
6861 if (!*non_constant_p
)
6862 /* Adjust the type of the result to the type of the temporary. */
6863 r
= adjust_temp_type (TREE_TYPE (t
), r
);
6867 r
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 1),
6868 allow_non_constant
, addr
,
6873 case NON_LVALUE_EXPR
:
6874 case TRY_CATCH_EXPR
:
6875 case CLEANUP_POINT_EXPR
:
6876 case MUST_NOT_THROW_EXPR
:
6878 r
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 0),
6879 allow_non_constant
, addr
,
6883 /* These differ from cxx_eval_unary_expression in that this doesn't
6884 check for a constant operand or result; an address can be
6885 constant without its operand being, and vice versa. */
6887 r
= cxx_eval_indirect_ref (call
, t
, allow_non_constant
, addr
,
6893 tree oldop
= TREE_OPERAND (t
, 0);
6894 tree op
= cxx_eval_constant_expression (call
, oldop
,
6898 /* Don't VERIFY_CONSTANT here. */
6899 if (*non_constant_p
)
6901 /* This function does more aggressive folding than fold itself. */
6902 r
= build_fold_addr_expr_with_type (op
, TREE_TYPE (t
));
6903 if (TREE_CODE (r
) == ADDR_EXPR
&& TREE_OPERAND (r
, 0) == oldop
)
6911 case FIX_TRUNC_EXPR
:
6916 case TRUTH_NOT_EXPR
:
6917 case FIXED_CONVERT_EXPR
:
6918 r
= cxx_eval_unary_expression (call
, t
, allow_non_constant
, addr
,
6924 /* check_return_expr sometimes wraps a TARGET_EXPR in a
6925 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
6926 introduced by build_call_a. */
6927 tree op0
= TREE_OPERAND (t
, 0);
6928 tree op1
= TREE_OPERAND (t
, 1);
6930 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
6931 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
6932 r
= cxx_eval_constant_expression (call
, op0
, allow_non_constant
,
6933 addr
, non_constant_p
);
6936 /* Check that the LHS is constant and then discard it. */
6937 cxx_eval_constant_expression (call
, op0
, allow_non_constant
,
6938 false, non_constant_p
);
6939 r
= cxx_eval_constant_expression (call
, op1
, allow_non_constant
,
6940 addr
, non_constant_p
);
6945 case POINTER_PLUS_EXPR
:
6949 case TRUNC_DIV_EXPR
:
6951 case FLOOR_DIV_EXPR
:
6952 case ROUND_DIV_EXPR
:
6953 case TRUNC_MOD_EXPR
:
6955 case ROUND_MOD_EXPR
:
6957 case EXACT_DIV_EXPR
:
6967 case TRUTH_XOR_EXPR
:
6974 case UNORDERED_EXPR
:
6983 r
= cxx_eval_binary_expression (call
, t
, allow_non_constant
, addr
,
6987 /* fold can introduce non-IF versions of these; still treat them as
6988 short-circuiting. */
6989 case TRUTH_AND_EXPR
:
6990 case TRUTH_ANDIF_EXPR
:
6991 r
= cxx_eval_logical_expression (call
, t
, boolean_false_node
,
6993 allow_non_constant
, addr
,
6998 case TRUTH_ORIF_EXPR
:
6999 r
= cxx_eval_logical_expression (call
, t
, boolean_true_node
,
7001 allow_non_constant
, addr
,
7006 r
= cxx_eval_array_reference (call
, t
, allow_non_constant
, addr
,
7011 r
= cxx_eval_component_reference (call
, t
, allow_non_constant
, addr
,
7016 r
= cxx_eval_bit_field_ref (call
, t
, allow_non_constant
, addr
,
7022 r
= cxx_eval_conditional_expression (call
, t
, allow_non_constant
, addr
,
7027 r
= cxx_eval_bare_aggregate (call
, t
, allow_non_constant
, addr
,
7032 /* We can get this in a defaulted constructor for a class with a
7033 non-static data member of array type. Either the initializer will
7034 be NULL, meaning default-initialization, or it will be an lvalue
7035 or xvalue of the same type, meaning direct-initialization from the
7036 corresponding member. */
7037 r
= cxx_eval_vec_init (call
, t
, allow_non_constant
, addr
,
7042 case VIEW_CONVERT_EXPR
:
7045 tree oldop
= TREE_OPERAND (t
, 0);
7047 tree to
= TREE_TYPE (t
);
7048 tree source
= TREE_TYPE (op
);
7049 if (TYPE_PTR_P (source
) && ARITHMETIC_TYPE_P (to
)
7050 && !(TREE_CODE (op
) == COMPONENT_REF
7051 && TYPE_PTRMEMFUNC_P (TREE_TYPE (TREE_OPERAND (op
, 0)))))
7053 if (!allow_non_constant
)
7054 error ("conversion of expression %qE of pointer type "
7055 "cannot yield a constant expression", op
);
7056 *non_constant_p
= true;
7059 op
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 0),
7060 allow_non_constant
, addr
,
7062 if (*non_constant_p
)
7065 /* We didn't fold at the top so we could check for ptr-int
7068 r
= fold_build1 (TREE_CODE (t
), to
, op
);
7069 /* Conversion of an out-of-range value has implementation-defined
7070 behavior; the language considers it different from arithmetic
7071 overflow, which is undefined. */
7072 if (TREE_OVERFLOW_P (r
) && !TREE_OVERFLOW_P (op
))
7073 TREE_OVERFLOW (r
) = false;
7077 case EMPTY_CLASS_EXPR
:
7078 /* This is good enough for a function argument that might not get
7079 used, and they can't do anything with it, so just return it. */
7083 case DYNAMIC_CAST_EXPR
:
7084 case PSEUDO_DTOR_EXPR
:
7085 case PREINCREMENT_EXPR
:
7086 case POSTINCREMENT_EXPR
:
7087 case PREDECREMENT_EXPR
:
7088 case POSTDECREMENT_EXPR
:
7092 case VEC_DELETE_EXPR
:
7096 /* GCC internal stuff. */
7099 case WITH_CLEANUP_EXPR
:
7100 case STATEMENT_LIST
:
7102 case NON_DEPENDENT_EXPR
:
7106 if (!allow_non_constant
)
7107 error_at (EXPR_LOC_OR_HERE (t
),
7108 "expression %qE is not a constant-expression", t
);
7109 *non_constant_p
= true;
7113 internal_error ("unexpected expression %qE of kind %s", t
,
7114 tree_code_name
[TREE_CODE (t
)]);
7115 *non_constant_p
= true;
7119 if (r
== error_mark_node
)
7120 *non_constant_p
= true;
7122 if (*non_constant_p
)
7129 cxx_eval_outermost_constant_expr (tree t
, bool allow_non_constant
)
7131 bool non_constant_p
= false;
7132 tree r
= cxx_eval_constant_expression (NULL
, t
, allow_non_constant
,
7133 false, &non_constant_p
);
7135 verify_constant (r
, allow_non_constant
, &non_constant_p
);
7137 if (non_constant_p
&& !allow_non_constant
)
7138 return error_mark_node
;
7139 else if (non_constant_p
&& TREE_CONSTANT (t
))
7141 /* This isn't actually constant, so unset TREE_CONSTANT. */
7142 if (EXPR_P (t
) || TREE_CODE (t
) == CONSTRUCTOR
)
7145 r
= build_nop (TREE_TYPE (t
), t
);
7146 TREE_CONSTANT (r
) = false;
7149 else if (non_constant_p
|| r
== t
)
7151 else if (TREE_CODE (r
) == CONSTRUCTOR
&& CLASS_TYPE_P (TREE_TYPE (r
)))
7153 if (TREE_CODE (t
) == TARGET_EXPR
7154 && TARGET_EXPR_INITIAL (t
) == r
)
7158 r
= get_target_expr (r
);
7159 TREE_CONSTANT (r
) = true;
7167 /* Returns true if T is a valid subexpression of a constant expression,
7168 even if it isn't itself a constant expression. */
7171 is_sub_constant_expr (tree t
)
7173 bool non_constant_p
= false;
7174 cxx_eval_constant_expression (NULL
, t
, true, false, &non_constant_p
);
7175 return !non_constant_p
;
7178 /* If T represents a constant expression returns its reduced value.
7179 Otherwise return error_mark_node. If T is dependent, then
7183 cxx_constant_value (tree t
)
7185 return cxx_eval_outermost_constant_expr (t
, false);
7188 /* If T is a constant expression, returns its reduced value.
7189 Otherwise, if T does not have TREE_CONSTANT set, returns T.
7190 Otherwise, returns a version of T without TREE_CONSTANT. */
7193 maybe_constant_value (tree t
)
7197 if (type_dependent_expression_p (t
)
7198 || type_unknown_p (t
)
7199 || !potential_constant_expression (t
)
7200 || value_dependent_expression_p (t
))
7203 r
= cxx_eval_outermost_constant_expr (t
, true);
7204 #ifdef ENABLE_CHECKING
7205 /* cp_tree_equal looks through NOPs, so allow them. */
7207 || CONVERT_EXPR_P (t
)
7208 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
7209 || !cp_tree_equal (r
, t
));
7214 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
7215 than wrapped in a TARGET_EXPR. */
7218 maybe_constant_init (tree t
)
7220 t
= maybe_constant_value (t
);
7221 if (TREE_CODE (t
) == TARGET_EXPR
)
7223 tree init
= TARGET_EXPR_INITIAL (t
);
7224 if (TREE_CODE (init
) == CONSTRUCTOR
7225 && TREE_CONSTANT (init
))
7232 /* FIXME see ADDR_EXPR section in potential_constant_expression_1. */
7233 /* Return true if the object referred to by REF has automatic or thread
7236 enum { ck_ok
, ck_bad
, ck_unknown
};
7238 check_automatic_or_tls (tree ref
)
7240 enum machine_mode mode
;
7241 HOST_WIDE_INT bitsize
, bitpos
;
7243 int volatilep
= 0, unsignedp
= 0;
7244 tree decl
= get_inner_reference (ref
, &bitsize
, &bitpos
, &offset
,
7245 &mode
, &unsignedp
, &volatilep
, false);
7248 /* If there isn't a decl in the middle, we don't know the linkage here,
7249 and this isn't a constant expression anyway. */
7252 dk
= decl_storage_duration (decl
);
7253 return (dk
== dk_auto
|| dk
== dk_thread
) ? ck_bad
: ck_ok
;
7257 /* Return true if the DECL designates a builtin function that is
7258 morally constexpr, in the sense that its parameter types and
7259 return type are literal types and the compiler is allowed to
7260 fold its invocations. */
7263 morally_constexpr_builtin_function_p (tree decl
)
7265 tree funtype
= TREE_TYPE (decl
);
7268 if (!is_builtin_fn (decl
))
7270 if (!literal_type_p (TREE_TYPE (funtype
)))
7272 for (t
= TYPE_ARG_TYPES (funtype
); t
!= NULL
; t
= TREE_CHAIN (t
))
7274 if (t
== void_list_node
)
7276 if (!literal_type_p (TREE_VALUE (t
)))
7279 /* We assume no varargs builtins are suitable. */
7283 /* Return true if T denotes a potentially constant expression. Issue
7284 diagnostic as appropriate under control of FLAGS. If WANT_RVAL is true,
7285 an lvalue-rvalue conversion is implied.
7287 C++0x [expr.const] used to say
7289 6 An expression is a potential constant expression if it is
7290 a constant expression where all occurences of function
7291 parameters are replaced by arbitrary constant expressions
7292 of the appropriate type.
7294 2 A conditional expression is a constant expression unless it
7295 involves one of the following as a potentially evaluated
7296 subexpression (3.2), but subexpressions of logical AND (5.14),
7297 logical OR (5.15), and conditional (5.16) operations that are
7298 not evaluated are not considered. */
7301 potential_constant_expression_1 (tree t
, bool want_rval
, tsubst_flags_t flags
)
7303 enum { any
= false, rval
= true };
7307 /* C++98 has different rules for the form of a constant expression that
7308 are enforced in the parser, so we can assume that anything that gets
7309 this far is suitable. */
7310 if (cxx_dialect
< cxx0x
)
7313 if (t
== error_mark_node
)
7317 if (TREE_THIS_VOLATILE (t
))
7319 if (flags
& tf_error
)
7320 error ("expression %qE has side-effects", t
);
7323 if (CONSTANT_CLASS_P (t
))
7325 if (TREE_OVERFLOW (t
))
7327 if (flags
& tf_error
)
7329 permerror (EXPR_LOC_OR_HERE (t
),
7330 "overflow in constant expression");
7331 if (flag_permissive
)
7339 switch (TREE_CODE (t
))
7345 case TEMPLATE_ID_EXPR
:
7352 case TEMPLATE_PARM_INDEX
:
7354 case IDENTIFIER_NODE
:
7358 /* -- this (5.1) unless it appears as the postfix-expression in a
7359 class member access expression, including the result of the
7360 implicit transformation in the body of the non-static
7361 member function (9.3.1); */
7362 if (is_this_parameter (t
))
7364 if (flags
& tf_error
)
7365 error ("%qE is not a potential constant expression", t
);
7370 case AGGR_INIT_EXPR
:
7372 /* -- an invocation of a function other than a constexpr function
7373 or a constexpr constructor. */
7375 tree fun
= get_function_named_in_call (t
);
7376 const int nargs
= call_expr_nargs (t
);
7377 if (TREE_CODE (fun
) != FUNCTION_DECL
)
7379 if (potential_constant_expression_1 (fun
, rval
, flags
))
7380 /* Might end up being a constant function pointer. */
7382 if (flags
& tf_error
)
7383 error ("%qE is not a function name", fun
);
7386 /* Skip initial arguments to base constructors. */
7387 if (DECL_BASE_CONSTRUCTOR_P (fun
))
7388 i
= num_artificial_parms_for (fun
);
7391 fun
= DECL_ORIGIN (fun
);
7392 if (builtin_valid_in_constant_expr_p (fun
))
7394 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
7395 && !morally_constexpr_builtin_function_p (fun
))
7397 if (flags
& tf_error
)
7398 error ("%qD is not %<constexpr%>", fun
);
7401 for (; i
< nargs
; ++i
)
7403 tree x
= get_nth_callarg (t
, i
);
7404 /* A call to a non-static member function takes the
7405 address of the object as the first argument.
7406 But in a constant expression the address will be folded
7407 away, so look through it now. */
7408 if (i
== 0 && DECL_NONSTATIC_MEMBER_P (fun
)
7409 && !DECL_CONSTRUCTOR_P (fun
))
7411 if (is_this_parameter (x
))
7413 else if (!potential_constant_expression_1 (x
, rval
, flags
))
7415 if (flags
& tf_error
)
7416 error ("object argument is not a potential constant "
7421 else if (!potential_constant_expression_1 (x
, rval
, flags
))
7423 if (flags
& tf_error
)
7424 error ("argument in position %qP is not a "
7425 "potential constant expression", i
);
7432 case NON_LVALUE_EXPR
:
7433 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
7434 -- an lvalue of integral type that refers to a non-volatile
7435 const variable or static data member initialized with
7436 constant expressions, or
7438 -- an lvalue of literal type that refers to non-volatile
7439 object defined with constexpr, or that refers to a
7440 sub-object of such an object; */
7441 return potential_constant_expression_1 (TREE_OPERAND (t
, 0), rval
, flags
);
7444 if (want_rval
&& !decl_constant_var_p (t
)
7445 && !dependent_type_p (TREE_TYPE (t
)))
7447 if (flags
& tf_error
)
7448 non_const_var_error (t
);
7455 case VIEW_CONVERT_EXPR
:
7456 /* -- an array-to-pointer conversion that is applied to an lvalue
7457 that designates an object with thread or automatic storage
7458 duration; FIXME not implemented as it breaks constexpr arrays;
7459 need to fix the standard
7460 -- a type conversion from a pointer or pointer-to-member type
7461 to a literal type. */
7463 tree from
= TREE_OPERAND (t
, 0);
7464 tree source
= TREE_TYPE (from
);
7465 tree target
= TREE_TYPE (t
);
7466 if (TYPE_PTR_P (source
) && ARITHMETIC_TYPE_P (target
)
7467 && !(TREE_CODE (from
) == COMPONENT_REF
7468 && TYPE_PTRMEMFUNC_P (TREE_TYPE (TREE_OPERAND (from
, 0)))))
7470 if (flags
& tf_error
)
7471 error ("conversion of expression %qE of pointer type "
7472 "cannot yield a constant expression", from
);
7475 return (potential_constant_expression_1
7476 (from
, TREE_CODE (t
) != VIEW_CONVERT_EXPR
, flags
));
7480 /* -- a unary operator & that is applied to an lvalue that
7481 designates an object with thread or automatic storage
7483 t
= TREE_OPERAND (t
, 0);
7485 /* FIXME adjust when issue 1197 is fully resolved. For now don't do
7486 any checking here, as we might dereference the pointer later. If
7487 we remove this code, also remove check_automatic_or_tls. */
7488 i
= check_automatic_or_tls (t
);
7493 if (flags
& tf_error
)
7494 error ("address-of an object %qE with thread local or "
7495 "automatic storage is not a constant expression", t
);
7499 return potential_constant_expression_1 (t
, any
, flags
);
7505 /* -- a class member access unless its postfix-expression is
7506 of literal type or of pointer to literal type. */
7507 /* This test would be redundant, as it follows from the
7508 postfix-expression being a potential constant expression. */
7509 return potential_constant_expression_1 (TREE_OPERAND (t
, 0),
7512 case EXPR_PACK_EXPANSION
:
7513 return potential_constant_expression_1 (PACK_EXPANSION_PATTERN (t
),
7518 tree x
= TREE_OPERAND (t
, 0);
7520 if (is_this_parameter (x
))
7522 if (DECL_CONSTRUCTOR_P (DECL_CONTEXT (x
)) && want_rval
)
7524 if (flags
& tf_error
)
7525 sorry ("use of the value of the object being constructed "
7526 "in a constant expression");
7531 return potential_constant_expression_1 (x
, rval
, flags
);
7535 case DYNAMIC_CAST_EXPR
:
7536 case PSEUDO_DTOR_EXPR
:
7537 case PREINCREMENT_EXPR
:
7538 case POSTINCREMENT_EXPR
:
7539 case PREDECREMENT_EXPR
:
7540 case POSTDECREMENT_EXPR
:
7544 case VEC_DELETE_EXPR
:
7548 /* GCC internal stuff. */
7551 case WITH_CLEANUP_EXPR
:
7552 case CLEANUP_POINT_EXPR
:
7553 case MUST_NOT_THROW_EXPR
:
7554 case TRY_CATCH_EXPR
:
7555 case STATEMENT_LIST
:
7556 /* Don't bother trying to define a subset of statement-expressions to
7557 be constant-expressions, at least for now. */
7561 if (flags
& tf_error
)
7562 error ("expression %qE is not a constant-expression", t
);
7566 /* -- a typeid expression whose operand is of polymorphic
7569 tree e
= TREE_OPERAND (t
, 0);
7570 if (!TYPE_P (e
) && !type_dependent_expression_p (e
)
7571 && TYPE_POLYMORPHIC_P (TREE_TYPE (e
)))
7573 if (flags
& tf_error
)
7574 error ("typeid-expression is not a constant expression "
7575 "because %qE is of polymorphic type", e
);
7582 /* -- a subtraction where both operands are pointers. */
7583 if (TYPE_PTR_P (TREE_OPERAND (t
, 0))
7584 && TYPE_PTR_P (TREE_OPERAND (t
, 1)))
7586 if (flags
& tf_error
)
7587 error ("difference of two pointer expressions is not "
7588 "a constant expression");
7600 /* -- a relational or equality operator where at least
7601 one of the operands is a pointer. */
7602 if (TYPE_PTR_P (TREE_OPERAND (t
, 0))
7603 || TYPE_PTR_P (TREE_OPERAND (t
, 1)))
7605 if (flags
& tf_error
)
7606 error ("pointer comparison expression is not a "
7607 "constant expression");
7617 case FIX_TRUNC_EXPR
:
7622 case TRUTH_NOT_EXPR
:
7623 case FIXED_CONVERT_EXPR
:
7624 case UNARY_PLUS_EXPR
:
7625 return potential_constant_expression_1 (TREE_OPERAND (t
, 0), rval
,
7629 case CONST_CAST_EXPR
:
7630 case STATIC_CAST_EXPR
:
7631 case REINTERPRET_CAST_EXPR
:
7632 return (potential_constant_expression_1
7633 (TREE_OPERAND (t
, 0),
7634 TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
, flags
));
7637 case NON_DEPENDENT_EXPR
:
7638 /* For convenience. */
7640 return potential_constant_expression_1 (TREE_OPERAND (t
, 0),
7644 return potential_constant_expression_1 (TREE_OPERAND (t
, 1),
7649 return potential_constant_expression_1 (TREE_OPERAND (t
, 1),
7654 VEC(constructor_elt
, gc
) *v
= CONSTRUCTOR_ELTS (t
);
7655 constructor_elt
*ce
;
7656 for (i
= 0; VEC_iterate (constructor_elt
, v
, i
, ce
); ++i
)
7657 if (!potential_constant_expression_1 (ce
->value
, want_rval
, flags
))
7664 gcc_assert (TREE_PURPOSE (t
) == NULL_TREE
7665 || DECL_P (TREE_PURPOSE (t
)));
7666 if (!potential_constant_expression_1 (TREE_VALUE (t
), want_rval
,
7669 if (TREE_CHAIN (t
) == NULL_TREE
)
7671 return potential_constant_expression_1 (TREE_CHAIN (t
), want_rval
,
7675 case TRUNC_DIV_EXPR
:
7677 case FLOOR_DIV_EXPR
:
7678 case ROUND_DIV_EXPR
:
7679 case TRUNC_MOD_EXPR
:
7681 case ROUND_MOD_EXPR
:
7683 tree denom
= TREE_OPERAND (t
, 1);
7684 /* We can't call maybe_constant_value on an expression
7685 that hasn't been through fold_non_dependent_expr yet. */
7686 if (!processing_template_decl
)
7687 denom
= maybe_constant_value (denom
);
7688 if (integer_zerop (denom
))
7690 if (flags
& tf_error
)
7691 error ("division by zero is not a constant-expression");
7703 /* check_return_expr sometimes wraps a TARGET_EXPR in a
7704 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
7705 introduced by build_call_a. */
7706 tree op0
= TREE_OPERAND (t
, 0);
7707 tree op1
= TREE_OPERAND (t
, 1);
7709 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
7710 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
7711 return potential_constant_expression_1 (op0
, want_rval
, flags
);
7716 /* If the first operand is the non-short-circuit constant, look at
7717 the second operand; otherwise we only care about the first one for
7719 case TRUTH_AND_EXPR
:
7720 case TRUTH_ANDIF_EXPR
:
7721 tmp
= boolean_true_node
;
7724 case TRUTH_ORIF_EXPR
:
7725 tmp
= boolean_false_node
;
7727 if (TREE_OPERAND (t
, 0) == tmp
)
7728 return potential_constant_expression_1 (TREE_OPERAND (t
, 1), rval
, flags
);
7730 return potential_constant_expression_1 (TREE_OPERAND (t
, 0), rval
, flags
);
7734 case POINTER_PLUS_EXPR
:
7736 case EXACT_DIV_EXPR
:
7746 case TRUTH_XOR_EXPR
:
7757 case ARRAY_RANGE_REF
:
7761 for (i
= 0; i
< 2; ++i
)
7762 if (!potential_constant_expression_1 (TREE_OPERAND (t
, i
),
7769 /* If the condition is a known constant, we know which of the legs we
7770 care about; otherwise we only require that the condition and
7771 either of the legs be potentially constant. */
7772 tmp
= TREE_OPERAND (t
, 0);
7773 if (!potential_constant_expression_1 (tmp
, rval
, flags
))
7775 else if (tmp
== boolean_true_node
)
7776 return potential_constant_expression_1 (TREE_OPERAND (t
, 1),
7778 else if (tmp
== boolean_false_node
)
7779 return potential_constant_expression_1 (TREE_OPERAND (t
, 2),
7781 for (i
= 1; i
< 3; ++i
)
7782 if (potential_constant_expression_1 (TREE_OPERAND (t
, i
),
7783 want_rval
, tf_none
))
7785 if (flags
& tf_error
)
7786 error ("expression %qE is not a constant-expression", t
);
7790 if (VEC_INIT_EXPR_IS_CONSTEXPR (t
))
7792 if (flags
& tf_error
)
7794 error ("non-constant array initialization");
7795 diagnose_non_constexpr_vec_init (t
);
7800 sorry ("unexpected ast of kind %s", tree_code_name
[TREE_CODE (t
)]);
7806 /* The main entry point to the above. */
7809 potential_constant_expression (tree t
)
7811 return potential_constant_expression_1 (t
, false, tf_none
);
7814 /* As above, but require a constant rvalue. */
7817 potential_rvalue_constant_expression (tree t
)
7819 return potential_constant_expression_1 (t
, true, tf_none
);
7822 /* Like above, but complain about non-constant expressions. */
7825 require_potential_constant_expression (tree t
)
7827 return potential_constant_expression_1 (t
, false, tf_warning_or_error
);
7830 /* Cross product of the above. */
7833 require_potential_rvalue_constant_expression (tree t
)
7835 return potential_constant_expression_1 (t
, true, tf_warning_or_error
);
7838 /* Constructor for a lambda expression. */
7841 build_lambda_expr (void)
7843 tree lambda
= make_node (LAMBDA_EXPR
);
7844 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda
) = CPLD_NONE
;
7845 LAMBDA_EXPR_CAPTURE_LIST (lambda
) = NULL_TREE
;
7846 LAMBDA_EXPR_THIS_CAPTURE (lambda
) = NULL_TREE
;
7847 LAMBDA_EXPR_RETURN_TYPE (lambda
) = NULL_TREE
;
7848 LAMBDA_EXPR_MUTABLE_P (lambda
) = false;
7852 /* Create the closure object for a LAMBDA_EXPR. */
7855 build_lambda_object (tree lambda_expr
)
7857 /* Build aggregate constructor call.
7858 - cp_parser_braced_list
7859 - cp_parser_functional_cast */
7860 VEC(constructor_elt
,gc
) *elts
= NULL
;
7861 tree node
, expr
, type
;
7862 location_t saved_loc
;
7864 if (processing_template_decl
)
7867 /* Make sure any error messages refer to the lambda-introducer. */
7868 saved_loc
= input_location
;
7869 input_location
= LAMBDA_EXPR_LOCATION (lambda_expr
);
7871 for (node
= LAMBDA_EXPR_CAPTURE_LIST (lambda_expr
);
7873 node
= TREE_CHAIN (node
))
7875 tree field
= TREE_PURPOSE (node
);
7876 tree val
= TREE_VALUE (node
);
7878 if (field
== error_mark_node
)
7880 expr
= error_mark_node
;
7887 /* Mere mortals can't copy arrays with aggregate initialization, so
7888 do some magic to make it work here. */
7889 if (TREE_CODE (TREE_TYPE (field
)) == ARRAY_TYPE
)
7890 val
= build_array_copy (val
);
7891 else if (DECL_NORMAL_CAPTURE_P (field
)
7892 && TREE_CODE (TREE_TYPE (field
)) != REFERENCE_TYPE
)
7894 /* "the entities that are captured by copy are used to
7895 direct-initialize each corresponding non-static data
7896 member of the resulting closure object."
7898 There's normally no way to express direct-initialization
7899 from an element of a CONSTRUCTOR, so we build up a special
7900 TARGET_EXPR to bypass the usual copy-initialization. */
7901 val
= force_rvalue (val
);
7902 if (TREE_CODE (val
) == TARGET_EXPR
)
7903 TARGET_EXPR_DIRECT_INIT_P (val
) = true;
7906 CONSTRUCTOR_APPEND_ELT (elts
, DECL_NAME (field
), val
);
7909 expr
= build_constructor (init_list_type_node
, elts
);
7910 CONSTRUCTOR_IS_DIRECT_INIT (expr
) = 1;
7912 /* N2927: "[The closure] class type is not an aggregate."
7913 But we briefly treat it as an aggregate to make this simpler. */
7914 type
= TREE_TYPE (lambda_expr
);
7915 CLASSTYPE_NON_AGGREGATE (type
) = 0;
7916 expr
= finish_compound_literal (type
, expr
);
7917 CLASSTYPE_NON_AGGREGATE (type
) = 1;
7920 input_location
= saved_loc
;
7924 /* Return an initialized RECORD_TYPE for LAMBDA.
7925 LAMBDA must have its explicit captures already. */
7928 begin_lambda_type (tree lambda
)
7933 /* Unique name. This is just like an unnamed class, but we cannot use
7934 make_anon_name because of certain checks against TYPE_ANONYMOUS_P. */
7936 name
= make_lambda_name ();
7938 /* Create the new RECORD_TYPE for this lambda. */
7939 type
= xref_tag (/*tag_code=*/record_type
,
7941 /*scope=*/ts_within_enclosing_non_class
,
7942 /*template_header_p=*/false);
7945 /* Designate it as a struct so that we can use aggregate initialization. */
7946 CLASSTYPE_DECLARED_CLASS (type
) = false;
7948 /* Clear base types. */
7949 xref_basetypes (type
, /*bases=*/NULL_TREE
);
7951 /* Start the class. */
7952 type
= begin_class_definition (type
, /*attributes=*/NULL_TREE
);
7954 /* Cross-reference the expression and the type. */
7955 TREE_TYPE (lambda
) = type
;
7956 CLASSTYPE_LAMBDA_EXPR (type
) = lambda
;
7961 /* Returns the type to use for the return type of the operator() of a
7965 lambda_return_type (tree expr
)
7968 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
7970 warning (0, "cannot deduce lambda return type from a braced-init-list");
7971 return void_type_node
;
7973 if (type_dependent_expression_p (expr
))
7975 type
= cxx_make_type (DECLTYPE_TYPE
);
7976 DECLTYPE_TYPE_EXPR (type
) = expr
;
7977 DECLTYPE_FOR_LAMBDA_RETURN (type
) = true;
7978 SET_TYPE_STRUCTURAL_EQUALITY (type
);
7981 type
= type_decays_to (unlowered_expr_type (expr
));
7985 /* Given a LAMBDA_EXPR or closure type LAMBDA, return the op() of the
7989 lambda_function (tree lambda
)
7992 if (TREE_CODE (lambda
) == LAMBDA_EXPR
)
7993 type
= TREE_TYPE (lambda
);
7996 gcc_assert (LAMBDA_TYPE_P (type
));
7997 /* Don't let debug_tree cause instantiation. */
7998 if (CLASSTYPE_TEMPLATE_INSTANTIATION (type
) && !COMPLETE_TYPE_P (type
))
8000 lambda
= lookup_member (type
, ansi_opname (CALL_EXPR
),
8001 /*protect=*/0, /*want_type=*/false);
8003 lambda
= BASELINK_FUNCTIONS (lambda
);
8007 /* Returns the type to use for the FIELD_DECL corresponding to the
8009 The caller should add REFERENCE_TYPE for capture by reference. */
8012 lambda_capture_field_type (tree expr
)
8015 if (type_dependent_expression_p (expr
))
8017 type
= cxx_make_type (DECLTYPE_TYPE
);
8018 DECLTYPE_TYPE_EXPR (type
) = expr
;
8019 DECLTYPE_FOR_LAMBDA_CAPTURE (type
) = true;
8020 SET_TYPE_STRUCTURAL_EQUALITY (type
);
8023 type
= non_reference (unlowered_expr_type (expr
));
8027 /* Recompute the return type for LAMBDA with body of the form:
8028 { return EXPR ; } */
8031 apply_lambda_return_type (tree lambda
, tree return_type
)
8033 tree fco
= lambda_function (lambda
);
8036 LAMBDA_EXPR_RETURN_TYPE (lambda
) = return_type
;
8038 /* If we got a DECLTYPE_TYPE, don't stick it in the function yet,
8039 it would interfere with instantiating the closure type. */
8040 if (dependent_type_p (return_type
))
8042 if (return_type
== error_mark_node
)
8045 /* TREE_TYPE (FUNCTION_DECL) == METHOD_TYPE
8046 TREE_TYPE (METHOD_TYPE) == return-type */
8047 TREE_TYPE (fco
) = change_return_type (return_type
, TREE_TYPE (fco
));
8049 result
= DECL_RESULT (fco
);
8050 if (result
== NULL_TREE
)
8053 /* We already have a DECL_RESULT from start_preparsed_function.
8054 Now we need to redo the work it and allocate_struct_function
8055 did to reflect the new type. */
8056 result
= build_decl (input_location
, RESULT_DECL
, NULL_TREE
,
8057 TYPE_MAIN_VARIANT (return_type
));
8058 DECL_ARTIFICIAL (result
) = 1;
8059 DECL_IGNORED_P (result
) = 1;
8060 cp_apply_type_quals_to_decl (cp_type_quals (return_type
),
8063 DECL_RESULT (fco
) = result
;
8065 if (!processing_template_decl
&& aggregate_value_p (result
, fco
))
8067 #ifdef PCC_STATIC_STRUCT_RETURN
8068 cfun
->returns_pcc_struct
= 1;
8070 cfun
->returns_struct
= 1;
8075 /* DECL is a local variable or parameter from the surrounding scope of a
8076 lambda-expression. Returns the decltype for a use of the capture field
8077 for DECL even if it hasn't been captured yet. */
8080 capture_decltype (tree decl
)
8082 tree lam
= CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (current_function_decl
));
8083 /* FIXME do lookup instead of list walk? */
8084 tree cap
= value_member (decl
, LAMBDA_EXPR_CAPTURE_LIST (lam
));
8088 type
= TREE_TYPE (TREE_PURPOSE (cap
));
8090 switch (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lam
))
8093 error ("%qD is not captured", decl
);
8094 return error_mark_node
;
8097 type
= TREE_TYPE (decl
);
8098 if (TREE_CODE (type
) == REFERENCE_TYPE
8099 && TREE_CODE (TREE_TYPE (type
)) != FUNCTION_TYPE
)
8100 type
= TREE_TYPE (type
);
8103 case CPLD_REFERENCE
:
8104 type
= TREE_TYPE (decl
);
8105 if (TREE_CODE (type
) != REFERENCE_TYPE
)
8106 type
= build_reference_type (TREE_TYPE (decl
));
8113 if (TREE_CODE (type
) != REFERENCE_TYPE
)
8115 if (!LAMBDA_EXPR_MUTABLE_P (lam
))
8116 type
= cp_build_qualified_type (type
, (cp_type_quals (type
)
8118 type
= build_reference_type (type
);
8123 /* From an ID and INITIALIZER, create a capture (by reference if
8124 BY_REFERENCE_P is true), add it to the capture-list for LAMBDA,
8128 add_capture (tree lambda
, tree id
, tree initializer
, bool by_reference_p
,
8129 bool explicit_init_p
)
8134 type
= lambda_capture_field_type (initializer
);
8137 type
= build_reference_type (type
);
8138 if (!real_lvalue_p (initializer
))
8139 error ("cannot capture %qE by reference", initializer
);
8142 /* Make member variable. */
8143 member
= build_lang_decl (FIELD_DECL
, id
, type
);
8144 if (!explicit_init_p
)
8145 /* Normal captures are invisible to name lookup but uses are replaced
8146 with references to the capture field; we implement this by only
8147 really making them invisible in unevaluated context; see
8148 qualify_lookup. For now, let's make explicitly initialized captures
8150 DECL_NORMAL_CAPTURE_P (member
) = true;
8152 /* Add it to the appropriate closure class if we've started it. */
8153 if (current_class_type
&& current_class_type
== TREE_TYPE (lambda
))
8154 finish_member_declaration (member
);
8156 LAMBDA_EXPR_CAPTURE_LIST (lambda
)
8157 = tree_cons (member
, initializer
, LAMBDA_EXPR_CAPTURE_LIST (lambda
));
8159 if (id
== get_identifier ("__this"))
8161 if (LAMBDA_EXPR_CAPTURES_THIS_P (lambda
))
8162 error ("already captured %<this%> in lambda expression");
8163 LAMBDA_EXPR_THIS_CAPTURE (lambda
) = member
;
8169 /* Register all the capture members on the list CAPTURES, which is the
8170 LAMBDA_EXPR_CAPTURE_LIST for the lambda after the introducer. */
8172 void register_capture_members (tree captures
)
8176 register_capture_members (TREE_CHAIN (captures
));
8177 finish_member_declaration (TREE_PURPOSE (captures
));
8181 /* Given a FIELD_DECL decl belonging to a closure type, return a
8182 COMPONENT_REF of it relative to the 'this' parameter of the op() for
8186 thisify_lambda_field (tree decl
)
8188 tree context
= lambda_function (DECL_CONTEXT (decl
));
8189 tree object
= cp_build_indirect_ref (DECL_ARGUMENTS (context
),
8191 tf_warning_or_error
);
8192 return finish_non_static_data_member (decl
, object
,
8193 /*qualifying_scope*/NULL_TREE
);
8196 /* Similar to add_capture, except this works on a stack of nested lambdas.
8197 BY_REFERENCE_P in this case is derived from the default capture mode.
8198 Returns the capture for the lambda at the bottom of the stack. */
8201 add_default_capture (tree lambda_stack
, tree id
, tree initializer
)
8203 bool this_capture_p
= (id
== get_identifier ("__this"));
8205 tree member
= NULL_TREE
;
8207 tree saved_class_type
= current_class_type
;
8211 for (node
= lambda_stack
;
8213 node
= TREE_CHAIN (node
))
8215 tree lambda
= TREE_VALUE (node
);
8217 current_class_type
= TREE_TYPE (lambda
);
8218 member
= add_capture (lambda
,
8223 && (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda
)
8224 == CPLD_REFERENCE
)),
8225 /*explicit_init_p=*/false);
8226 initializer
= thisify_lambda_field (member
);
8229 current_class_type
= saved_class_type
;
8234 /* Return the capture pertaining to a use of 'this' in LAMBDA, in the form of an
8235 INDIRECT_REF, possibly adding it through default capturing. */
8238 lambda_expr_this_capture (tree lambda
)
8242 tree this_capture
= LAMBDA_EXPR_THIS_CAPTURE (lambda
);
8244 /* Try to default capture 'this' if we can. */
8246 && LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda
) != CPLD_NONE
)
8248 tree containing_function
= TYPE_CONTEXT (TREE_TYPE (lambda
));
8249 tree lambda_stack
= tree_cons (NULL_TREE
, lambda
, NULL_TREE
);
8250 tree init
= NULL_TREE
;
8252 /* If we are in a lambda function, we can move out until we hit:
8253 1. a non-lambda function,
8254 2. a lambda function capturing 'this', or
8255 3. a non-default capturing lambda function. */
8256 while (LAMBDA_FUNCTION_P (containing_function
))
8259 = CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (containing_function
));
8261 if (LAMBDA_EXPR_THIS_CAPTURE (lambda
))
8263 /* An outer lambda has already captured 'this'. */
8264 tree cap
= LAMBDA_EXPR_THIS_CAPTURE (lambda
);
8265 init
= thisify_lambda_field (cap
);
8269 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda
) == CPLD_NONE
)
8270 /* An outer lambda won't let us capture 'this'. */
8273 lambda_stack
= tree_cons (NULL_TREE
,
8277 containing_function
= decl_function_context (containing_function
);
8280 if (!init
&& DECL_NONSTATIC_MEMBER_FUNCTION_P (containing_function
)
8281 && !LAMBDA_FUNCTION_P (containing_function
))
8282 /* First parameter is 'this'. */
8283 init
= DECL_ARGUMENTS (containing_function
);
8286 this_capture
= add_default_capture (lambda_stack
,
8287 /*id=*/get_identifier ("__this"),
8293 error ("%<this%> was not captured for this lambda function");
8294 result
= error_mark_node
;
8298 /* To make sure that current_class_ref is for the lambda. */
8299 gcc_assert (TYPE_MAIN_VARIANT (TREE_TYPE (current_class_ref
)) == TREE_TYPE (lambda
));
8301 result
= finish_non_static_data_member (this_capture
,
8303 /*qualifying_scope=*/NULL_TREE
);
8305 /* If 'this' is captured, each use of 'this' is transformed into an
8306 access to the corresponding unnamed data member of the closure
8307 type cast (_expr.cast_ 5.4) to the type of 'this'. [ The cast
8308 ensures that the transformed expression is an rvalue. ] */
8309 result
= rvalue (result
);
8315 /* Returns the method basetype of the innermost non-lambda function, or
8316 NULL_TREE if none. */
8319 nonlambda_method_basetype (void)
8322 if (!current_class_ref
)
8325 type
= current_class_type
;
8326 if (!LAMBDA_TYPE_P (type
))
8329 /* Find the nearest enclosing non-lambda function. */
8330 fn
= TYPE_NAME (type
);
8332 fn
= decl_function_context (fn
);
8333 while (fn
&& LAMBDA_FUNCTION_P (fn
));
8335 if (!fn
|| !DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
8338 return TYPE_METHOD_BASETYPE (TREE_TYPE (fn
));
8341 /* If the closure TYPE has a static op(), also add a conversion to function
8345 maybe_add_lambda_conv_op (tree type
)
8347 bool nested
= (current_function_decl
!= NULL_TREE
);
8348 tree callop
= lambda_function (type
);
8349 tree rettype
, name
, fntype
, fn
, body
, compound_stmt
;
8350 tree thistype
, stattype
, statfn
, convfn
, call
, arg
;
8351 VEC (tree
, gc
) *argvec
;
8353 if (LAMBDA_EXPR_CAPTURE_LIST (CLASSTYPE_LAMBDA_EXPR (type
)) != NULL_TREE
)
8356 stattype
= build_function_type (TREE_TYPE (TREE_TYPE (callop
)),
8357 FUNCTION_ARG_CHAIN (callop
));
8359 /* First build up the conversion op. */
8361 rettype
= build_pointer_type (stattype
);
8362 name
= mangle_conv_op_name_for_type (rettype
);
8363 thistype
= cp_build_qualified_type (type
, TYPE_QUAL_CONST
);
8364 fntype
= build_method_type_directly (thistype
, rettype
, void_list_node
);
8365 fn
= convfn
= build_lang_decl (FUNCTION_DECL
, name
, fntype
);
8366 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (callop
);
8368 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
8369 && DECL_ALIGN (fn
) < 2 * BITS_PER_UNIT
)
8370 DECL_ALIGN (fn
) = 2 * BITS_PER_UNIT
;
8372 SET_OVERLOADED_OPERATOR_CODE (fn
, TYPE_EXPR
);
8373 grokclassfn (type
, fn
, NO_SPECIAL
);
8374 set_linkage_according_to_type (type
, fn
);
8375 rest_of_decl_compilation (fn
, toplevel_bindings_p (), at_eof
);
8376 DECL_IN_AGGR_P (fn
) = 1;
8377 DECL_ARTIFICIAL (fn
) = 1;
8378 DECL_NOT_REALLY_EXTERN (fn
) = 1;
8379 DECL_DECLARED_INLINE_P (fn
) = 1;
8380 DECL_ARGUMENTS (fn
) = build_this_parm (fntype
, TYPE_QUAL_CONST
);
8382 DECL_INTERFACE_KNOWN (fn
) = 1;
8384 add_method (type
, fn
, NULL_TREE
);
8386 /* Generic thunk code fails for varargs; we'll complain in mark_used if
8387 the conversion op is used. */
8388 if (varargs_function_p (callop
))
8390 DECL_DELETED_FN (fn
) = 1;
8394 /* Now build up the thunk to be returned. */
8396 name
= get_identifier ("_FUN");
8397 fn
= statfn
= build_lang_decl (FUNCTION_DECL
, name
, stattype
);
8398 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (callop
);
8399 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
8400 && DECL_ALIGN (fn
) < 2 * BITS_PER_UNIT
)
8401 DECL_ALIGN (fn
) = 2 * BITS_PER_UNIT
;
8402 grokclassfn (type
, fn
, NO_SPECIAL
);
8403 set_linkage_according_to_type (type
, fn
);
8404 rest_of_decl_compilation (fn
, toplevel_bindings_p (), at_eof
);
8405 DECL_IN_AGGR_P (fn
) = 1;
8406 DECL_ARTIFICIAL (fn
) = 1;
8407 DECL_NOT_REALLY_EXTERN (fn
) = 1;
8408 DECL_DECLARED_INLINE_P (fn
) = 1;
8409 DECL_STATIC_FUNCTION_P (fn
) = 1;
8410 DECL_ARGUMENTS (fn
) = copy_list (DECL_CHAIN (DECL_ARGUMENTS (callop
)));
8411 for (arg
= DECL_ARGUMENTS (fn
); arg
; arg
= DECL_CHAIN (arg
))
8412 DECL_CONTEXT (arg
) = fn
;
8414 DECL_INTERFACE_KNOWN (fn
) = 1;
8416 add_method (type
, fn
, NULL_TREE
);
8419 push_function_context ();
8421 /* Generate the body of the thunk. */
8423 start_preparsed_function (statfn
, NULL_TREE
,
8424 SF_PRE_PARSED
| SF_INCLASS_INLINE
);
8425 if (DECL_ONE_ONLY (statfn
))
8427 /* Put the thunk in the same comdat group as the call op. */
8428 struct cgraph_node
*callop_node
, *thunk_node
;
8429 DECL_COMDAT_GROUP (statfn
) = DECL_COMDAT_GROUP (callop
);
8430 callop_node
= cgraph_node (callop
);
8431 thunk_node
= cgraph_node (statfn
);
8432 gcc_assert (callop_node
->same_comdat_group
== NULL
);
8433 gcc_assert (thunk_node
->same_comdat_group
== NULL
);
8434 callop_node
->same_comdat_group
= thunk_node
;
8435 thunk_node
->same_comdat_group
= callop_node
;
8437 body
= begin_function_body ();
8438 compound_stmt
= begin_compound_stmt (0);
8440 arg
= build1 (NOP_EXPR
, TREE_TYPE (DECL_ARGUMENTS (callop
)),
8442 argvec
= make_tree_vector ();
8443 VEC_quick_push (tree
, argvec
, arg
);
8444 for (arg
= DECL_ARGUMENTS (statfn
); arg
; arg
= DECL_CHAIN (arg
))
8445 VEC_safe_push (tree
, gc
, argvec
, arg
);
8446 call
= build_call_a (callop
, VEC_length (tree
, argvec
),
8447 VEC_address (tree
, argvec
));
8448 CALL_FROM_THUNK_P (call
) = 1;
8449 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (call
)))
8450 call
= build_cplus_new (TREE_TYPE (call
), call
);
8451 call
= convert_from_reference (call
);
8452 finish_return_stmt (call
);
8454 finish_compound_stmt (compound_stmt
);
8455 finish_function_body (body
);
8457 expand_or_defer_fn (finish_function (2));
8459 /* Generate the body of the conversion op. */
8461 start_preparsed_function (convfn
, NULL_TREE
,
8462 SF_PRE_PARSED
| SF_INCLASS_INLINE
);
8463 body
= begin_function_body ();
8464 compound_stmt
= begin_compound_stmt (0);
8466 finish_return_stmt (decay_conversion (statfn
));
8468 finish_compound_stmt (compound_stmt
);
8469 finish_function_body (body
);
8471 expand_or_defer_fn (finish_function (2));
8474 pop_function_context ();
8476 #include "gt-cp-semantics.h"