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 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
)
864 scope
= begin_for_scope (&init
);
866 FOR_INIT_STMT (r
) = init
;
867 TREE_CHAIN (r
) = scope
;
872 /* Finish the for-init-statement of a for-statement, which may be
873 given by FOR_STMT. */
876 finish_for_init_stmt (tree for_stmt
)
878 if (processing_template_decl
)
879 FOR_INIT_STMT (for_stmt
) = pop_stmt_list (FOR_INIT_STMT (for_stmt
));
881 FOR_BODY (for_stmt
) = do_pushlevel (sk_block
);
882 begin_cond (&FOR_COND (for_stmt
));
885 /* Finish the COND of a for-statement, which may be given by
889 finish_for_cond (tree cond
, tree for_stmt
)
891 finish_cond (&FOR_COND (for_stmt
), maybe_convert_cond (cond
));
892 simplify_loop_decl_cond (&FOR_COND (for_stmt
), FOR_BODY (for_stmt
));
895 /* Finish the increment-EXPRESSION in a for-statement, which may be
896 given by FOR_STMT. */
899 finish_for_expr (tree expr
, tree for_stmt
)
903 /* If EXPR is an overloaded function, issue an error; there is no
904 context available to use to perform overload resolution. */
905 if (type_unknown_p (expr
))
907 cxx_incomplete_type_error (expr
, TREE_TYPE (expr
));
908 expr
= error_mark_node
;
910 if (!processing_template_decl
)
912 if (warn_sequence_point
)
913 verify_sequence_points (expr
);
914 expr
= convert_to_void (expr
, ICV_THIRD_IN_FOR
,
915 tf_warning_or_error
);
917 else if (!type_dependent_expression_p (expr
))
918 convert_to_void (build_non_dependent_expr (expr
), ICV_THIRD_IN_FOR
,
919 tf_warning_or_error
);
920 expr
= maybe_cleanup_point_expr_void (expr
);
921 if (check_for_bare_parameter_packs (expr
))
922 expr
= error_mark_node
;
923 FOR_EXPR (for_stmt
) = expr
;
926 /* Finish the body of a for-statement, which may be given by
927 FOR_STMT. The increment-EXPR for the loop must be
929 It can also finish RANGE_FOR_STMT. */
932 finish_for_stmt (tree for_stmt
)
934 if (TREE_CODE (for_stmt
) == RANGE_FOR_STMT
)
935 RANGE_FOR_BODY (for_stmt
) = do_poplevel (RANGE_FOR_BODY (for_stmt
));
937 FOR_BODY (for_stmt
) = do_poplevel (FOR_BODY (for_stmt
));
939 /* Pop the scope for the body of the loop. */
940 if (flag_new_for_scope
> 0)
942 tree scope
= TREE_CHAIN (for_stmt
);
943 TREE_CHAIN (for_stmt
) = NULL
;
944 add_stmt (do_poplevel (scope
));
950 /* Begin a range-for-statement. Returns a new RANGE_FOR_STMT.
951 SCOPE and INIT should be the return of begin_for_scope,
953 To finish it call finish_for_stmt(). */
956 begin_range_for_stmt (tree scope
, tree init
)
960 r
= build_stmt (input_location
, RANGE_FOR_STMT
,
961 NULL_TREE
, NULL_TREE
, NULL_TREE
);
963 if (scope
== NULL_TREE
)
966 scope
= begin_for_scope (&init
);
969 /* RANGE_FOR_STMTs do not use nor save the init tree, so we
972 pop_stmt_list (init
);
973 TREE_CHAIN (r
) = scope
;
978 /* Finish the head of a range-based for statement, which may
979 be given by RANGE_FOR_STMT. DECL must be the declaration
980 and EXPR must be the loop expression. */
983 finish_range_for_decl (tree range_for_stmt
, tree decl
, tree expr
)
985 RANGE_FOR_DECL (range_for_stmt
) = decl
;
986 RANGE_FOR_EXPR (range_for_stmt
) = expr
;
987 add_stmt (range_for_stmt
);
988 RANGE_FOR_BODY (range_for_stmt
) = do_pushlevel (sk_block
);
991 /* Finish a break-statement. */
994 finish_break_stmt (void)
996 return add_stmt (build_stmt (input_location
, BREAK_STMT
));
999 /* Finish a continue-statement. */
1002 finish_continue_stmt (void)
1004 return add_stmt (build_stmt (input_location
, CONTINUE_STMT
));
1007 /* Begin a switch-statement. Returns a new SWITCH_STMT if
1011 begin_switch_stmt (void)
1015 r
= build_stmt (input_location
, SWITCH_STMT
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
1017 scope
= do_pushlevel (sk_block
);
1018 TREE_CHAIN (r
) = scope
;
1019 begin_cond (&SWITCH_STMT_COND (r
));
1024 /* Finish the cond of a switch-statement. */
1027 finish_switch_cond (tree cond
, tree switch_stmt
)
1029 tree orig_type
= NULL
;
1030 if (!processing_template_decl
)
1032 /* Convert the condition to an integer or enumeration type. */
1033 cond
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
, cond
, true);
1034 if (cond
== NULL_TREE
)
1036 error ("switch quantity not an integer");
1037 cond
= error_mark_node
;
1039 orig_type
= TREE_TYPE (cond
);
1040 if (cond
!= error_mark_node
)
1044 Integral promotions are performed. */
1045 cond
= perform_integral_promotions (cond
);
1046 cond
= maybe_cleanup_point_expr (cond
);
1049 if (check_for_bare_parameter_packs (cond
))
1050 cond
= error_mark_node
;
1051 else if (!processing_template_decl
&& warn_sequence_point
)
1052 verify_sequence_points (cond
);
1054 finish_cond (&SWITCH_STMT_COND (switch_stmt
), cond
);
1055 SWITCH_STMT_TYPE (switch_stmt
) = orig_type
;
1056 add_stmt (switch_stmt
);
1057 push_switch (switch_stmt
);
1058 SWITCH_STMT_BODY (switch_stmt
) = push_stmt_list ();
1061 /* Finish the body of a switch-statement, which may be given by
1062 SWITCH_STMT. The COND to switch on is indicated. */
1065 finish_switch_stmt (tree switch_stmt
)
1069 SWITCH_STMT_BODY (switch_stmt
) =
1070 pop_stmt_list (SWITCH_STMT_BODY (switch_stmt
));
1074 scope
= TREE_CHAIN (switch_stmt
);
1075 TREE_CHAIN (switch_stmt
) = NULL
;
1076 add_stmt (do_poplevel (scope
));
1079 /* Begin a try-block. Returns a newly-created TRY_BLOCK if
1083 begin_try_block (void)
1085 tree r
= build_stmt (input_location
, TRY_BLOCK
, NULL_TREE
, NULL_TREE
);
1087 TRY_STMTS (r
) = push_stmt_list ();
1091 /* Likewise, for a function-try-block. The block returned in
1092 *COMPOUND_STMT is an artificial outer scope, containing the
1093 function-try-block. */
1096 begin_function_try_block (tree
*compound_stmt
)
1099 /* This outer scope does not exist in the C++ standard, but we need
1100 a place to put __FUNCTION__ and similar variables. */
1101 *compound_stmt
= begin_compound_stmt (0);
1102 r
= begin_try_block ();
1103 FN_TRY_BLOCK_P (r
) = 1;
1107 /* Finish a try-block, which may be given by TRY_BLOCK. */
1110 finish_try_block (tree try_block
)
1112 TRY_STMTS (try_block
) = pop_stmt_list (TRY_STMTS (try_block
));
1113 TRY_HANDLERS (try_block
) = push_stmt_list ();
1116 /* Finish the body of a cleanup try-block, which may be given by
1120 finish_cleanup_try_block (tree try_block
)
1122 TRY_STMTS (try_block
) = pop_stmt_list (TRY_STMTS (try_block
));
1125 /* Finish an implicitly generated try-block, with a cleanup is given
1129 finish_cleanup (tree cleanup
, tree try_block
)
1131 TRY_HANDLERS (try_block
) = cleanup
;
1132 CLEANUP_P (try_block
) = 1;
1135 /* Likewise, for a function-try-block. */
1138 finish_function_try_block (tree try_block
)
1140 finish_try_block (try_block
);
1141 /* FIXME : something queer about CTOR_INITIALIZER somehow following
1142 the try block, but moving it inside. */
1143 in_function_try_handler
= 1;
1146 /* Finish a handler-sequence for a try-block, which may be given by
1150 finish_handler_sequence (tree try_block
)
1152 TRY_HANDLERS (try_block
) = pop_stmt_list (TRY_HANDLERS (try_block
));
1153 check_handlers (TRY_HANDLERS (try_block
));
1156 /* Finish the handler-seq for a function-try-block, given by
1157 TRY_BLOCK. COMPOUND_STMT is the outer block created by
1158 begin_function_try_block. */
1161 finish_function_handler_sequence (tree try_block
, tree compound_stmt
)
1163 in_function_try_handler
= 0;
1164 finish_handler_sequence (try_block
);
1165 finish_compound_stmt (compound_stmt
);
1168 /* Begin a handler. Returns a HANDLER if appropriate. */
1171 begin_handler (void)
1175 r
= build_stmt (input_location
, HANDLER
, NULL_TREE
, NULL_TREE
);
1178 /* Create a binding level for the eh_info and the exception object
1180 HANDLER_BODY (r
) = do_pushlevel (sk_catch
);
1185 /* Finish the handler-parameters for a handler, which may be given by
1186 HANDLER. DECL is the declaration for the catch parameter, or NULL
1187 if this is a `catch (...)' clause. */
1190 finish_handler_parms (tree decl
, tree handler
)
1192 tree type
= NULL_TREE
;
1193 if (processing_template_decl
)
1197 decl
= pushdecl (decl
);
1198 decl
= push_template_decl (decl
);
1199 HANDLER_PARMS (handler
) = decl
;
1200 type
= TREE_TYPE (decl
);
1204 type
= expand_start_catch_block (decl
);
1205 HANDLER_TYPE (handler
) = type
;
1206 if (!processing_template_decl
&& type
)
1207 mark_used (eh_type_info (type
));
1210 /* Finish a handler, which may be given by HANDLER. The BLOCKs are
1211 the return value from the matching call to finish_handler_parms. */
1214 finish_handler (tree handler
)
1216 if (!processing_template_decl
)
1217 expand_end_catch_block ();
1218 HANDLER_BODY (handler
) = do_poplevel (HANDLER_BODY (handler
));
1221 /* Begin a compound statement. FLAGS contains some bits that control the
1222 behavior and context. If BCS_NO_SCOPE is set, the compound statement
1223 does not define a scope. If BCS_FN_BODY is set, this is the outermost
1224 block of a function. If BCS_TRY_BLOCK is set, this is the block
1225 created on behalf of a TRY statement. Returns a token to be passed to
1226 finish_compound_stmt. */
1229 begin_compound_stmt (unsigned int flags
)
1233 if (flags
& BCS_NO_SCOPE
)
1235 r
= push_stmt_list ();
1236 STATEMENT_LIST_NO_SCOPE (r
) = 1;
1238 /* Normally, we try hard to keep the BLOCK for a statement-expression.
1239 But, if it's a statement-expression with a scopeless block, there's
1240 nothing to keep, and we don't want to accidentally keep a block
1241 *inside* the scopeless block. */
1242 keep_next_level (false);
1245 r
= do_pushlevel (flags
& BCS_TRY_BLOCK
? sk_try
: sk_block
);
1247 /* When processing a template, we need to remember where the braces were,
1248 so that we can set up identical scopes when instantiating the template
1249 later. BIND_EXPR is a handy candidate for this.
1250 Note that do_poplevel won't create a BIND_EXPR itself here (and thus
1251 result in nested BIND_EXPRs), since we don't build BLOCK nodes when
1252 processing templates. */
1253 if (processing_template_decl
)
1255 r
= build3 (BIND_EXPR
, NULL
, NULL
, r
, NULL
);
1256 BIND_EXPR_TRY_BLOCK (r
) = (flags
& BCS_TRY_BLOCK
) != 0;
1257 BIND_EXPR_BODY_BLOCK (r
) = (flags
& BCS_FN_BODY
) != 0;
1258 TREE_SIDE_EFFECTS (r
) = 1;
1264 /* Finish a compound-statement, which is given by STMT. */
1267 finish_compound_stmt (tree stmt
)
1269 if (TREE_CODE (stmt
) == BIND_EXPR
)
1271 tree body
= do_poplevel (BIND_EXPR_BODY (stmt
));
1272 /* If the STATEMENT_LIST is empty and this BIND_EXPR isn't special,
1273 discard the BIND_EXPR so it can be merged with the containing
1275 if (TREE_CODE (body
) == STATEMENT_LIST
1276 && STATEMENT_LIST_HEAD (body
) == NULL
1277 && !BIND_EXPR_BODY_BLOCK (stmt
)
1278 && !BIND_EXPR_TRY_BLOCK (stmt
))
1281 BIND_EXPR_BODY (stmt
) = body
;
1283 else if (STATEMENT_LIST_NO_SCOPE (stmt
))
1284 stmt
= pop_stmt_list (stmt
);
1287 /* Destroy any ObjC "super" receivers that may have been
1289 objc_clear_super_receiver ();
1291 stmt
= do_poplevel (stmt
);
1294 /* ??? See c_end_compound_stmt wrt statement expressions. */
1299 /* Finish an asm-statement, whose components are a STRING, some
1300 OUTPUT_OPERANDS, some INPUT_OPERANDS, some CLOBBERS and some
1301 LABELS. Also note whether the asm-statement should be
1302 considered volatile. */
1305 finish_asm_stmt (int volatile_p
, tree string
, tree output_operands
,
1306 tree input_operands
, tree clobbers
, tree labels
)
1310 int ninputs
= list_length (input_operands
);
1311 int noutputs
= list_length (output_operands
);
1313 if (!processing_template_decl
)
1315 const char *constraint
;
1316 const char **oconstraints
;
1317 bool allows_mem
, allows_reg
, is_inout
;
1321 oconstraints
= XALLOCAVEC (const char *, noutputs
);
1323 string
= resolve_asm_operand_names (string
, output_operands
,
1324 input_operands
, labels
);
1326 for (i
= 0, t
= output_operands
; t
; t
= TREE_CHAIN (t
), ++i
)
1328 operand
= TREE_VALUE (t
);
1330 /* ??? Really, this should not be here. Users should be using a
1331 proper lvalue, dammit. But there's a long history of using
1332 casts in the output operands. In cases like longlong.h, this
1333 becomes a primitive form of typechecking -- if the cast can be
1334 removed, then the output operand had a type of the proper width;
1335 otherwise we'll get an error. Gross, but ... */
1336 STRIP_NOPS (operand
);
1338 operand
= mark_lvalue_use (operand
);
1340 if (!lvalue_or_else (operand
, lv_asm
, tf_warning_or_error
))
1341 operand
= error_mark_node
;
1343 if (operand
!= error_mark_node
1344 && (TREE_READONLY (operand
)
1345 || CP_TYPE_CONST_P (TREE_TYPE (operand
))
1346 /* Functions are not modifiable, even though they are
1348 || TREE_CODE (TREE_TYPE (operand
)) == FUNCTION_TYPE
1349 || TREE_CODE (TREE_TYPE (operand
)) == METHOD_TYPE
1350 /* If it's an aggregate and any field is const, then it is
1351 effectively const. */
1352 || (CLASS_TYPE_P (TREE_TYPE (operand
))
1353 && C_TYPE_FIELDS_READONLY (TREE_TYPE (operand
)))))
1354 cxx_readonly_error (operand
, lv_asm
);
1356 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
1357 oconstraints
[i
] = constraint
;
1359 if (parse_output_constraint (&constraint
, i
, ninputs
, noutputs
,
1360 &allows_mem
, &allows_reg
, &is_inout
))
1362 /* If the operand is going to end up in memory,
1363 mark it addressable. */
1364 if (!allows_reg
&& !cxx_mark_addressable (operand
))
1365 operand
= error_mark_node
;
1368 operand
= error_mark_node
;
1370 TREE_VALUE (t
) = operand
;
1373 for (i
= 0, t
= input_operands
; t
; ++i
, t
= TREE_CHAIN (t
))
1375 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
1376 operand
= decay_conversion (TREE_VALUE (t
));
1378 /* If the type of the operand hasn't been determined (e.g.,
1379 because it involves an overloaded function), then issue
1380 an error message. There's no context available to
1381 resolve the overloading. */
1382 if (TREE_TYPE (operand
) == unknown_type_node
)
1384 error ("type of asm operand %qE could not be determined",
1386 operand
= error_mark_node
;
1389 if (parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, 0,
1390 oconstraints
, &allows_mem
, &allows_reg
))
1392 /* If the operand is going to end up in memory,
1393 mark it addressable. */
1394 if (!allows_reg
&& allows_mem
)
1396 /* Strip the nops as we allow this case. FIXME, this really
1397 should be rejected or made deprecated. */
1398 STRIP_NOPS (operand
);
1399 if (!cxx_mark_addressable (operand
))
1400 operand
= error_mark_node
;
1404 operand
= error_mark_node
;
1406 TREE_VALUE (t
) = operand
;
1410 r
= build_stmt (input_location
, ASM_EXPR
, string
,
1411 output_operands
, input_operands
,
1413 ASM_VOLATILE_P (r
) = volatile_p
|| noutputs
== 0;
1414 r
= maybe_cleanup_point_expr_void (r
);
1415 return add_stmt (r
);
1418 /* Finish a label with the indicated NAME. Returns the new label. */
1421 finish_label_stmt (tree name
)
1423 tree decl
= define_label (input_location
, name
);
1425 if (decl
== error_mark_node
)
1426 return error_mark_node
;
1428 add_stmt (build_stmt (input_location
, LABEL_EXPR
, decl
));
1433 /* Finish a series of declarations for local labels. G++ allows users
1434 to declare "local" labels, i.e., labels with scope. This extension
1435 is useful when writing code involving statement-expressions. */
1438 finish_label_decl (tree name
)
1440 if (!at_function_scope_p ())
1442 error ("__label__ declarations are only allowed in function scopes");
1446 add_decl_expr (declare_local_label (name
));
1449 /* When DECL goes out of scope, make sure that CLEANUP is executed. */
1452 finish_decl_cleanup (tree decl
, tree cleanup
)
1454 push_cleanup (decl
, cleanup
, false);
1457 /* If the current scope exits with an exception, run CLEANUP. */
1460 finish_eh_cleanup (tree cleanup
)
1462 push_cleanup (NULL
, cleanup
, true);
1465 /* The MEM_INITS is a list of mem-initializers, in reverse of the
1466 order they were written by the user. Each node is as for
1467 emit_mem_initializers. */
1470 finish_mem_initializers (tree mem_inits
)
1472 /* Reorder the MEM_INITS so that they are in the order they appeared
1473 in the source program. */
1474 mem_inits
= nreverse (mem_inits
);
1476 if (processing_template_decl
)
1480 for (mem
= mem_inits
; mem
; mem
= TREE_CHAIN (mem
))
1482 /* If the TREE_PURPOSE is a TYPE_PACK_EXPANSION, skip the
1483 check for bare parameter packs in the TREE_VALUE, because
1484 any parameter packs in the TREE_VALUE have already been
1485 bound as part of the TREE_PURPOSE. See
1486 make_pack_expansion for more information. */
1487 if (TREE_CODE (TREE_PURPOSE (mem
)) != TYPE_PACK_EXPANSION
1488 && check_for_bare_parameter_packs (TREE_VALUE (mem
)))
1489 TREE_VALUE (mem
) = error_mark_node
;
1492 add_stmt (build_min_nt (CTOR_INITIALIZER
, mem_inits
));
1495 emit_mem_initializers (mem_inits
);
1498 /* Finish a parenthesized expression EXPR. */
1501 finish_parenthesized_expr (tree expr
)
1504 /* This inhibits warnings in c_common_truthvalue_conversion. */
1505 TREE_NO_WARNING (expr
) = 1;
1507 if (TREE_CODE (expr
) == OFFSET_REF
)
1508 /* [expr.unary.op]/3 The qualified id of a pointer-to-member must not be
1509 enclosed in parentheses. */
1510 PTRMEM_OK_P (expr
) = 0;
1512 if (TREE_CODE (expr
) == STRING_CST
)
1513 PAREN_STRING_LITERAL_P (expr
) = 1;
1518 /* Finish a reference to a non-static data member (DECL) that is not
1519 preceded by `.' or `->'. */
1522 finish_non_static_data_member (tree decl
, tree object
, tree qualifying_scope
)
1524 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
);
1528 tree scope
= qualifying_scope
;
1529 if (scope
== NULL_TREE
)
1530 scope
= context_for_name_lookup (decl
);
1531 object
= maybe_dummy_object (scope
, NULL
);
1534 /* DR 613: Can use non-static data members without an associated
1535 object in sizeof/decltype/alignof. */
1536 if (is_dummy_object (object
) && cp_unevaluated_operand
== 0
1537 && (!processing_template_decl
|| !current_class_ref
))
1539 if (current_function_decl
1540 && DECL_STATIC_FUNCTION_P (current_function_decl
))
1541 error ("invalid use of member %q+D in static member function", decl
);
1543 error ("invalid use of non-static data member %q+D", decl
);
1544 error ("from this location");
1546 return error_mark_node
;
1549 if (current_class_ptr
)
1550 TREE_USED (current_class_ptr
) = 1;
1551 if (processing_template_decl
&& !qualifying_scope
)
1553 tree type
= TREE_TYPE (decl
);
1555 if (TREE_CODE (type
) == REFERENCE_TYPE
)
1556 type
= TREE_TYPE (type
);
1559 /* Set the cv qualifiers. */
1560 int quals
= (current_class_ref
1561 ? cp_type_quals (TREE_TYPE (current_class_ref
))
1562 : TYPE_UNQUALIFIED
);
1564 if (DECL_MUTABLE_P (decl
))
1565 quals
&= ~TYPE_QUAL_CONST
;
1567 quals
|= cp_type_quals (TREE_TYPE (decl
));
1568 type
= cp_build_qualified_type (type
, quals
);
1571 return build_min (COMPONENT_REF
, type
, object
, decl
, NULL_TREE
);
1573 /* If PROCESSING_TEMPLATE_DECL is nonzero here, then
1574 QUALIFYING_SCOPE is also non-null. Wrap this in a SCOPE_REF
1576 else if (processing_template_decl
)
1577 return build_qualified_name (TREE_TYPE (decl
),
1580 /*template_p=*/false);
1583 tree access_type
= TREE_TYPE (object
);
1585 perform_or_defer_access_check (TYPE_BINFO (access_type
), decl
,
1588 /* If the data member was named `C::M', convert `*this' to `C'
1590 if (qualifying_scope
)
1592 tree binfo
= NULL_TREE
;
1593 object
= build_scoped_ref (object
, qualifying_scope
,
1597 return build_class_member_access_expr (object
, decl
,
1598 /*access_path=*/NULL_TREE
,
1599 /*preserve_reference=*/false,
1600 tf_warning_or_error
);
1604 /* If we are currently parsing a template and we encountered a typedef
1605 TYPEDEF_DECL that is being accessed though CONTEXT, this function
1606 adds the typedef to a list tied to the current template.
1607 At tempate instantiatin time, that list is walked and access check
1608 performed for each typedef.
1609 LOCATION is the location of the usage point of TYPEDEF_DECL. */
1612 add_typedef_to_current_template_for_access_check (tree typedef_decl
,
1614 location_t location
)
1616 tree template_info
= NULL
;
1617 tree cs
= current_scope ();
1619 if (!is_typedef_decl (typedef_decl
)
1621 || !CLASS_TYPE_P (context
)
1625 if (CLASS_TYPE_P (cs
) || TREE_CODE (cs
) == FUNCTION_DECL
)
1626 template_info
= get_template_info (cs
);
1629 && TI_TEMPLATE (template_info
)
1630 && !currently_open_class (context
))
1631 append_type_to_template_for_access_check (cs
, typedef_decl
,
1635 /* DECL was the declaration to which a qualified-id resolved. Issue
1636 an error message if it is not accessible. If OBJECT_TYPE is
1637 non-NULL, we have just seen `x->' or `x.' and OBJECT_TYPE is the
1638 type of `*x', or `x', respectively. If the DECL was named as
1639 `A::B' then NESTED_NAME_SPECIFIER is `A'. */
1642 check_accessibility_of_qualified_id (tree decl
,
1644 tree nested_name_specifier
)
1647 tree qualifying_type
= NULL_TREE
;
1649 /* If we are parsing a template declaration and if decl is a typedef,
1650 add it to a list tied to the template.
1651 At template instantiation time, that list will be walked and
1652 access check performed. */
1653 add_typedef_to_current_template_for_access_check (decl
,
1654 nested_name_specifier
1655 ? nested_name_specifier
1656 : DECL_CONTEXT (decl
),
1659 /* If we're not checking, return immediately. */
1660 if (deferred_access_no_check
)
1663 /* Determine the SCOPE of DECL. */
1664 scope
= context_for_name_lookup (decl
);
1665 /* If the SCOPE is not a type, then DECL is not a member. */
1666 if (!TYPE_P (scope
))
1668 /* Compute the scope through which DECL is being accessed. */
1670 /* OBJECT_TYPE might not be a class type; consider:
1672 class A { typedef int I; };
1676 In this case, we will have "A::I" as the DECL, but "I" as the
1678 && CLASS_TYPE_P (object_type
)
1679 && DERIVED_FROM_P (scope
, object_type
))
1680 /* If we are processing a `->' or `.' expression, use the type of the
1682 qualifying_type
= object_type
;
1683 else if (nested_name_specifier
)
1685 /* If the reference is to a non-static member of the
1686 current class, treat it as if it were referenced through
1688 if (DECL_NONSTATIC_MEMBER_P (decl
)
1689 && current_class_ptr
1690 && DERIVED_FROM_P (scope
, current_class_type
))
1691 qualifying_type
= current_class_type
;
1692 /* Otherwise, use the type indicated by the
1693 nested-name-specifier. */
1695 qualifying_type
= nested_name_specifier
;
1698 /* Otherwise, the name must be from the current class or one of
1700 qualifying_type
= currently_open_derived_class (scope
);
1703 /* It is possible for qualifying type to be a TEMPLATE_TYPE_PARM
1704 or similar in a default argument value. */
1705 && CLASS_TYPE_P (qualifying_type
)
1706 && !dependent_type_p (qualifying_type
))
1707 perform_or_defer_access_check (TYPE_BINFO (qualifying_type
), decl
,
1711 /* EXPR is the result of a qualified-id. The QUALIFYING_CLASS was the
1712 class named to the left of the "::" operator. DONE is true if this
1713 expression is a complete postfix-expression; it is false if this
1714 expression is followed by '->', '[', '(', etc. ADDRESS_P is true
1715 iff this expression is the operand of '&'. TEMPLATE_P is true iff
1716 the qualified-id was of the form "A::template B". TEMPLATE_ARG_P
1717 is true iff this qualified name appears as a template argument. */
1720 finish_qualified_id_expr (tree qualifying_class
,
1725 bool template_arg_p
)
1727 gcc_assert (TYPE_P (qualifying_class
));
1729 if (error_operand_p (expr
))
1730 return error_mark_node
;
1732 if (DECL_P (expr
) || BASELINK_P (expr
))
1736 check_template_keyword (expr
);
1738 /* If EXPR occurs as the operand of '&', use special handling that
1739 permits a pointer-to-member. */
1740 if (address_p
&& done
)
1742 if (TREE_CODE (expr
) == SCOPE_REF
)
1743 expr
= TREE_OPERAND (expr
, 1);
1744 expr
= build_offset_ref (qualifying_class
, expr
,
1745 /*address_p=*/true);
1749 /* Within the scope of a class, turn references to non-static
1750 members into expression of the form "this->...". */
1752 /* But, within a template argument, we do not want make the
1753 transformation, as there is no "this" pointer. */
1755 else if (TREE_CODE (expr
) == FIELD_DECL
)
1757 push_deferring_access_checks (dk_no_check
);
1758 expr
= finish_non_static_data_member (expr
, NULL_TREE
,
1760 pop_deferring_access_checks ();
1762 else if (BASELINK_P (expr
) && !processing_template_decl
)
1766 /* See if any of the functions are non-static members. */
1767 /* If so, the expression may be relative to 'this'. */
1768 if (!shared_member_p (expr
)
1769 && (ob
= maybe_dummy_object (qualifying_class
, NULL
),
1770 !is_dummy_object (ob
)))
1771 expr
= (build_class_member_access_expr
1774 BASELINK_ACCESS_BINFO (expr
),
1775 /*preserve_reference=*/false,
1776 tf_warning_or_error
));
1778 /* The expression is a qualified name whose address is not
1780 expr
= build_offset_ref (qualifying_class
, expr
, /*address_p=*/false);
1786 /* Begin a statement-expression. The value returned must be passed to
1787 finish_stmt_expr. */
1790 begin_stmt_expr (void)
1792 return push_stmt_list ();
1795 /* Process the final expression of a statement expression. EXPR can be
1796 NULL, if the final expression is empty. Return a STATEMENT_LIST
1797 containing all the statements in the statement-expression, or
1798 ERROR_MARK_NODE if there was an error. */
1801 finish_stmt_expr_expr (tree expr
, tree stmt_expr
)
1803 if (error_operand_p (expr
))
1805 /* The type of the statement-expression is the type of the last
1807 TREE_TYPE (stmt_expr
) = error_mark_node
;
1808 return error_mark_node
;
1811 /* If the last statement does not have "void" type, then the value
1812 of the last statement is the value of the entire expression. */
1815 tree type
= TREE_TYPE (expr
);
1817 if (processing_template_decl
)
1819 expr
= build_stmt (input_location
, EXPR_STMT
, expr
);
1820 expr
= add_stmt (expr
);
1821 /* Mark the last statement so that we can recognize it as such at
1822 template-instantiation time. */
1823 EXPR_STMT_STMT_EXPR_RESULT (expr
) = 1;
1825 else if (VOID_TYPE_P (type
))
1827 /* Just treat this like an ordinary statement. */
1828 expr
= finish_expr_stmt (expr
);
1832 /* It actually has a value we need to deal with. First, force it
1833 to be an rvalue so that we won't need to build up a copy
1834 constructor call later when we try to assign it to something. */
1835 expr
= force_rvalue (expr
);
1836 if (error_operand_p (expr
))
1837 return error_mark_node
;
1839 /* Update for array-to-pointer decay. */
1840 type
= TREE_TYPE (expr
);
1842 /* Wrap it in a CLEANUP_POINT_EXPR and add it to the list like a
1843 normal statement, but don't convert to void or actually add
1845 if (TREE_CODE (expr
) != CLEANUP_POINT_EXPR
)
1846 expr
= maybe_cleanup_point_expr (expr
);
1850 /* The type of the statement-expression is the type of the last
1852 TREE_TYPE (stmt_expr
) = type
;
1858 /* Finish a statement-expression. EXPR should be the value returned
1859 by the previous begin_stmt_expr. Returns an expression
1860 representing the statement-expression. */
1863 finish_stmt_expr (tree stmt_expr
, bool has_no_scope
)
1868 if (error_operand_p (stmt_expr
))
1870 pop_stmt_list (stmt_expr
);
1871 return error_mark_node
;
1874 gcc_assert (TREE_CODE (stmt_expr
) == STATEMENT_LIST
);
1876 type
= TREE_TYPE (stmt_expr
);
1877 result
= pop_stmt_list (stmt_expr
);
1878 TREE_TYPE (result
) = type
;
1880 if (processing_template_decl
)
1882 result
= build_min (STMT_EXPR
, type
, result
);
1883 TREE_SIDE_EFFECTS (result
) = 1;
1884 STMT_EXPR_NO_SCOPE (result
) = has_no_scope
;
1886 else if (CLASS_TYPE_P (type
))
1888 /* Wrap the statement-expression in a TARGET_EXPR so that the
1889 temporary object created by the final expression is destroyed at
1890 the end of the full-expression containing the
1891 statement-expression. */
1892 result
= force_target_expr (type
, result
);
1898 /* Returns the expression which provides the value of STMT_EXPR. */
1901 stmt_expr_value_expr (tree stmt_expr
)
1903 tree t
= STMT_EXPR_STMT (stmt_expr
);
1905 if (TREE_CODE (t
) == BIND_EXPR
)
1906 t
= BIND_EXPR_BODY (t
);
1908 if (TREE_CODE (t
) == STATEMENT_LIST
&& STATEMENT_LIST_TAIL (t
))
1909 t
= STATEMENT_LIST_TAIL (t
)->stmt
;
1911 if (TREE_CODE (t
) == EXPR_STMT
)
1912 t
= EXPR_STMT_EXPR (t
);
1917 /* Return TRUE iff EXPR_STMT is an empty list of
1918 expression statements. */
1921 empty_expr_stmt_p (tree expr_stmt
)
1923 tree body
= NULL_TREE
;
1925 if (expr_stmt
== void_zero_node
)
1930 if (TREE_CODE (expr_stmt
) == EXPR_STMT
)
1931 body
= EXPR_STMT_EXPR (expr_stmt
);
1932 else if (TREE_CODE (expr_stmt
) == STATEMENT_LIST
)
1938 if (TREE_CODE (body
) == STATEMENT_LIST
)
1939 return tsi_end_p (tsi_start (body
));
1941 return empty_expr_stmt_p (body
);
1946 /* Perform Koenig lookup. FN is the postfix-expression representing
1947 the function (or functions) to call; ARGS are the arguments to the
1948 call; if INCLUDE_STD then the `std' namespace is automatically
1949 considered an associated namespace (used in range-based for loops).
1950 Returns the functions to be considered by overload resolution. */
1953 perform_koenig_lookup (tree fn
, VEC(tree
,gc
) *args
, bool include_std
)
1955 tree identifier
= NULL_TREE
;
1956 tree functions
= NULL_TREE
;
1957 tree tmpl_args
= NULL_TREE
;
1958 bool template_id
= false;
1960 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
1962 /* Use a separate flag to handle null args. */
1964 tmpl_args
= TREE_OPERAND (fn
, 1);
1965 fn
= TREE_OPERAND (fn
, 0);
1968 /* Find the name of the overloaded function. */
1969 if (TREE_CODE (fn
) == IDENTIFIER_NODE
)
1971 else if (is_overloaded_fn (fn
))
1974 identifier
= DECL_NAME (get_first_fn (functions
));
1976 else if (DECL_P (fn
))
1979 identifier
= DECL_NAME (fn
);
1982 /* A call to a namespace-scope function using an unqualified name.
1984 Do Koenig lookup -- unless any of the arguments are
1986 if (!any_type_dependent_arguments_p (args
)
1987 && !any_dependent_template_arguments_p (tmpl_args
))
1989 fn
= lookup_arg_dependent (identifier
, functions
, args
, include_std
);
1991 /* The unqualified name could not be resolved. */
1992 fn
= unqualified_fn_lookup_error (identifier
);
1995 if (fn
&& template_id
)
1996 fn
= build2 (TEMPLATE_ID_EXPR
, unknown_type_node
, fn
, tmpl_args
);
2001 /* Generate an expression for `FN (ARGS)'. This may change the
2004 If DISALLOW_VIRTUAL is true, the call to FN will be not generated
2005 as a virtual call, even if FN is virtual. (This flag is set when
2006 encountering an expression where the function name is explicitly
2007 qualified. For example a call to `X::f' never generates a virtual
2010 Returns code for the call. */
2013 finish_call_expr (tree fn
, VEC(tree
,gc
) **args
, bool disallow_virtual
,
2014 bool koenig_p
, tsubst_flags_t complain
)
2018 VEC(tree
,gc
) *orig_args
= NULL
;
2020 if (fn
== error_mark_node
)
2021 return error_mark_node
;
2023 gcc_assert (!TYPE_P (fn
));
2027 if (processing_template_decl
)
2029 if (type_dependent_expression_p (fn
)
2030 || any_type_dependent_arguments_p (*args
))
2032 result
= build_nt_call_vec (fn
, *args
);
2033 KOENIG_LOOKUP_P (result
) = koenig_p
;
2038 tree fndecl
= OVL_CURRENT (fn
);
2039 if (TREE_CODE (fndecl
) != FUNCTION_DECL
2040 || !TREE_THIS_VOLATILE (fndecl
))
2046 current_function_returns_abnormally
= 1;
2050 orig_args
= make_tree_vector_copy (*args
);
2051 if (!BASELINK_P (fn
)
2052 && TREE_CODE (fn
) != PSEUDO_DTOR_EXPR
2053 && TREE_TYPE (fn
) != unknown_type_node
)
2054 fn
= build_non_dependent_expr (fn
);
2055 make_args_non_dependent (*args
);
2058 if (is_overloaded_fn (fn
))
2059 fn
= baselink_for_fns (fn
);
2062 if (BASELINK_P (fn
))
2066 /* A call to a member function. From [over.call.func]:
2068 If the keyword this is in scope and refers to the class of
2069 that member function, or a derived class thereof, then the
2070 function call is transformed into a qualified function call
2071 using (*this) as the postfix-expression to the left of the
2072 . operator.... [Otherwise] a contrived object of type T
2073 becomes the implied object argument.
2077 struct A { void f(); };
2078 struct B : public A {};
2079 struct C : public A { void g() { B::f(); }};
2081 "the class of that member function" refers to `A'. But 11.2
2082 [class.access.base] says that we need to convert 'this' to B* as
2083 part of the access, so we pass 'B' to maybe_dummy_object. */
2085 object
= maybe_dummy_object (BINFO_TYPE (BASELINK_ACCESS_BINFO (fn
)),
2088 if (processing_template_decl
)
2090 if (type_dependent_expression_p (object
))
2092 tree ret
= build_nt_call_vec (orig_fn
, orig_args
);
2093 release_tree_vector (orig_args
);
2096 object
= build_non_dependent_expr (object
);
2099 result
= build_new_method_call (object
, fn
, args
, NULL_TREE
,
2101 ? LOOKUP_NONVIRTUAL
: 0),
2105 else if (is_overloaded_fn (fn
))
2107 /* If the function is an overloaded builtin, resolve it. */
2108 if (TREE_CODE (fn
) == FUNCTION_DECL
2109 && (DECL_BUILT_IN_CLASS (fn
) == BUILT_IN_NORMAL
2110 || DECL_BUILT_IN_CLASS (fn
) == BUILT_IN_MD
))
2111 result
= resolve_overloaded_builtin (input_location
, fn
, *args
);
2114 /* A call to a namespace-scope function. */
2115 result
= build_new_function_call (fn
, args
, koenig_p
, complain
);
2117 else if (TREE_CODE (fn
) == PSEUDO_DTOR_EXPR
)
2119 if (!VEC_empty (tree
, *args
))
2120 error ("arguments to destructor are not allowed");
2121 /* Mark the pseudo-destructor call as having side-effects so
2122 that we do not issue warnings about its use. */
2123 result
= build1 (NOP_EXPR
,
2125 TREE_OPERAND (fn
, 0));
2126 TREE_SIDE_EFFECTS (result
) = 1;
2128 else if (CLASS_TYPE_P (TREE_TYPE (fn
)))
2129 /* If the "function" is really an object of class type, it might
2130 have an overloaded `operator ()'. */
2131 result
= build_op_call (fn
, args
, complain
);
2134 /* A call where the function is unknown. */
2135 result
= cp_build_function_call_vec (fn
, args
, complain
);
2137 if (processing_template_decl
)
2139 result
= build_call_vec (TREE_TYPE (result
), orig_fn
, orig_args
);
2140 KOENIG_LOOKUP_P (result
) = koenig_p
;
2141 release_tree_vector (orig_args
);
2147 /* Finish a call to a postfix increment or decrement or EXPR. (Which
2148 is indicated by CODE, which should be POSTINCREMENT_EXPR or
2149 POSTDECREMENT_EXPR.) */
2152 finish_increment_expr (tree expr
, enum tree_code code
)
2154 return build_x_unary_op (code
, expr
, tf_warning_or_error
);
2157 /* Finish a use of `this'. Returns an expression for `this'. */
2160 finish_this_expr (void)
2164 if (current_class_ptr
)
2166 tree type
= TREE_TYPE (current_class_ref
);
2168 /* In a lambda expression, 'this' refers to the captured 'this'. */
2169 if (LAMBDA_TYPE_P (type
))
2170 result
= lambda_expr_this_capture (CLASSTYPE_LAMBDA_EXPR (type
));
2172 result
= current_class_ptr
;
2175 else if (current_function_decl
2176 && DECL_STATIC_FUNCTION_P (current_function_decl
))
2178 error ("%<this%> is unavailable for static member functions");
2179 result
= error_mark_node
;
2183 if (current_function_decl
)
2184 error ("invalid use of %<this%> in non-member function");
2186 error ("invalid use of %<this%> at top level");
2187 result
= error_mark_node
;
2193 /* Finish a pseudo-destructor expression. If SCOPE is NULL, the
2194 expression was of the form `OBJECT.~DESTRUCTOR' where DESTRUCTOR is
2195 the TYPE for the type given. If SCOPE is non-NULL, the expression
2196 was of the form `OBJECT.SCOPE::~DESTRUCTOR'. */
2199 finish_pseudo_destructor_expr (tree object
, tree scope
, tree destructor
)
2201 if (object
== error_mark_node
|| destructor
== error_mark_node
)
2202 return error_mark_node
;
2204 gcc_assert (TYPE_P (destructor
));
2206 if (!processing_template_decl
)
2208 if (scope
== error_mark_node
)
2210 error ("invalid qualifying scope in pseudo-destructor name");
2211 return error_mark_node
;
2213 if (scope
&& TYPE_P (scope
) && !check_dtor_name (scope
, destructor
))
2215 error ("qualified type %qT does not match destructor name ~%qT",
2217 return error_mark_node
;
2221 /* [expr.pseudo] says both:
2223 The type designated by the pseudo-destructor-name shall be
2224 the same as the object type.
2228 The cv-unqualified versions of the object type and of the
2229 type designated by the pseudo-destructor-name shall be the
2232 We implement the more generous second sentence, since that is
2233 what most other compilers do. */
2234 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (object
),
2237 error ("%qE is not of type %qT", object
, destructor
);
2238 return error_mark_node
;
2242 return build3 (PSEUDO_DTOR_EXPR
, void_type_node
, object
, scope
, destructor
);
2245 /* Finish an expression of the form CODE EXPR. */
2248 finish_unary_op_expr (enum tree_code code
, tree expr
)
2250 tree result
= build_x_unary_op (code
, expr
, tf_warning_or_error
);
2251 /* Inside a template, build_x_unary_op does not fold the
2252 expression. So check whether the result is folded before
2253 setting TREE_NEGATED_INT. */
2254 if (code
== NEGATE_EXPR
&& TREE_CODE (expr
) == INTEGER_CST
2255 && TREE_CODE (result
) == INTEGER_CST
2256 && !TYPE_UNSIGNED (TREE_TYPE (result
))
2257 && INT_CST_LT (result
, integer_zero_node
))
2259 /* RESULT may be a cached INTEGER_CST, so we must copy it before
2260 setting TREE_NEGATED_INT. */
2261 result
= copy_node (result
);
2262 TREE_NEGATED_INT (result
) = 1;
2264 if (TREE_OVERFLOW_P (result
) && !TREE_OVERFLOW_P (expr
))
2265 overflow_warning (input_location
, result
);
2270 /* Finish a compound-literal expression. TYPE is the type to which
2271 the CONSTRUCTOR in COMPOUND_LITERAL is being cast. */
2274 finish_compound_literal (tree type
, tree compound_literal
)
2276 if (type
== error_mark_node
)
2277 return error_mark_node
;
2279 if (!TYPE_OBJ_P (type
))
2281 error ("compound literal of non-object type %qT", type
);
2282 return error_mark_node
;
2285 if (processing_template_decl
)
2287 TREE_TYPE (compound_literal
) = type
;
2288 /* Mark the expression as a compound literal. */
2289 TREE_HAS_CONSTRUCTOR (compound_literal
) = 1;
2290 return compound_literal
;
2293 type
= complete_type (type
);
2295 if (TYPE_NON_AGGREGATE_CLASS (type
))
2297 /* Trying to deal with a CONSTRUCTOR instead of a TREE_LIST
2298 everywhere that deals with function arguments would be a pain, so
2299 just wrap it in a TREE_LIST. The parser set a flag so we know
2300 that it came from T{} rather than T({}). */
2301 CONSTRUCTOR_IS_DIRECT_INIT (compound_literal
) = 1;
2302 compound_literal
= build_tree_list (NULL_TREE
, compound_literal
);
2303 return build_functional_cast (type
, compound_literal
, tf_error
);
2306 if (TREE_CODE (type
) == ARRAY_TYPE
2307 && check_array_initializer (NULL_TREE
, type
, compound_literal
))
2308 return error_mark_node
;
2309 compound_literal
= reshape_init (type
, compound_literal
);
2310 if (TREE_CODE (type
) == ARRAY_TYPE
)
2311 cp_complete_array_type (&type
, compound_literal
, false);
2312 compound_literal
= digest_init (type
, compound_literal
);
2313 return get_target_expr (compound_literal
);
2316 /* Return the declaration for the function-name variable indicated by
2320 finish_fname (tree id
)
2324 decl
= fname_decl (input_location
, C_RID_CODE (id
), id
);
2325 if (processing_template_decl
)
2326 decl
= DECL_NAME (decl
);
2330 /* Finish a translation unit. */
2333 finish_translation_unit (void)
2335 /* In case there were missing closebraces,
2336 get us back to the global binding level. */
2338 while (current_namespace
!= global_namespace
)
2341 /* Do file scope __FUNCTION__ et al. */
2342 finish_fname_decls ();
2345 /* Finish a template type parameter, specified as AGGR IDENTIFIER.
2346 Returns the parameter. */
2349 finish_template_type_parm (tree aggr
, tree identifier
)
2351 if (aggr
!= class_type_node
)
2353 permerror (input_location
, "template type parameters must use the keyword %<class%> or %<typename%>");
2354 aggr
= class_type_node
;
2357 return build_tree_list (aggr
, identifier
);
2360 /* Finish a template template parameter, specified as AGGR IDENTIFIER.
2361 Returns the parameter. */
2364 finish_template_template_parm (tree aggr
, tree identifier
)
2366 tree decl
= build_decl (input_location
,
2367 TYPE_DECL
, identifier
, NULL_TREE
);
2368 tree tmpl
= build_lang_decl (TEMPLATE_DECL
, identifier
, NULL_TREE
);
2369 DECL_TEMPLATE_PARMS (tmpl
) = current_template_parms
;
2370 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
2371 DECL_ARTIFICIAL (decl
) = 1;
2372 end_template_decl ();
2374 gcc_assert (DECL_TEMPLATE_PARMS (tmpl
));
2376 check_default_tmpl_args (decl
, DECL_TEMPLATE_PARMS (tmpl
),
2377 /*is_primary=*/true, /*is_partial=*/false,
2380 return finish_template_type_parm (aggr
, tmpl
);
2383 /* ARGUMENT is the default-argument value for a template template
2384 parameter. If ARGUMENT is invalid, issue error messages and return
2385 the ERROR_MARK_NODE. Otherwise, ARGUMENT itself is returned. */
2388 check_template_template_default_arg (tree argument
)
2390 if (TREE_CODE (argument
) != TEMPLATE_DECL
2391 && TREE_CODE (argument
) != TEMPLATE_TEMPLATE_PARM
2392 && TREE_CODE (argument
) != UNBOUND_CLASS_TEMPLATE
)
2394 if (TREE_CODE (argument
) == TYPE_DECL
)
2395 error ("invalid use of type %qT as a default value for a template "
2396 "template-parameter", TREE_TYPE (argument
));
2398 error ("invalid default argument for a template template parameter");
2399 return error_mark_node
;
2405 /* Begin a class definition, as indicated by T. */
2408 begin_class_definition (tree t
, tree attributes
)
2410 if (error_operand_p (t
) || error_operand_p (TYPE_MAIN_DECL (t
)))
2411 return error_mark_node
;
2413 if (processing_template_parmlist
)
2415 error ("definition of %q#T inside template parameter list", t
);
2416 return error_mark_node
;
2419 /* According to the C++ ABI, decimal classes defined in ISO/IEC TR 24733
2420 are passed the same as decimal scalar types. */
2421 if (TREE_CODE (t
) == RECORD_TYPE
2422 && !processing_template_decl
)
2424 tree ns
= TYPE_CONTEXT (t
);
2425 if (ns
&& TREE_CODE (ns
) == NAMESPACE_DECL
2426 && DECL_CONTEXT (ns
) == std_node
2428 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (ns
)), "decimal"))
2430 const char *n
= TYPE_NAME_STRING (t
);
2431 if ((strcmp (n
, "decimal32") == 0)
2432 || (strcmp (n
, "decimal64") == 0)
2433 || (strcmp (n
, "decimal128") == 0))
2434 TYPE_TRANSPARENT_AGGR (t
) = 1;
2438 /* A non-implicit typename comes from code like:
2440 template <typename T> struct A {
2441 template <typename U> struct A<T>::B ...
2443 This is erroneous. */
2444 else if (TREE_CODE (t
) == TYPENAME_TYPE
)
2446 error ("invalid definition of qualified type %qT", t
);
2447 t
= error_mark_node
;
2450 if (t
== error_mark_node
|| ! MAYBE_CLASS_TYPE_P (t
))
2452 t
= make_class_type (RECORD_TYPE
);
2453 pushtag (make_anon_name (), t
, /*tag_scope=*/ts_current
);
2456 if (TYPE_BEING_DEFINED (t
))
2458 t
= make_class_type (TREE_CODE (t
));
2459 pushtag (TYPE_IDENTIFIER (t
), t
, /*tag_scope=*/ts_current
);
2461 maybe_process_partial_specialization (t
);
2463 TYPE_BEING_DEFINED (t
) = 1;
2465 cplus_decl_attributes (&t
, attributes
, (int) ATTR_FLAG_TYPE_IN_PLACE
);
2466 fixup_attribute_variants (t
);
2468 if (flag_pack_struct
)
2471 TYPE_PACKED (t
) = 1;
2472 /* Even though the type is being defined for the first time
2473 here, there might have been a forward declaration, so there
2474 might be cv-qualified variants of T. */
2475 for (v
= TYPE_NEXT_VARIANT (t
); v
; v
= TYPE_NEXT_VARIANT (v
))
2476 TYPE_PACKED (v
) = 1;
2478 /* Reset the interface data, at the earliest possible
2479 moment, as it might have been set via a class foo;
2481 if (! TYPE_ANONYMOUS_P (t
))
2483 struct c_fileinfo
*finfo
= get_fileinfo (input_filename
);
2484 CLASSTYPE_INTERFACE_ONLY (t
) = finfo
->interface_only
;
2485 SET_CLASSTYPE_INTERFACE_UNKNOWN_X
2486 (t
, finfo
->interface_unknown
);
2488 reset_specialization();
2490 /* Make a declaration for this class in its own scope. */
2491 build_self_reference ();
2496 /* Finish the member declaration given by DECL. */
2499 finish_member_declaration (tree decl
)
2501 if (decl
== error_mark_node
|| decl
== NULL_TREE
)
2504 if (decl
== void_type_node
)
2505 /* The COMPONENT was a friend, not a member, and so there's
2506 nothing for us to do. */
2509 /* We should see only one DECL at a time. */
2510 gcc_assert (DECL_CHAIN (decl
) == NULL_TREE
);
2512 /* Set up access control for DECL. */
2514 = (current_access_specifier
== access_private_node
);
2515 TREE_PROTECTED (decl
)
2516 = (current_access_specifier
== access_protected_node
);
2517 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
2519 TREE_PRIVATE (DECL_TEMPLATE_RESULT (decl
)) = TREE_PRIVATE (decl
);
2520 TREE_PROTECTED (DECL_TEMPLATE_RESULT (decl
)) = TREE_PROTECTED (decl
);
2523 /* Mark the DECL as a member of the current class. */
2524 DECL_CONTEXT (decl
) = current_class_type
;
2526 /* Check for bare parameter packs in the member variable declaration. */
2527 if (TREE_CODE (decl
) == FIELD_DECL
)
2529 if (check_for_bare_parameter_packs (TREE_TYPE (decl
)))
2530 TREE_TYPE (decl
) = error_mark_node
;
2531 if (check_for_bare_parameter_packs (DECL_ATTRIBUTES (decl
)))
2532 DECL_ATTRIBUTES (decl
) = NULL_TREE
;
2537 A C language linkage is ignored for the names of class members
2538 and the member function type of class member functions. */
2539 if (DECL_LANG_SPECIFIC (decl
) && DECL_LANGUAGE (decl
) == lang_c
)
2540 SET_DECL_LANGUAGE (decl
, lang_cplusplus
);
2542 /* Put functions on the TYPE_METHODS list and everything else on the
2543 TYPE_FIELDS list. Note that these are built up in reverse order.
2544 We reverse them (to obtain declaration order) in finish_struct. */
2545 if (TREE_CODE (decl
) == FUNCTION_DECL
2546 || DECL_FUNCTION_TEMPLATE_P (decl
))
2548 /* We also need to add this function to the
2549 CLASSTYPE_METHOD_VEC. */
2550 if (add_method (current_class_type
, decl
, NULL_TREE
))
2552 DECL_CHAIN (decl
) = TYPE_METHODS (current_class_type
);
2553 TYPE_METHODS (current_class_type
) = decl
;
2555 maybe_add_class_template_decl_list (current_class_type
, decl
,
2559 /* Enter the DECL into the scope of the class. */
2560 else if ((TREE_CODE (decl
) == USING_DECL
&& !DECL_DEPENDENT_P (decl
))
2561 || pushdecl_class_level (decl
))
2563 /* All TYPE_DECLs go at the end of TYPE_FIELDS. Ordinary fields
2564 go at the beginning. The reason is that lookup_field_1
2565 searches the list in order, and we want a field name to
2566 override a type name so that the "struct stat hack" will
2567 work. In particular:
2569 struct S { enum E { }; int E } s;
2572 is valid. In addition, the FIELD_DECLs must be maintained in
2573 declaration order so that class layout works as expected.
2574 However, we don't need that order until class layout, so we
2575 save a little time by putting FIELD_DECLs on in reverse order
2576 here, and then reversing them in finish_struct_1. (We could
2577 also keep a pointer to the correct insertion points in the
2580 if (TREE_CODE (decl
) == TYPE_DECL
)
2581 TYPE_FIELDS (current_class_type
)
2582 = chainon (TYPE_FIELDS (current_class_type
), decl
);
2585 DECL_CHAIN (decl
) = TYPE_FIELDS (current_class_type
);
2586 TYPE_FIELDS (current_class_type
) = decl
;
2589 maybe_add_class_template_decl_list (current_class_type
, decl
,
2594 note_decl_for_pch (decl
);
2597 /* DECL has been declared while we are building a PCH file. Perform
2598 actions that we might normally undertake lazily, but which can be
2599 performed now so that they do not have to be performed in
2600 translation units which include the PCH file. */
2603 note_decl_for_pch (tree decl
)
2605 gcc_assert (pch_file
);
2607 /* There's a good chance that we'll have to mangle names at some
2608 point, even if only for emission in debugging information. */
2609 if ((TREE_CODE (decl
) == VAR_DECL
2610 || TREE_CODE (decl
) == FUNCTION_DECL
)
2611 && !processing_template_decl
)
2615 /* Finish processing a complete template declaration. The PARMS are
2616 the template parameters. */
2619 finish_template_decl (tree parms
)
2622 end_template_decl ();
2624 end_specialization ();
2627 /* Finish processing a template-id (which names a type) of the form
2628 NAME < ARGS >. Return the TYPE_DECL for the type named by the
2629 template-id. If ENTERING_SCOPE is nonzero we are about to enter
2630 the scope of template-id indicated. */
2633 finish_template_type (tree name
, tree args
, int entering_scope
)
2637 decl
= lookup_template_class (name
, args
,
2638 NULL_TREE
, NULL_TREE
, entering_scope
,
2639 tf_warning_or_error
| tf_user
);
2640 if (decl
!= error_mark_node
)
2641 decl
= TYPE_STUB_DECL (decl
);
2646 /* Finish processing a BASE_CLASS with the indicated ACCESS_SPECIFIER.
2647 Return a TREE_LIST containing the ACCESS_SPECIFIER and the
2648 BASE_CLASS, or NULL_TREE if an error occurred. The
2649 ACCESS_SPECIFIER is one of
2650 access_{default,public,protected_private}_node. For a virtual base
2651 we set TREE_TYPE. */
2654 finish_base_specifier (tree base
, tree access
, bool virtual_p
)
2658 if (base
== error_mark_node
)
2660 error ("invalid base-class specification");
2663 else if (! MAYBE_CLASS_TYPE_P (base
))
2665 error ("%qT is not a class type", base
);
2670 if (cp_type_quals (base
) != 0)
2672 error ("base class %qT has cv qualifiers", base
);
2673 base
= TYPE_MAIN_VARIANT (base
);
2675 result
= build_tree_list (access
, base
);
2677 TREE_TYPE (result
) = integer_type_node
;
2683 /* If FNS is a member function, a set of member functions, or a
2684 template-id referring to one or more member functions, return a
2685 BASELINK for FNS, incorporating the current access context.
2686 Otherwise, return FNS unchanged. */
2689 baselink_for_fns (tree fns
)
2694 if (BASELINK_P (fns
)
2695 || error_operand_p (fns
))
2699 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
2700 fn
= TREE_OPERAND (fn
, 0);
2701 fn
= get_first_fn (fn
);
2702 if (!DECL_FUNCTION_MEMBER_P (fn
))
2705 cl
= currently_open_derived_class (DECL_CONTEXT (fn
));
2707 cl
= DECL_CONTEXT (fn
);
2708 cl
= TYPE_BINFO (cl
);
2709 return build_baselink (cl
, cl
, fns
, /*optype=*/NULL_TREE
);
2712 /* Returns true iff DECL is an automatic variable from a function outside
2716 outer_automatic_var_p (tree decl
)
2718 return ((TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == PARM_DECL
)
2719 && DECL_FUNCTION_SCOPE_P (decl
)
2720 && !TREE_STATIC (decl
)
2721 && DECL_CONTEXT (decl
) != current_function_decl
);
2724 /* Returns true iff DECL is a capture field from a lambda that is not our
2725 immediate context. */
2728 outer_lambda_capture_p (tree decl
)
2730 return (TREE_CODE (decl
) == FIELD_DECL
2731 && LAMBDA_TYPE_P (DECL_CONTEXT (decl
))
2732 && (!current_class_type
2733 || !DERIVED_FROM_P (DECL_CONTEXT (decl
), current_class_type
)));
2736 /* ID_EXPRESSION is a representation of parsed, but unprocessed,
2737 id-expression. (See cp_parser_id_expression for details.) SCOPE,
2738 if non-NULL, is the type or namespace used to explicitly qualify
2739 ID_EXPRESSION. DECL is the entity to which that name has been
2742 *CONSTANT_EXPRESSION_P is true if we are presently parsing a
2743 constant-expression. In that case, *NON_CONSTANT_EXPRESSION_P will
2744 be set to true if this expression isn't permitted in a
2745 constant-expression, but it is otherwise not set by this function.
2746 *ALLOW_NON_CONSTANT_EXPRESSION_P is true if we are parsing a
2747 constant-expression, but a non-constant expression is also
2750 DONE is true if this expression is a complete postfix-expression;
2751 it is false if this expression is followed by '->', '[', '(', etc.
2752 ADDRESS_P is true iff this expression is the operand of '&'.
2753 TEMPLATE_P is true iff the qualified-id was of the form
2754 "A::template B". TEMPLATE_ARG_P is true iff this qualified name
2755 appears as a template argument.
2757 If an error occurs, and it is the kind of error that might cause
2758 the parser to abort a tentative parse, *ERROR_MSG is filled in. It
2759 is the caller's responsibility to issue the message. *ERROR_MSG
2760 will be a string with static storage duration, so the caller need
2763 Return an expression for the entity, after issuing appropriate
2764 diagnostics. This function is also responsible for transforming a
2765 reference to a non-static member into a COMPONENT_REF that makes
2766 the use of "this" explicit.
2768 Upon return, *IDK will be filled in appropriately. */
2770 finish_id_expression (tree id_expression
,
2774 bool integral_constant_expression_p
,
2775 bool allow_non_integral_constant_expression_p
,
2776 bool *non_integral_constant_expression_p
,
2780 bool template_arg_p
,
2781 const char **error_msg
,
2782 location_t location
)
2784 /* Initialize the output parameters. */
2785 *idk
= CP_ID_KIND_NONE
;
2788 if (id_expression
== error_mark_node
)
2789 return error_mark_node
;
2790 /* If we have a template-id, then no further lookup is
2791 required. If the template-id was for a template-class, we
2792 will sometimes have a TYPE_DECL at this point. */
2793 else if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
2794 || TREE_CODE (decl
) == TYPE_DECL
)
2796 /* Look up the name. */
2799 if (decl
== error_mark_node
)
2801 /* Name lookup failed. */
2804 || (!dependent_type_p (scope
)
2805 && !(TREE_CODE (id_expression
) == IDENTIFIER_NODE
2806 && IDENTIFIER_TYPENAME_P (id_expression
)
2807 && dependent_type_p (TREE_TYPE (id_expression
))))))
2809 /* If the qualifying type is non-dependent (and the name
2810 does not name a conversion operator to a dependent
2811 type), issue an error. */
2812 qualified_name_lookup_error (scope
, id_expression
, decl
, location
);
2813 return error_mark_node
;
2817 /* It may be resolved via Koenig lookup. */
2818 *idk
= CP_ID_KIND_UNQUALIFIED
;
2819 return id_expression
;
2822 decl
= id_expression
;
2824 /* If DECL is a variable that would be out of scope under
2825 ANSI/ISO rules, but in scope in the ARM, name lookup
2826 will succeed. Issue a diagnostic here. */
2828 decl
= check_for_out_of_scope_variable (decl
);
2830 /* Remember that the name was used in the definition of
2831 the current class so that we can check later to see if
2832 the meaning would have been different after the class
2833 was entirely defined. */
2834 if (!scope
&& decl
!= error_mark_node
2835 && TREE_CODE (id_expression
) == IDENTIFIER_NODE
)
2836 maybe_note_name_used_in_class (id_expression
, decl
);
2838 /* Disallow uses of local variables from containing functions, except
2839 within lambda-expressions. */
2840 if ((outer_automatic_var_p (decl
)
2841 || outer_lambda_capture_p (decl
))
2842 /* It's not a use (3.2) if we're in an unevaluated context. */
2843 && !cp_unevaluated_operand
)
2845 tree context
= DECL_CONTEXT (decl
);
2846 tree containing_function
= current_function_decl
;
2847 tree lambda_stack
= NULL_TREE
;
2848 tree lambda_expr
= NULL_TREE
;
2849 tree initializer
= decl
;
2851 /* Core issue 696: "[At the July 2009 meeting] the CWG expressed
2852 support for an approach in which a reference to a local
2853 [constant] automatic variable in a nested class or lambda body
2854 would enter the expression as an rvalue, which would reduce
2855 the complexity of the problem"
2857 FIXME update for final resolution of core issue 696. */
2858 if (decl_constant_var_p (decl
))
2859 return integral_constant_value (decl
);
2861 if (TYPE_P (context
))
2863 /* Implicit capture of an explicit capture. */
2864 context
= lambda_function (context
);
2865 initializer
= thisify_lambda_field (decl
);
2868 /* If we are in a lambda function, we can move out until we hit
2870 2. a non-lambda function, or
2871 3. a non-default capturing lambda function. */
2872 while (context
!= containing_function
2873 && LAMBDA_FUNCTION_P (containing_function
))
2875 lambda_expr
= CLASSTYPE_LAMBDA_EXPR
2876 (DECL_CONTEXT (containing_function
));
2878 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr
)
2882 lambda_stack
= tree_cons (NULL_TREE
,
2887 = decl_function_context (containing_function
);
2890 if (context
== containing_function
)
2892 decl
= add_default_capture (lambda_stack
,
2893 /*id=*/DECL_NAME (decl
),
2896 else if (lambda_expr
)
2898 error ("%qD is not captured", decl
);
2899 return error_mark_node
;
2903 error (TREE_CODE (decl
) == VAR_DECL
2904 ? "use of %<auto%> variable from containing function"
2905 : "use of parameter from containing function");
2906 error (" %q+#D declared here", decl
);
2907 return error_mark_node
;
2911 /* Also disallow uses of function parameters outside the function
2912 body, except inside an unevaluated context (i.e. decltype). */
2913 if (TREE_CODE (decl
) == PARM_DECL
2914 && DECL_CONTEXT (decl
) == NULL_TREE
2915 && !cp_unevaluated_operand
)
2917 error ("use of parameter %qD outside function body", decl
);
2918 return error_mark_node
;
2922 /* If we didn't find anything, or what we found was a type,
2923 then this wasn't really an id-expression. */
2924 if (TREE_CODE (decl
) == TEMPLATE_DECL
2925 && !DECL_FUNCTION_TEMPLATE_P (decl
))
2927 *error_msg
= "missing template arguments";
2928 return error_mark_node
;
2930 else if (TREE_CODE (decl
) == TYPE_DECL
2931 || TREE_CODE (decl
) == NAMESPACE_DECL
)
2933 *error_msg
= "expected primary-expression";
2934 return error_mark_node
;
2937 /* If the name resolved to a template parameter, there is no
2938 need to look it up again later. */
2939 if ((TREE_CODE (decl
) == CONST_DECL
&& DECL_TEMPLATE_PARM_P (decl
))
2940 || TREE_CODE (decl
) == TEMPLATE_PARM_INDEX
)
2944 *idk
= CP_ID_KIND_NONE
;
2945 if (TREE_CODE (decl
) == TEMPLATE_PARM_INDEX
)
2946 decl
= TEMPLATE_PARM_DECL (decl
);
2947 r
= convert_from_reference (DECL_INITIAL (decl
));
2949 if (integral_constant_expression_p
2950 && !dependent_type_p (TREE_TYPE (decl
))
2951 && !(INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (r
))))
2953 if (!allow_non_integral_constant_expression_p
)
2954 error ("template parameter %qD of type %qT is not allowed in "
2955 "an integral constant expression because it is not of "
2956 "integral or enumeration type", decl
, TREE_TYPE (decl
));
2957 *non_integral_constant_expression_p
= true;
2961 /* Similarly, we resolve enumeration constants to their
2962 underlying values. */
2963 else if (TREE_CODE (decl
) == CONST_DECL
)
2965 *idk
= CP_ID_KIND_NONE
;
2966 if (!processing_template_decl
)
2968 used_types_insert (TREE_TYPE (decl
));
2969 return DECL_INITIAL (decl
);
2977 /* If the declaration was explicitly qualified indicate
2978 that. The semantics of `A::f(3)' are different than
2979 `f(3)' if `f' is virtual. */
2981 ? CP_ID_KIND_QUALIFIED
2982 : (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
2983 ? CP_ID_KIND_TEMPLATE_ID
2984 : CP_ID_KIND_UNQUALIFIED
));
2989 An id-expression is type-dependent if it contains an
2990 identifier that was declared with a dependent type.
2992 The standard is not very specific about an id-expression that
2993 names a set of overloaded functions. What if some of them
2994 have dependent types and some of them do not? Presumably,
2995 such a name should be treated as a dependent name. */
2996 /* Assume the name is not dependent. */
2997 dependent_p
= false;
2998 if (!processing_template_decl
)
2999 /* No names are dependent outside a template. */
3001 /* A template-id where the name of the template was not resolved
3002 is definitely dependent. */
3003 else if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
3004 && (TREE_CODE (TREE_OPERAND (decl
, 0))
3005 == IDENTIFIER_NODE
))
3007 /* For anything except an overloaded function, just check its
3009 else if (!is_overloaded_fn (decl
))
3011 = dependent_type_p (TREE_TYPE (decl
));
3012 /* For a set of overloaded functions, check each of the
3018 if (BASELINK_P (fns
))
3019 fns
= BASELINK_FUNCTIONS (fns
);
3021 /* For a template-id, check to see if the template
3022 arguments are dependent. */
3023 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
3025 tree args
= TREE_OPERAND (fns
, 1);
3026 dependent_p
= any_dependent_template_arguments_p (args
);
3027 /* The functions are those referred to by the
3029 fns
= TREE_OPERAND (fns
, 0);
3032 /* If there are no dependent template arguments, go through
3033 the overloaded functions. */
3034 while (fns
&& !dependent_p
)
3036 tree fn
= OVL_CURRENT (fns
);
3038 /* Member functions of dependent classes are
3040 if (TREE_CODE (fn
) == FUNCTION_DECL
3041 && type_dependent_expression_p (fn
))
3043 else if (TREE_CODE (fn
) == TEMPLATE_DECL
3044 && dependent_template_p (fn
))
3047 fns
= OVL_NEXT (fns
);
3051 /* If the name was dependent on a template parameter, we will
3052 resolve the name at instantiation time. */
3055 /* Create a SCOPE_REF for qualified names, if the scope is
3061 if (address_p
&& done
)
3062 decl
= finish_qualified_id_expr (scope
, decl
,
3068 tree type
= NULL_TREE
;
3069 if (DECL_P (decl
) && !dependent_scope_p (scope
))
3070 type
= TREE_TYPE (decl
);
3071 decl
= build_qualified_name (type
,
3077 if (TREE_TYPE (decl
))
3078 decl
= convert_from_reference (decl
);
3081 /* A TEMPLATE_ID already contains all the information we
3083 if (TREE_CODE (id_expression
) == TEMPLATE_ID_EXPR
)
3084 return id_expression
;
3085 *idk
= CP_ID_KIND_UNQUALIFIED_DEPENDENT
;
3086 /* If we found a variable, then name lookup during the
3087 instantiation will always resolve to the same VAR_DECL
3088 (or an instantiation thereof). */
3089 if (TREE_CODE (decl
) == VAR_DECL
3090 || TREE_CODE (decl
) == PARM_DECL
)
3091 return convert_from_reference (decl
);
3092 /* The same is true for FIELD_DECL, but we also need to
3093 make sure that the syntax is correct. */
3094 else if (TREE_CODE (decl
) == FIELD_DECL
)
3096 /* Since SCOPE is NULL here, this is an unqualified name.
3097 Access checking has been performed during name lookup
3098 already. Turn off checking to avoid duplicate errors. */
3099 push_deferring_access_checks (dk_no_check
);
3100 decl
= finish_non_static_data_member
3102 /*qualifying_scope=*/NULL_TREE
);
3103 pop_deferring_access_checks ();
3106 return id_expression
;
3109 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
3111 error ("use of namespace %qD as expression", decl
);
3112 return error_mark_node
;
3114 else if (DECL_CLASS_TEMPLATE_P (decl
))
3116 error ("use of class template %qT as expression", decl
);
3117 return error_mark_node
;
3119 else if (TREE_CODE (decl
) == TREE_LIST
)
3121 /* Ambiguous reference to base members. */
3122 error ("request for member %qD is ambiguous in "
3123 "multiple inheritance lattice", id_expression
);
3124 print_candidates (decl
);
3125 return error_mark_node
;
3128 /* Mark variable-like entities as used. Functions are similarly
3129 marked either below or after overload resolution. */
3130 if (TREE_CODE (decl
) == VAR_DECL
3131 || TREE_CODE (decl
) == PARM_DECL
3132 || TREE_CODE (decl
) == RESULT_DECL
)
3135 /* Only certain kinds of names are allowed in constant
3136 expression. Enumerators and template parameters have already
3137 been handled above. */
3138 if (integral_constant_expression_p
3139 && ! decl_constant_var_p (decl
)
3140 && ! builtin_valid_in_constant_expr_p (decl
))
3142 if (!allow_non_integral_constant_expression_p
)
3144 error ("%qD cannot appear in a constant-expression", decl
);
3145 return error_mark_node
;
3147 *non_integral_constant_expression_p
= true;
3152 decl
= (adjust_result_of_qualified_name_lookup
3153 (decl
, scope
, current_class_type
));
3155 if (TREE_CODE (decl
) == FUNCTION_DECL
)
3158 if (TREE_CODE (decl
) == FIELD_DECL
|| BASELINK_P (decl
))
3159 decl
= finish_qualified_id_expr (scope
,
3167 tree r
= convert_from_reference (decl
);
3169 /* In a template, return a SCOPE_REF for most qualified-ids
3170 so that we can check access at instantiation time. But if
3171 we're looking at a member of the current instantiation, we
3172 know we have access and building up the SCOPE_REF confuses
3173 non-type template argument handling. */
3174 if (processing_template_decl
&& TYPE_P (scope
)
3175 && !currently_open_class (scope
))
3176 r
= build_qualified_name (TREE_TYPE (r
),
3182 else if (TREE_CODE (decl
) == FIELD_DECL
)
3184 /* Since SCOPE is NULL here, this is an unqualified name.
3185 Access checking has been performed during name lookup
3186 already. Turn off checking to avoid duplicate errors. */
3187 push_deferring_access_checks (dk_no_check
);
3188 decl
= finish_non_static_data_member (decl
, NULL_TREE
,
3189 /*qualifying_scope=*/NULL_TREE
);
3190 pop_deferring_access_checks ();
3192 else if (is_overloaded_fn (decl
))
3196 first_fn
= get_first_fn (decl
);
3197 if (TREE_CODE (first_fn
) == TEMPLATE_DECL
)
3198 first_fn
= DECL_TEMPLATE_RESULT (first_fn
);
3200 if (!really_overloaded_fn (decl
))
3201 mark_used (first_fn
);
3204 && TREE_CODE (first_fn
) == FUNCTION_DECL
3205 && DECL_FUNCTION_MEMBER_P (first_fn
)
3206 && !shared_member_p (decl
))
3208 /* A set of member functions. */
3209 decl
= maybe_dummy_object (DECL_CONTEXT (first_fn
), 0);
3210 return finish_class_member_access_expr (decl
, id_expression
,
3211 /*template_p=*/false,
3212 tf_warning_or_error
);
3215 decl
= baselink_for_fns (decl
);
3219 if (DECL_P (decl
) && DECL_NONLOCAL (decl
)
3220 && DECL_CLASS_SCOPE_P (decl
))
3222 tree context
= context_for_name_lookup (decl
);
3223 if (context
!= current_class_type
)
3225 tree path
= currently_open_derived_class (context
);
3226 perform_or_defer_access_check (TYPE_BINFO (path
),
3231 decl
= convert_from_reference (decl
);
3235 if (TREE_DEPRECATED (decl
))
3236 warn_deprecated_use (decl
, NULL_TREE
);
3241 /* Implement the __typeof keyword: Return the type of EXPR, suitable for
3242 use as a type-specifier. */
3245 finish_typeof (tree expr
)
3249 if (type_dependent_expression_p (expr
))
3251 type
= cxx_make_type (TYPEOF_TYPE
);
3252 TYPEOF_TYPE_EXPR (type
) = expr
;
3253 SET_TYPE_STRUCTURAL_EQUALITY (type
);
3258 expr
= mark_type_use (expr
);
3260 type
= unlowered_expr_type (expr
);
3262 if (!type
|| type
== unknown_type_node
)
3264 error ("type of %qE is unknown", expr
);
3265 return error_mark_node
;
3271 /* Perform C++-specific checks for __builtin_offsetof before calling
3275 finish_offsetof (tree expr
)
3277 if (TREE_CODE (expr
) == PSEUDO_DTOR_EXPR
)
3279 error ("cannot apply %<offsetof%> to destructor %<~%T%>",
3280 TREE_OPERAND (expr
, 2));
3281 return error_mark_node
;
3283 if (TREE_CODE (TREE_TYPE (expr
)) == FUNCTION_TYPE
3284 || TREE_CODE (TREE_TYPE (expr
)) == METHOD_TYPE
3285 || TREE_TYPE (expr
) == unknown_type_node
)
3287 if (TREE_CODE (expr
) == COMPONENT_REF
3288 || TREE_CODE (expr
) == COMPOUND_EXPR
)
3289 expr
= TREE_OPERAND (expr
, 1);
3290 error ("cannot apply %<offsetof%> to member function %qD", expr
);
3291 return error_mark_node
;
3293 if (TREE_CODE (expr
) == INDIRECT_REF
&& REFERENCE_REF_P (expr
))
3294 expr
= TREE_OPERAND (expr
, 0);
3295 return fold_offsetof (expr
, NULL_TREE
);
3298 /* Replace the AGGR_INIT_EXPR at *TP with an equivalent CALL_EXPR. This
3299 function is broken out from the above for the benefit of the tree-ssa
3303 simplify_aggr_init_expr (tree
*tp
)
3305 tree aggr_init_expr
= *tp
;
3307 /* Form an appropriate CALL_EXPR. */
3308 tree fn
= AGGR_INIT_EXPR_FN (aggr_init_expr
);
3309 tree slot
= AGGR_INIT_EXPR_SLOT (aggr_init_expr
);
3310 tree type
= TREE_TYPE (slot
);
3313 enum style_t
{ ctor
, arg
, pcc
} style
;
3315 if (AGGR_INIT_VIA_CTOR_P (aggr_init_expr
))
3317 #ifdef PCC_STATIC_STRUCT_RETURN
3323 gcc_assert (TREE_ADDRESSABLE (type
));
3327 call_expr
= build_call_array_loc (input_location
,
3328 TREE_TYPE (TREE_TYPE (TREE_TYPE (fn
))),
3330 aggr_init_expr_nargs (aggr_init_expr
),
3331 AGGR_INIT_EXPR_ARGP (aggr_init_expr
));
3332 TREE_NOTHROW (call_expr
) = TREE_NOTHROW (aggr_init_expr
);
3336 /* Replace the first argument to the ctor with the address of the
3338 cxx_mark_addressable (slot
);
3339 CALL_EXPR_ARG (call_expr
, 0) =
3340 build1 (ADDR_EXPR
, build_pointer_type (type
), slot
);
3342 else if (style
== arg
)
3344 /* Just mark it addressable here, and leave the rest to
3345 expand_call{,_inline}. */
3346 cxx_mark_addressable (slot
);
3347 CALL_EXPR_RETURN_SLOT_OPT (call_expr
) = true;
3348 call_expr
= build2 (INIT_EXPR
, TREE_TYPE (call_expr
), slot
, call_expr
);
3350 else if (style
== pcc
)
3352 /* If we're using the non-reentrant PCC calling convention, then we
3353 need to copy the returned value out of the static buffer into the
3355 push_deferring_access_checks (dk_no_check
);
3356 call_expr
= build_aggr_init (slot
, call_expr
,
3357 DIRECT_BIND
| LOOKUP_ONLYCONVERTING
,
3358 tf_warning_or_error
);
3359 pop_deferring_access_checks ();
3360 call_expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (slot
), call_expr
, slot
);
3363 if (AGGR_INIT_ZERO_FIRST (aggr_init_expr
))
3365 tree init
= build_zero_init (type
, NULL_TREE
,
3366 /*static_storage_p=*/false);
3367 init
= build2 (INIT_EXPR
, void_type_node
, slot
, init
);
3368 call_expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (call_expr
),
3375 /* Emit all thunks to FN that should be emitted when FN is emitted. */
3378 emit_associated_thunks (tree fn
)
3380 /* When we use vcall offsets, we emit thunks with the virtual
3381 functions to which they thunk. The whole point of vcall offsets
3382 is so that you can know statically the entire set of thunks that
3383 will ever be needed for a given virtual function, thereby
3384 enabling you to output all the thunks with the function itself. */
3385 if (DECL_VIRTUAL_P (fn
)
3386 /* Do not emit thunks for extern template instantiations. */
3387 && ! DECL_REALLY_EXTERN (fn
))
3391 for (thunk
= DECL_THUNKS (fn
); thunk
; thunk
= DECL_CHAIN (thunk
))
3393 if (!THUNK_ALIAS (thunk
))
3395 use_thunk (thunk
, /*emit_p=*/1);
3396 if (DECL_RESULT_THUNK_P (thunk
))
3400 for (probe
= DECL_THUNKS (thunk
);
3401 probe
; probe
= DECL_CHAIN (probe
))
3402 use_thunk (probe
, /*emit_p=*/1);
3406 gcc_assert (!DECL_THUNKS (thunk
));
3411 /* Generate RTL for FN. */
3414 expand_or_defer_fn_1 (tree fn
)
3416 /* When the parser calls us after finishing the body of a template
3417 function, we don't really want to expand the body. */
3418 if (processing_template_decl
)
3420 /* Normally, collection only occurs in rest_of_compilation. So,
3421 if we don't collect here, we never collect junk generated
3422 during the processing of templates until we hit a
3423 non-template function. It's not safe to do this inside a
3424 nested class, though, as the parser may have local state that
3425 is not a GC root. */
3426 if (!function_depth
)
3431 gcc_assert (DECL_SAVED_TREE (fn
));
3433 /* If this is a constructor or destructor body, we have to clone
3435 if (maybe_clone_body (fn
))
3437 /* We don't want to process FN again, so pretend we've written
3438 it out, even though we haven't. */
3439 TREE_ASM_WRITTEN (fn
) = 1;
3440 DECL_SAVED_TREE (fn
) = NULL_TREE
;
3444 /* We make a decision about linkage for these functions at the end
3445 of the compilation. Until that point, we do not want the back
3446 end to output them -- but we do want it to see the bodies of
3447 these functions so that it can inline them as appropriate. */
3448 if (DECL_DECLARED_INLINE_P (fn
) || DECL_IMPLICIT_INSTANTIATION (fn
))
3450 if (DECL_INTERFACE_KNOWN (fn
))
3451 /* We've already made a decision as to how this function will
3455 DECL_EXTERNAL (fn
) = 1;
3456 DECL_NOT_REALLY_EXTERN (fn
) = 1;
3457 note_vague_linkage_fn (fn
);
3458 /* A non-template inline function with external linkage will
3459 always be COMDAT. As we must eventually determine the
3460 linkage of all functions, and as that causes writes to
3461 the data mapped in from the PCH file, it's advantageous
3462 to mark the functions at this point. */
3463 if (!DECL_IMPLICIT_INSTANTIATION (fn
))
3465 /* This function must have external linkage, as
3466 otherwise DECL_INTERFACE_KNOWN would have been
3468 gcc_assert (TREE_PUBLIC (fn
));
3469 comdat_linkage (fn
);
3470 DECL_INTERFACE_KNOWN (fn
) = 1;
3474 import_export_decl (fn
);
3476 /* If the user wants us to keep all inline functions, then mark
3477 this function as needed so that finish_file will make sure to
3478 output it later. Similarly, all dllexport'd functions must
3479 be emitted; there may be callers in other DLLs. */
3480 if ((flag_keep_inline_functions
3481 && DECL_DECLARED_INLINE_P (fn
)
3482 && !DECL_REALLY_EXTERN (fn
))
3483 || lookup_attribute ("dllexport", DECL_ATTRIBUTES (fn
)))
3487 /* There's no reason to do any of the work here if we're only doing
3488 semantic analysis; this code just generates RTL. */
3489 if (flag_syntax_only
)
3496 expand_or_defer_fn (tree fn
)
3498 if (expand_or_defer_fn_1 (fn
))
3502 /* Expand or defer, at the whim of the compilation unit manager. */
3503 cgraph_finalize_function (fn
, function_depth
> 1);
3504 emit_associated_thunks (fn
);
3517 /* Helper function for walk_tree, used by finalize_nrv below. */
3520 finalize_nrv_r (tree
* tp
, int* walk_subtrees
, void* data
)
3522 struct nrv_data
*dp
= (struct nrv_data
*)data
;
3525 /* No need to walk into types. There wouldn't be any need to walk into
3526 non-statements, except that we have to consider STMT_EXPRs. */
3529 /* Change all returns to just refer to the RESULT_DECL; this is a nop,
3530 but differs from using NULL_TREE in that it indicates that we care
3531 about the value of the RESULT_DECL. */
3532 else if (TREE_CODE (*tp
) == RETURN_EXPR
)
3533 TREE_OPERAND (*tp
, 0) = dp
->result
;
3534 /* Change all cleanups for the NRV to only run when an exception is
3536 else if (TREE_CODE (*tp
) == CLEANUP_STMT
3537 && CLEANUP_DECL (*tp
) == dp
->var
)
3538 CLEANUP_EH_ONLY (*tp
) = 1;
3539 /* Replace the DECL_EXPR for the NRV with an initialization of the
3540 RESULT_DECL, if needed. */
3541 else if (TREE_CODE (*tp
) == DECL_EXPR
3542 && DECL_EXPR_DECL (*tp
) == dp
->var
)
3545 if (DECL_INITIAL (dp
->var
)
3546 && DECL_INITIAL (dp
->var
) != error_mark_node
)
3547 init
= build2 (INIT_EXPR
, void_type_node
, dp
->result
,
3548 DECL_INITIAL (dp
->var
));
3550 init
= build_empty_stmt (EXPR_LOCATION (*tp
));
3551 DECL_INITIAL (dp
->var
) = NULL_TREE
;
3552 SET_EXPR_LOCATION (init
, EXPR_LOCATION (*tp
));
3555 /* And replace all uses of the NRV with the RESULT_DECL. */
3556 else if (*tp
== dp
->var
)
3559 /* Avoid walking into the same tree more than once. Unfortunately, we
3560 can't just use walk_tree_without duplicates because it would only call
3561 us for the first occurrence of dp->var in the function body. */
3562 slot
= htab_find_slot (dp
->visited
, *tp
, INSERT
);
3568 /* Keep iterating. */
3572 /* Called from finish_function to implement the named return value
3573 optimization by overriding all the RETURN_EXPRs and pertinent
3574 CLEANUP_STMTs and replacing all occurrences of VAR with RESULT, the
3575 RESULT_DECL for the function. */
3578 finalize_nrv (tree
*tp
, tree var
, tree result
)
3580 struct nrv_data data
;
3582 /* Copy name from VAR to RESULT. */
3583 DECL_NAME (result
) = DECL_NAME (var
);
3584 /* Don't forget that we take its address. */
3585 TREE_ADDRESSABLE (result
) = TREE_ADDRESSABLE (var
);
3586 /* Finally set DECL_VALUE_EXPR to avoid assigning
3587 a stack slot at -O0 for the original var and debug info
3588 uses RESULT location for VAR. */
3589 SET_DECL_VALUE_EXPR (var
, result
);
3590 DECL_HAS_VALUE_EXPR_P (var
) = 1;
3593 data
.result
= result
;
3594 data
.visited
= htab_create (37, htab_hash_pointer
, htab_eq_pointer
, NULL
);
3595 cp_walk_tree (tp
, finalize_nrv_r
, &data
, 0);
3596 htab_delete (data
.visited
);
3599 /* Create CP_OMP_CLAUSE_INFO for clause C. Returns true if it is invalid. */
3602 cxx_omp_create_clause_info (tree c
, tree type
, bool need_default_ctor
,
3603 bool need_copy_ctor
, bool need_copy_assignment
)
3605 int save_errorcount
= errorcount
;
3608 /* Always allocate 3 elements for simplicity. These are the
3609 function decls for the ctor, dtor, and assignment op.
3610 This layout is known to the three lang hooks,
3611 cxx_omp_clause_default_init, cxx_omp_clause_copy_init,
3612 and cxx_omp_clause_assign_op. */
3613 info
= make_tree_vec (3);
3614 CP_OMP_CLAUSE_INFO (c
) = info
;
3616 if (need_default_ctor
|| need_copy_ctor
)
3618 if (need_default_ctor
)
3619 t
= get_default_ctor (type
);
3621 t
= get_copy_ctor (type
);
3623 if (t
&& !trivial_fn_p (t
))
3624 TREE_VEC_ELT (info
, 0) = t
;
3627 if ((need_default_ctor
|| need_copy_ctor
)
3628 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
3629 TREE_VEC_ELT (info
, 1) = get_dtor (type
);
3631 if (need_copy_assignment
)
3633 t
= get_copy_assign (type
);
3635 if (t
&& !trivial_fn_p (t
))
3636 TREE_VEC_ELT (info
, 2) = t
;
3639 return errorcount
!= save_errorcount
;
3642 /* For all elements of CLAUSES, validate them vs OpenMP constraints.
3643 Remove any elements from the list that are invalid. */
3646 finish_omp_clauses (tree clauses
)
3648 bitmap_head generic_head
, firstprivate_head
, lastprivate_head
;
3649 tree c
, t
, *pc
= &clauses
;
3652 bitmap_obstack_initialize (NULL
);
3653 bitmap_initialize (&generic_head
, &bitmap_default_obstack
);
3654 bitmap_initialize (&firstprivate_head
, &bitmap_default_obstack
);
3655 bitmap_initialize (&lastprivate_head
, &bitmap_default_obstack
);
3657 for (pc
= &clauses
, c
= clauses
; c
; c
= *pc
)
3659 bool remove
= false;
3661 switch (OMP_CLAUSE_CODE (c
))
3663 case OMP_CLAUSE_SHARED
:
3665 goto check_dup_generic
;
3666 case OMP_CLAUSE_PRIVATE
:
3668 goto check_dup_generic
;
3669 case OMP_CLAUSE_REDUCTION
:
3671 goto check_dup_generic
;
3672 case OMP_CLAUSE_COPYPRIVATE
:
3673 name
= "copyprivate";
3674 goto check_dup_generic
;
3675 case OMP_CLAUSE_COPYIN
:
3677 goto check_dup_generic
;
3679 t
= OMP_CLAUSE_DECL (c
);
3680 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
3682 if (processing_template_decl
)
3685 error ("%qD is not a variable in clause %qs", t
, name
);
3687 error ("%qE is not a variable in clause %qs", t
, name
);
3690 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
3691 || bitmap_bit_p (&firstprivate_head
, DECL_UID (t
))
3692 || bitmap_bit_p (&lastprivate_head
, DECL_UID (t
)))
3694 error ("%qD appears more than once in data clauses", t
);
3698 bitmap_set_bit (&generic_head
, DECL_UID (t
));
3701 case OMP_CLAUSE_FIRSTPRIVATE
:
3702 t
= OMP_CLAUSE_DECL (c
);
3703 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
3705 if (processing_template_decl
)
3708 error ("%qD is not a variable in clause %<firstprivate%>", t
);
3710 error ("%qE is not a variable in clause %<firstprivate%>", t
);
3713 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
3714 || bitmap_bit_p (&firstprivate_head
, DECL_UID (t
)))
3716 error ("%qD appears more than once in data clauses", t
);
3720 bitmap_set_bit (&firstprivate_head
, DECL_UID (t
));
3723 case OMP_CLAUSE_LASTPRIVATE
:
3724 t
= OMP_CLAUSE_DECL (c
);
3725 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
3727 if (processing_template_decl
)
3730 error ("%qD is not a variable in clause %<lastprivate%>", t
);
3732 error ("%qE is not a variable in clause %<lastprivate%>", t
);
3735 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
3736 || bitmap_bit_p (&lastprivate_head
, DECL_UID (t
)))
3738 error ("%qD appears more than once in data clauses", t
);
3742 bitmap_set_bit (&lastprivate_head
, DECL_UID (t
));
3746 t
= OMP_CLAUSE_IF_EXPR (c
);
3747 t
= maybe_convert_cond (t
);
3748 if (t
== error_mark_node
)
3750 OMP_CLAUSE_IF_EXPR (c
) = t
;
3753 case OMP_CLAUSE_NUM_THREADS
:
3754 t
= OMP_CLAUSE_NUM_THREADS_EXPR (c
);
3755 if (t
== error_mark_node
)
3757 else if (!type_dependent_expression_p (t
)
3758 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
3760 error ("num_threads expression must be integral");
3765 case OMP_CLAUSE_SCHEDULE
:
3766 t
= OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c
);
3769 else if (t
== error_mark_node
)
3771 else if (!type_dependent_expression_p (t
)
3772 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
3774 error ("schedule chunk size expression must be integral");
3779 case OMP_CLAUSE_NOWAIT
:
3780 case OMP_CLAUSE_ORDERED
:
3781 case OMP_CLAUSE_DEFAULT
:
3782 case OMP_CLAUSE_UNTIED
:
3783 case OMP_CLAUSE_COLLAPSE
:
3791 *pc
= OMP_CLAUSE_CHAIN (c
);
3793 pc
= &OMP_CLAUSE_CHAIN (c
);
3796 for (pc
= &clauses
, c
= clauses
; c
; c
= *pc
)
3798 enum omp_clause_code c_kind
= OMP_CLAUSE_CODE (c
);
3799 bool remove
= false;
3800 bool need_complete_non_reference
= false;
3801 bool need_default_ctor
= false;
3802 bool need_copy_ctor
= false;
3803 bool need_copy_assignment
= false;
3804 bool need_implicitly_determined
= false;
3805 tree type
, inner_type
;
3809 case OMP_CLAUSE_SHARED
:
3811 need_implicitly_determined
= true;
3813 case OMP_CLAUSE_PRIVATE
:
3815 need_complete_non_reference
= true;
3816 need_default_ctor
= true;
3817 need_implicitly_determined
= true;
3819 case OMP_CLAUSE_FIRSTPRIVATE
:
3820 name
= "firstprivate";
3821 need_complete_non_reference
= true;
3822 need_copy_ctor
= true;
3823 need_implicitly_determined
= true;
3825 case OMP_CLAUSE_LASTPRIVATE
:
3826 name
= "lastprivate";
3827 need_complete_non_reference
= true;
3828 need_copy_assignment
= true;
3829 need_implicitly_determined
= true;
3831 case OMP_CLAUSE_REDUCTION
:
3833 need_implicitly_determined
= true;
3835 case OMP_CLAUSE_COPYPRIVATE
:
3836 name
= "copyprivate";
3837 need_copy_assignment
= true;
3839 case OMP_CLAUSE_COPYIN
:
3841 need_copy_assignment
= true;
3844 pc
= &OMP_CLAUSE_CHAIN (c
);
3848 t
= OMP_CLAUSE_DECL (c
);
3849 if (processing_template_decl
3850 && TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
3852 pc
= &OMP_CLAUSE_CHAIN (c
);
3858 case OMP_CLAUSE_LASTPRIVATE
:
3859 if (!bitmap_bit_p (&firstprivate_head
, DECL_UID (t
)))
3860 need_default_ctor
= true;
3863 case OMP_CLAUSE_REDUCTION
:
3864 if (AGGREGATE_TYPE_P (TREE_TYPE (t
))
3865 || POINTER_TYPE_P (TREE_TYPE (t
)))
3867 error ("%qE has invalid type for %<reduction%>", t
);
3870 else if (FLOAT_TYPE_P (TREE_TYPE (t
)))
3872 enum tree_code r_code
= OMP_CLAUSE_REDUCTION_CODE (c
);
3880 error ("%qE has invalid type for %<reduction(%s)%>",
3881 t
, operator_name_info
[r_code
].name
);
3887 case OMP_CLAUSE_COPYIN
:
3888 if (TREE_CODE (t
) != VAR_DECL
|| !DECL_THREAD_LOCAL_P (t
))
3890 error ("%qE must be %<threadprivate%> for %<copyin%>", t
);
3899 if (need_complete_non_reference
)
3901 t
= require_complete_type (t
);
3902 if (t
== error_mark_node
)
3904 else if (TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
)
3906 error ("%qE has reference type for %qs", t
, name
);
3910 if (need_implicitly_determined
)
3912 const char *share_name
= NULL
;
3914 if (TREE_CODE (t
) == VAR_DECL
&& DECL_THREAD_LOCAL_P (t
))
3915 share_name
= "threadprivate";
3916 else switch (cxx_omp_predetermined_sharing (t
))
3918 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
3920 case OMP_CLAUSE_DEFAULT_SHARED
:
3921 share_name
= "shared";
3923 case OMP_CLAUSE_DEFAULT_PRIVATE
:
3924 share_name
= "private";
3931 error ("%qE is predetermined %qs for %qs",
3932 t
, share_name
, name
);
3937 /* We're interested in the base element, not arrays. */
3938 inner_type
= type
= TREE_TYPE (t
);
3939 while (TREE_CODE (inner_type
) == ARRAY_TYPE
)
3940 inner_type
= TREE_TYPE (inner_type
);
3942 /* Check for special function availability by building a call to one.
3943 Save the results, because later we won't be in the right context
3944 for making these queries. */
3945 if (CLASS_TYPE_P (inner_type
)
3946 && (need_default_ctor
|| need_copy_ctor
|| need_copy_assignment
)
3947 && !type_dependent_expression_p (t
)
3948 && cxx_omp_create_clause_info (c
, inner_type
, need_default_ctor
,
3949 need_copy_ctor
, need_copy_assignment
))
3953 *pc
= OMP_CLAUSE_CHAIN (c
);
3955 pc
= &OMP_CLAUSE_CHAIN (c
);
3958 bitmap_obstack_release (NULL
);
3962 /* For all variables in the tree_list VARS, mark them as thread local. */
3965 finish_omp_threadprivate (tree vars
)
3969 /* Mark every variable in VARS to be assigned thread local storage. */
3970 for (t
= vars
; t
; t
= TREE_CHAIN (t
))
3972 tree v
= TREE_PURPOSE (t
);
3974 if (error_operand_p (v
))
3976 else if (TREE_CODE (v
) != VAR_DECL
)
3977 error ("%<threadprivate%> %qD is not file, namespace "
3978 "or block scope variable", v
);
3979 /* If V had already been marked threadprivate, it doesn't matter
3980 whether it had been used prior to this point. */
3981 else if (TREE_USED (v
)
3982 && (DECL_LANG_SPECIFIC (v
) == NULL
3983 || !CP_DECL_THREADPRIVATE_P (v
)))
3984 error ("%qE declared %<threadprivate%> after first use", v
);
3985 else if (! TREE_STATIC (v
) && ! DECL_EXTERNAL (v
))
3986 error ("automatic variable %qE cannot be %<threadprivate%>", v
);
3987 else if (! COMPLETE_TYPE_P (TREE_TYPE (v
)))
3988 error ("%<threadprivate%> %qE has incomplete type", v
);
3989 else if (TREE_STATIC (v
) && TYPE_P (CP_DECL_CONTEXT (v
))
3990 && CP_DECL_CONTEXT (v
) != current_class_type
)
3991 error ("%<threadprivate%> %qE directive not "
3992 "in %qT definition", v
, CP_DECL_CONTEXT (v
));
3995 /* Allocate a LANG_SPECIFIC structure for V, if needed. */
3996 if (DECL_LANG_SPECIFIC (v
) == NULL
)
3998 retrofit_lang_decl (v
);
4000 /* Make sure that DECL_DISCRIMINATOR_P continues to be true
4001 after the allocation of the lang_decl structure. */
4002 if (DECL_DISCRIMINATOR_P (v
))
4003 DECL_LANG_SPECIFIC (v
)->u
.base
.u2sel
= 1;
4006 if (! DECL_THREAD_LOCAL_P (v
))
4008 DECL_TLS_MODEL (v
) = decl_default_tls_model (v
);
4009 /* If rtl has been already set for this var, call
4010 make_decl_rtl once again, so that encode_section_info
4011 has a chance to look at the new decl flags. */
4012 if (DECL_RTL_SET_P (v
))
4015 CP_DECL_THREADPRIVATE_P (v
) = 1;
4020 /* Build an OpenMP structured block. */
4023 begin_omp_structured_block (void)
4025 return do_pushlevel (sk_omp
);
4029 finish_omp_structured_block (tree block
)
4031 return do_poplevel (block
);
4034 /* Similarly, except force the retention of the BLOCK. */
4037 begin_omp_parallel (void)
4039 keep_next_level (true);
4040 return begin_omp_structured_block ();
4044 finish_omp_parallel (tree clauses
, tree body
)
4048 body
= finish_omp_structured_block (body
);
4050 stmt
= make_node (OMP_PARALLEL
);
4051 TREE_TYPE (stmt
) = void_type_node
;
4052 OMP_PARALLEL_CLAUSES (stmt
) = clauses
;
4053 OMP_PARALLEL_BODY (stmt
) = body
;
4055 return add_stmt (stmt
);
4059 begin_omp_task (void)
4061 keep_next_level (true);
4062 return begin_omp_structured_block ();
4066 finish_omp_task (tree clauses
, tree body
)
4070 body
= finish_omp_structured_block (body
);
4072 stmt
= make_node (OMP_TASK
);
4073 TREE_TYPE (stmt
) = void_type_node
;
4074 OMP_TASK_CLAUSES (stmt
) = clauses
;
4075 OMP_TASK_BODY (stmt
) = body
;
4077 return add_stmt (stmt
);
4080 /* Helper function for finish_omp_for. Convert Ith random access iterator
4081 into integral iterator. Return FALSE if successful. */
4084 handle_omp_for_class_iterator (int i
, location_t locus
, tree declv
, tree initv
,
4085 tree condv
, tree incrv
, tree
*body
,
4086 tree
*pre_body
, tree clauses
)
4088 tree diff
, iter_init
, iter_incr
= NULL
, last
;
4089 tree incr_var
= NULL
, orig_pre_body
, orig_body
, c
;
4090 tree decl
= TREE_VEC_ELT (declv
, i
);
4091 tree init
= TREE_VEC_ELT (initv
, i
);
4092 tree cond
= TREE_VEC_ELT (condv
, i
);
4093 tree incr
= TREE_VEC_ELT (incrv
, i
);
4095 location_t elocus
= locus
;
4097 if (init
&& EXPR_HAS_LOCATION (init
))
4098 elocus
= EXPR_LOCATION (init
);
4100 switch (TREE_CODE (cond
))
4106 if (TREE_OPERAND (cond
, 1) == iter
)
4107 cond
= build2 (swap_tree_comparison (TREE_CODE (cond
)),
4108 TREE_TYPE (cond
), iter
, TREE_OPERAND (cond
, 0));
4109 if (TREE_OPERAND (cond
, 0) != iter
)
4110 cond
= error_mark_node
;
4113 tree tem
= build_x_binary_op (TREE_CODE (cond
), iter
, ERROR_MARK
,
4114 TREE_OPERAND (cond
, 1), ERROR_MARK
,
4115 NULL
, tf_warning_or_error
);
4116 if (error_operand_p (tem
))
4121 cond
= error_mark_node
;
4124 if (cond
== error_mark_node
)
4126 error_at (elocus
, "invalid controlling predicate");
4129 diff
= build_x_binary_op (MINUS_EXPR
, TREE_OPERAND (cond
, 1),
4130 ERROR_MARK
, iter
, ERROR_MARK
, NULL
,
4131 tf_warning_or_error
);
4132 if (error_operand_p (diff
))
4134 if (TREE_CODE (TREE_TYPE (diff
)) != INTEGER_TYPE
)
4136 error_at (elocus
, "difference between %qE and %qD does not have integer type",
4137 TREE_OPERAND (cond
, 1), iter
);
4141 switch (TREE_CODE (incr
))
4143 case PREINCREMENT_EXPR
:
4144 case PREDECREMENT_EXPR
:
4145 case POSTINCREMENT_EXPR
:
4146 case POSTDECREMENT_EXPR
:
4147 if (TREE_OPERAND (incr
, 0) != iter
)
4149 incr
= error_mark_node
;
4152 iter_incr
= build_x_unary_op (TREE_CODE (incr
), iter
,
4153 tf_warning_or_error
);
4154 if (error_operand_p (iter_incr
))
4156 else if (TREE_CODE (incr
) == PREINCREMENT_EXPR
4157 || TREE_CODE (incr
) == POSTINCREMENT_EXPR
)
4158 incr
= integer_one_node
;
4160 incr
= integer_minus_one_node
;
4163 if (TREE_OPERAND (incr
, 0) != iter
)
4164 incr
= error_mark_node
;
4165 else if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
4166 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
4168 tree rhs
= TREE_OPERAND (incr
, 1);
4169 if (TREE_OPERAND (rhs
, 0) == iter
)
4171 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs
, 1)))
4173 incr
= error_mark_node
;
4176 iter_incr
= build_x_modify_expr (iter
, TREE_CODE (rhs
),
4177 TREE_OPERAND (rhs
, 1),
4178 tf_warning_or_error
);
4179 if (error_operand_p (iter_incr
))
4181 incr
= TREE_OPERAND (rhs
, 1);
4182 incr
= cp_convert (TREE_TYPE (diff
), incr
);
4183 if (TREE_CODE (rhs
) == MINUS_EXPR
)
4185 incr
= build1 (NEGATE_EXPR
, TREE_TYPE (diff
), incr
);
4186 incr
= fold_if_not_in_template (incr
);
4188 if (TREE_CODE (incr
) != INTEGER_CST
4189 && (TREE_CODE (incr
) != NOP_EXPR
4190 || (TREE_CODE (TREE_OPERAND (incr
, 0))
4195 else if (TREE_OPERAND (rhs
, 1) == iter
)
4197 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs
, 0))) != INTEGER_TYPE
4198 || TREE_CODE (rhs
) != PLUS_EXPR
)
4199 incr
= error_mark_node
;
4202 iter_incr
= build_x_binary_op (PLUS_EXPR
,
4203 TREE_OPERAND (rhs
, 0),
4206 tf_warning_or_error
);
4207 if (error_operand_p (iter_incr
))
4209 iter_incr
= build_x_modify_expr (iter
, NOP_EXPR
,
4211 tf_warning_or_error
);
4212 if (error_operand_p (iter_incr
))
4214 incr
= TREE_OPERAND (rhs
, 0);
4219 incr
= error_mark_node
;
4222 incr
= error_mark_node
;
4225 incr
= error_mark_node
;
4229 if (incr
== error_mark_node
)
4231 error_at (elocus
, "invalid increment expression");
4235 incr
= cp_convert (TREE_TYPE (diff
), incr
);
4236 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
4237 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
4238 && OMP_CLAUSE_DECL (c
) == iter
)
4241 decl
= create_temporary_var (TREE_TYPE (diff
));
4243 add_decl_expr (decl
);
4244 last
= create_temporary_var (TREE_TYPE (diff
));
4246 add_decl_expr (last
);
4247 if (c
&& iter_incr
== NULL
)
4249 incr_var
= create_temporary_var (TREE_TYPE (diff
));
4250 pushdecl (incr_var
);
4251 add_decl_expr (incr_var
);
4253 gcc_assert (stmts_are_full_exprs_p ());
4255 orig_pre_body
= *pre_body
;
4256 *pre_body
= push_stmt_list ();
4258 add_stmt (orig_pre_body
);
4260 finish_expr_stmt (build_x_modify_expr (iter
, NOP_EXPR
, init
,
4261 tf_warning_or_error
));
4262 init
= build_int_cst (TREE_TYPE (diff
), 0);
4263 if (c
&& iter_incr
== NULL
)
4265 finish_expr_stmt (build_x_modify_expr (incr_var
, NOP_EXPR
,
4266 incr
, tf_warning_or_error
));
4268 iter_incr
= build_x_modify_expr (iter
, PLUS_EXPR
, incr
,
4269 tf_warning_or_error
);
4271 finish_expr_stmt (build_x_modify_expr (last
, NOP_EXPR
, init
,
4272 tf_warning_or_error
));
4273 *pre_body
= pop_stmt_list (*pre_body
);
4275 cond
= cp_build_binary_op (elocus
,
4276 TREE_CODE (cond
), decl
, diff
,
4277 tf_warning_or_error
);
4278 incr
= build_modify_expr (elocus
, decl
, NULL_TREE
, PLUS_EXPR
,
4279 elocus
, incr
, NULL_TREE
);
4282 *body
= push_stmt_list ();
4283 iter_init
= build2 (MINUS_EXPR
, TREE_TYPE (diff
), decl
, last
);
4284 iter_init
= build_x_modify_expr (iter
, PLUS_EXPR
, iter_init
,
4285 tf_warning_or_error
);
4286 iter_init
= build1 (NOP_EXPR
, void_type_node
, iter_init
);
4287 finish_expr_stmt (iter_init
);
4288 finish_expr_stmt (build_x_modify_expr (last
, NOP_EXPR
, decl
,
4289 tf_warning_or_error
));
4290 add_stmt (orig_body
);
4291 *body
= pop_stmt_list (*body
);
4295 OMP_CLAUSE_LASTPRIVATE_STMT (c
) = push_stmt_list ();
4296 finish_expr_stmt (iter_incr
);
4297 OMP_CLAUSE_LASTPRIVATE_STMT (c
)
4298 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (c
));
4301 TREE_VEC_ELT (declv
, i
) = decl
;
4302 TREE_VEC_ELT (initv
, i
) = init
;
4303 TREE_VEC_ELT (condv
, i
) = cond
;
4304 TREE_VEC_ELT (incrv
, i
) = incr
;
4309 /* Build and validate an OMP_FOR statement. CLAUSES, BODY, COND, INCR
4310 are directly for their associated operands in the statement. DECL
4311 and INIT are a combo; if DECL is NULL then INIT ought to be a
4312 MODIFY_EXPR, and the DECL should be extracted. PRE_BODY are
4313 optional statements that need to go before the loop into its
4317 finish_omp_for (location_t locus
, tree declv
, tree initv
, tree condv
,
4318 tree incrv
, tree body
, tree pre_body
, tree clauses
)
4320 tree omp_for
= NULL
, orig_incr
= NULL
;
4321 tree decl
, init
, cond
, incr
;
4325 gcc_assert (TREE_VEC_LENGTH (declv
) == TREE_VEC_LENGTH (initv
));
4326 gcc_assert (TREE_VEC_LENGTH (declv
) == TREE_VEC_LENGTH (condv
));
4327 gcc_assert (TREE_VEC_LENGTH (declv
) == TREE_VEC_LENGTH (incrv
));
4328 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
4330 decl
= TREE_VEC_ELT (declv
, i
);
4331 init
= TREE_VEC_ELT (initv
, i
);
4332 cond
= TREE_VEC_ELT (condv
, i
);
4333 incr
= TREE_VEC_ELT (incrv
, i
);
4339 switch (TREE_CODE (init
))
4342 decl
= TREE_OPERAND (init
, 0);
4343 init
= TREE_OPERAND (init
, 1);
4346 if (TREE_CODE (TREE_OPERAND (init
, 1)) == NOP_EXPR
)
4348 decl
= TREE_OPERAND (init
, 0);
4349 init
= TREE_OPERAND (init
, 2);
4359 "expected iteration declaration or initialization");
4364 if (init
&& EXPR_HAS_LOCATION (init
))
4365 elocus
= EXPR_LOCATION (init
);
4369 error_at (elocus
, "missing controlling predicate");
4375 error_at (elocus
, "missing increment expression");
4379 TREE_VEC_ELT (declv
, i
) = decl
;
4380 TREE_VEC_ELT (initv
, i
) = init
;
4383 if (dependent_omp_for_p (declv
, initv
, condv
, incrv
))
4387 stmt
= make_node (OMP_FOR
);
4389 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
4391 /* This is really just a place-holder. We'll be decomposing this
4392 again and going through the cp_build_modify_expr path below when
4393 we instantiate the thing. */
4394 TREE_VEC_ELT (initv
, i
)
4395 = build2 (MODIFY_EXPR
, void_type_node
, TREE_VEC_ELT (declv
, i
),
4396 TREE_VEC_ELT (initv
, i
));
4399 TREE_TYPE (stmt
) = void_type_node
;
4400 OMP_FOR_INIT (stmt
) = initv
;
4401 OMP_FOR_COND (stmt
) = condv
;
4402 OMP_FOR_INCR (stmt
) = incrv
;
4403 OMP_FOR_BODY (stmt
) = body
;
4404 OMP_FOR_PRE_BODY (stmt
) = pre_body
;
4405 OMP_FOR_CLAUSES (stmt
) = clauses
;
4407 SET_EXPR_LOCATION (stmt
, locus
);
4408 return add_stmt (stmt
);
4411 if (processing_template_decl
)
4412 orig_incr
= make_tree_vec (TREE_VEC_LENGTH (incrv
));
4414 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); )
4416 decl
= TREE_VEC_ELT (declv
, i
);
4417 init
= TREE_VEC_ELT (initv
, i
);
4418 cond
= TREE_VEC_ELT (condv
, i
);
4419 incr
= TREE_VEC_ELT (incrv
, i
);
4421 TREE_VEC_ELT (orig_incr
, i
) = incr
;
4424 if (init
&& EXPR_HAS_LOCATION (init
))
4425 elocus
= EXPR_LOCATION (init
);
4429 error_at (elocus
, "expected iteration declaration or initialization");
4433 if (incr
&& TREE_CODE (incr
) == MODOP_EXPR
)
4436 TREE_VEC_ELT (orig_incr
, i
) = incr
;
4437 incr
= cp_build_modify_expr (TREE_OPERAND (incr
, 0),
4438 TREE_CODE (TREE_OPERAND (incr
, 1)),
4439 TREE_OPERAND (incr
, 2),
4440 tf_warning_or_error
);
4443 if (CLASS_TYPE_P (TREE_TYPE (decl
)))
4445 if (handle_omp_for_class_iterator (i
, locus
, declv
, initv
, condv
,
4446 incrv
, &body
, &pre_body
, clauses
))
4451 if (!INTEGRAL_TYPE_P (TREE_TYPE (decl
))
4452 && TREE_CODE (TREE_TYPE (decl
)) != POINTER_TYPE
)
4454 error_at (elocus
, "invalid type for iteration variable %qE", decl
);
4458 if (!processing_template_decl
)
4460 init
= fold_build_cleanup_point_expr (TREE_TYPE (init
), init
);
4461 init
= cp_build_modify_expr (decl
, NOP_EXPR
, init
, tf_warning_or_error
);
4464 init
= build2 (MODIFY_EXPR
, void_type_node
, decl
, init
);
4466 && TREE_SIDE_EFFECTS (cond
)
4467 && COMPARISON_CLASS_P (cond
)
4468 && !processing_template_decl
)
4470 tree t
= TREE_OPERAND (cond
, 0);
4471 if (TREE_SIDE_EFFECTS (t
)
4473 && (TREE_CODE (t
) != NOP_EXPR
4474 || TREE_OPERAND (t
, 0) != decl
))
4475 TREE_OPERAND (cond
, 0)
4476 = fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4478 t
= TREE_OPERAND (cond
, 1);
4479 if (TREE_SIDE_EFFECTS (t
)
4481 && (TREE_CODE (t
) != NOP_EXPR
4482 || TREE_OPERAND (t
, 0) != decl
))
4483 TREE_OPERAND (cond
, 1)
4484 = fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4486 if (decl
== error_mark_node
|| init
== error_mark_node
)
4489 TREE_VEC_ELT (declv
, i
) = decl
;
4490 TREE_VEC_ELT (initv
, i
) = init
;
4491 TREE_VEC_ELT (condv
, i
) = cond
;
4492 TREE_VEC_ELT (incrv
, i
) = incr
;
4496 if (IS_EMPTY_STMT (pre_body
))
4499 omp_for
= c_finish_omp_for (locus
, declv
, initv
, condv
, incrv
,
4502 if (omp_for
== NULL
)
4505 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INCR (omp_for
)); i
++)
4507 decl
= TREE_OPERAND (TREE_VEC_ELT (OMP_FOR_INIT (omp_for
), i
), 0);
4508 incr
= TREE_VEC_ELT (OMP_FOR_INCR (omp_for
), i
);
4510 if (TREE_CODE (incr
) != MODIFY_EXPR
)
4513 if (TREE_SIDE_EFFECTS (TREE_OPERAND (incr
, 1))
4514 && BINARY_CLASS_P (TREE_OPERAND (incr
, 1))
4515 && !processing_template_decl
)
4517 tree t
= TREE_OPERAND (TREE_OPERAND (incr
, 1), 0);
4518 if (TREE_SIDE_EFFECTS (t
)
4520 && (TREE_CODE (t
) != NOP_EXPR
4521 || TREE_OPERAND (t
, 0) != decl
))
4522 TREE_OPERAND (TREE_OPERAND (incr
, 1), 0)
4523 = fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4525 t
= TREE_OPERAND (TREE_OPERAND (incr
, 1), 1);
4526 if (TREE_SIDE_EFFECTS (t
)
4528 && (TREE_CODE (t
) != NOP_EXPR
4529 || TREE_OPERAND (t
, 0) != decl
))
4530 TREE_OPERAND (TREE_OPERAND (incr
, 1), 1)
4531 = fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
4535 TREE_VEC_ELT (OMP_FOR_INCR (omp_for
), i
) = TREE_VEC_ELT (orig_incr
, i
);
4537 if (omp_for
!= NULL
)
4538 OMP_FOR_CLAUSES (omp_for
) = clauses
;
4543 finish_omp_atomic (enum tree_code code
, tree lhs
, tree rhs
)
4552 dependent_p
= false;
4555 /* Even in a template, we can detect invalid uses of the atomic
4556 pragma if neither LHS nor RHS is type-dependent. */
4557 if (processing_template_decl
)
4559 dependent_p
= (type_dependent_expression_p (lhs
)
4560 || type_dependent_expression_p (rhs
));
4563 lhs
= build_non_dependent_expr (lhs
);
4564 rhs
= build_non_dependent_expr (rhs
);
4569 stmt
= c_finish_omp_atomic (input_location
, code
, lhs
, rhs
);
4570 if (stmt
== error_mark_node
)
4573 if (processing_template_decl
)
4574 stmt
= build2 (OMP_ATOMIC
, void_type_node
, integer_zero_node
,
4575 build2 (code
, void_type_node
, orig_lhs
, orig_rhs
));
4580 finish_omp_barrier (void)
4582 tree fn
= built_in_decls
[BUILT_IN_GOMP_BARRIER
];
4583 VEC(tree
,gc
) *vec
= make_tree_vector ();
4584 tree stmt
= finish_call_expr (fn
, &vec
, false, false, tf_warning_or_error
);
4585 release_tree_vector (vec
);
4586 finish_expr_stmt (stmt
);
4590 finish_omp_flush (void)
4592 tree fn
= built_in_decls
[BUILT_IN_SYNCHRONIZE
];
4593 VEC(tree
,gc
) *vec
= make_tree_vector ();
4594 tree stmt
= finish_call_expr (fn
, &vec
, false, false, tf_warning_or_error
);
4595 release_tree_vector (vec
);
4596 finish_expr_stmt (stmt
);
4600 finish_omp_taskwait (void)
4602 tree fn
= built_in_decls
[BUILT_IN_GOMP_TASKWAIT
];
4603 VEC(tree
,gc
) *vec
= make_tree_vector ();
4604 tree stmt
= finish_call_expr (fn
, &vec
, false, false, tf_warning_or_error
);
4605 release_tree_vector (vec
);
4606 finish_expr_stmt (stmt
);
4610 init_cp_semantics (void)
4614 /* Build a STATIC_ASSERT for a static assertion with the condition
4615 CONDITION and the message text MESSAGE. LOCATION is the location
4616 of the static assertion in the source code. When MEMBER_P, this
4617 static assertion is a member of a class. */
4619 finish_static_assert (tree condition
, tree message
, location_t location
,
4622 if (check_for_bare_parameter_packs (condition
))
4623 condition
= error_mark_node
;
4625 if (type_dependent_expression_p (condition
)
4626 || value_dependent_expression_p (condition
))
4628 /* We're in a template; build a STATIC_ASSERT and put it in
4632 assertion
= make_node (STATIC_ASSERT
);
4633 STATIC_ASSERT_CONDITION (assertion
) = condition
;
4634 STATIC_ASSERT_MESSAGE (assertion
) = message
;
4635 STATIC_ASSERT_SOURCE_LOCATION (assertion
) = location
;
4638 maybe_add_class_template_decl_list (current_class_type
,
4642 add_stmt (assertion
);
4647 /* Fold the expression and convert it to a boolean value. */
4648 condition
= fold_non_dependent_expr (condition
);
4649 condition
= cp_convert (boolean_type_node
, condition
);
4650 condition
= maybe_constant_value (condition
);
4652 if (TREE_CODE (condition
) == INTEGER_CST
&& !integer_zerop (condition
))
4653 /* Do nothing; the condition is satisfied. */
4657 location_t saved_loc
= input_location
;
4659 input_location
= location
;
4660 if (TREE_CODE (condition
) == INTEGER_CST
4661 && integer_zerop (condition
))
4662 /* Report the error. */
4663 error ("static assertion failed: %E", message
);
4664 else if (condition
&& condition
!= error_mark_node
)
4666 error ("non-constant condition for static assertion");
4667 cxx_constant_value (condition
);
4669 input_location
= saved_loc
;
4673 /* Returns the type of EXPR for cases where we can determine it even though
4674 EXPR is a type-dependent expression. */
4677 describable_type (tree expr
)
4679 tree type
= NULL_TREE
;
4681 if (! type_dependent_expression_p (expr
)
4682 && ! type_unknown_p (expr
))
4684 type
= unlowered_expr_type (expr
);
4685 if (real_lvalue_p (expr
))
4686 type
= build_reference_type (type
);
4692 switch (TREE_CODE (expr
))
4698 return TREE_TYPE (expr
);
4703 case TEMPLATE_PARM_INDEX
:
4705 case STATIC_CAST_EXPR
:
4706 case REINTERPRET_CAST_EXPR
:
4707 case CONST_CAST_EXPR
:
4708 case DYNAMIC_CAST_EXPR
:
4709 type
= TREE_TYPE (expr
);
4714 tree ptrtype
= describable_type (TREE_OPERAND (expr
, 0));
4715 if (ptrtype
&& POINTER_TYPE_P (ptrtype
))
4716 type
= build_reference_type (TREE_TYPE (ptrtype
));
4721 if (TREE_CODE_CLASS (TREE_CODE (expr
)) == tcc_constant
)
4722 type
= TREE_TYPE (expr
);
4726 if (type
&& type_uses_auto (type
))
4732 /* Implements the C++0x decltype keyword. Returns the type of EXPR,
4733 suitable for use as a type-specifier.
4735 ID_EXPRESSION_OR_MEMBER_ACCESS_P is true when EXPR was parsed as an
4736 id-expression or a class member access, FALSE when it was parsed as
4737 a full expression. */
4740 finish_decltype_type (tree expr
, bool id_expression_or_member_access_p
)
4742 tree orig_expr
= expr
;
4743 tree type
= NULL_TREE
;
4745 if (!expr
|| error_operand_p (expr
))
4746 return error_mark_node
;
4749 || TREE_CODE (expr
) == TYPE_DECL
4750 || (TREE_CODE (expr
) == BIT_NOT_EXPR
4751 && TYPE_P (TREE_OPERAND (expr
, 0))))
4753 error ("argument to decltype must be an expression");
4754 return error_mark_node
;
4757 if (type_dependent_expression_p (expr
)
4758 /* In a template, a COMPONENT_REF has an IDENTIFIER_NODE for op1 even
4759 if it isn't dependent, so that we can check access control at
4760 instantiation time, so defer the decltype as well (PR 42277). */
4761 || (id_expression_or_member_access_p
4762 && processing_template_decl
4763 && TREE_CODE (expr
) == COMPONENT_REF
))
4765 if (id_expression_or_member_access_p
)
4767 switch (TREE_CODE (expr
))
4774 case TEMPLATE_PARM_INDEX
:
4775 type
= TREE_TYPE (expr
);
4783 if (type
&& !type_uses_auto (type
))
4787 type
= cxx_make_type (DECLTYPE_TYPE
);
4788 DECLTYPE_TYPE_EXPR (type
) = expr
;
4789 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type
)
4790 = id_expression_or_member_access_p
;
4791 SET_TYPE_STRUCTURAL_EQUALITY (type
);
4796 /* The type denoted by decltype(e) is defined as follows: */
4798 expr
= resolve_nondeduced_context (expr
);
4800 /* To get the size of a static data member declared as an array of
4801 unknown bound, we need to instantiate it. */
4802 if (TREE_CODE (expr
) == VAR_DECL
4803 && VAR_HAD_UNKNOWN_BOUND (expr
)
4804 && DECL_TEMPLATE_INSTANTIATION (expr
))
4805 instantiate_decl (expr
, /*defer_ok*/true, /*expl_inst_mem*/false);
4807 if (id_expression_or_member_access_p
)
4809 /* If e is an id-expression or a class member access (5.2.5
4810 [expr.ref]), decltype(e) is defined as the type of the entity
4811 named by e. If there is no such entity, or e names a set of
4812 overloaded functions, the program is ill-formed. */
4813 if (TREE_CODE (expr
) == IDENTIFIER_NODE
)
4814 expr
= lookup_name (expr
);
4816 if (TREE_CODE (expr
) == INDIRECT_REF
)
4817 /* This can happen when the expression is, e.g., "a.b". Just
4818 look at the underlying operand. */
4819 expr
= TREE_OPERAND (expr
, 0);
4821 if (TREE_CODE (expr
) == OFFSET_REF
4822 || TREE_CODE (expr
) == MEMBER_REF
)
4823 /* We're only interested in the field itself. If it is a
4824 BASELINK, we will need to see through it in the next
4826 expr
= TREE_OPERAND (expr
, 1);
4828 if (TREE_CODE (expr
) == BASELINK
)
4829 /* See through BASELINK nodes to the underlying functions. */
4830 expr
= BASELINK_FUNCTIONS (expr
);
4832 if (TREE_CODE (expr
) == TEMPLATE_ID_EXPR
)
4833 expr
= TREE_OPERAND (expr
, 0);
4835 if (TREE_CODE (expr
) == OVERLOAD
)
4837 if (OVL_CHAIN (expr
)
4838 || TREE_CODE (OVL_FUNCTION (expr
)) == TEMPLATE_DECL
)
4840 error ("%qE refers to a set of overloaded functions", orig_expr
);
4841 return error_mark_node
;
4844 /* An overload set containing only one function: just look
4845 at that function. */
4846 expr
= OVL_FUNCTION (expr
);
4849 switch (TREE_CODE (expr
))
4852 if (DECL_BIT_FIELD_TYPE (expr
))
4854 type
= DECL_BIT_FIELD_TYPE (expr
);
4857 /* Fall through for fields that aren't bitfields. */
4864 case TEMPLATE_PARM_INDEX
:
4865 expr
= mark_type_use (expr
);
4866 type
= TREE_TYPE (expr
);
4870 type
= error_mark_node
;
4874 mark_type_use (expr
);
4875 type
= is_bitfield_expr_with_lowered_type (expr
);
4877 type
= TREE_TYPE (TREE_OPERAND (expr
, 1));
4884 /* We can get here when the id-expression refers to an
4886 type
= TREE_TYPE (expr
);
4890 gcc_assert (TYPE_P (expr
) || DECL_P (expr
)
4891 || TREE_CODE (expr
) == SCOPE_REF
);
4892 error ("argument to decltype must be an expression");
4893 return error_mark_node
;
4898 /* Expressions of reference type are sometimes wrapped in
4899 INDIRECT_REFs. INDIRECT_REFs are just internal compiler
4900 representation, not part of the language, so we have to look
4902 if (TREE_CODE (expr
) == INDIRECT_REF
4903 && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0)))
4905 expr
= TREE_OPERAND (expr
, 0);
4907 if (TREE_CODE (expr
) == CALL_EXPR
)
4909 /* If e is a function call (5.2.2 [expr.call]) or an
4910 invocation of an overloaded operator (parentheses around e
4911 are ignored), decltype(e) is defined as the return type of
4913 tree fndecl
= get_callee_fndecl (expr
);
4914 if (fndecl
&& fndecl
!= error_mark_node
)
4915 type
= TREE_TYPE (TREE_TYPE (fndecl
));
4918 tree target_type
= TREE_TYPE (CALL_EXPR_FN (expr
));
4919 if ((TREE_CODE (target_type
) == REFERENCE_TYPE
4920 || TREE_CODE (target_type
) == POINTER_TYPE
)
4921 && (TREE_CODE (TREE_TYPE (target_type
)) == FUNCTION_TYPE
4922 || TREE_CODE (TREE_TYPE (target_type
)) == METHOD_TYPE
))
4923 type
= TREE_TYPE (TREE_TYPE (target_type
));
4924 else if (processing_template_decl
)
4925 /* Within a template finish_call_expr doesn't resolve
4926 CALL_EXPR_FN, so even though this decltype isn't really
4927 dependent let's defer resolving it. */
4928 goto treat_as_dependent
;
4930 sorry ("unable to determine the declared type of expression %<%E%>",
4936 type
= is_bitfield_expr_with_lowered_type (expr
);
4939 /* Bitfields are special, because their type encodes the
4940 number of bits they store. If the expression referenced a
4941 bitfield, TYPE now has the declared type of that
4943 type
= cp_build_qualified_type (type
,
4944 cp_type_quals (TREE_TYPE (expr
)));
4946 if (real_lvalue_p (expr
))
4947 type
= build_reference_type (type
);
4949 /* Within a lambda-expression:
4951 Every occurrence of decltype((x)) where x is a possibly
4952 parenthesized id-expression that names an entity of
4953 automatic storage duration is treated as if x were
4954 transformed into an access to a corresponding data member
4955 of the closure type that would have been declared if x
4956 were a use of the denoted entity. */
4957 else if (outer_automatic_var_p (expr
)
4958 && current_function_decl
4959 && LAMBDA_FUNCTION_P (current_function_decl
))
4960 type
= capture_decltype (expr
);
4963 /* Otherwise, where T is the type of e, if e is an lvalue,
4964 decltype(e) is defined as T&, otherwise decltype(e) is
4966 type
= TREE_TYPE (expr
);
4967 if (type
== error_mark_node
)
4968 return error_mark_node
;
4969 else if (expr
== current_class_ptr
)
4970 /* If the expression is just "this", we want the
4971 cv-unqualified pointer for the "this" type. */
4972 type
= TYPE_MAIN_VARIANT (type
);
4973 else if (real_lvalue_p (expr
))
4975 if (TREE_CODE (type
) != REFERENCE_TYPE
4976 || TYPE_REF_IS_RVALUE (type
))
4977 type
= build_reference_type (non_reference (type
));
4980 type
= non_reference (type
);
4985 if (!type
|| type
== unknown_type_node
)
4987 error ("type of %qE is unknown", expr
);
4988 return error_mark_node
;
4994 /* Called from trait_expr_value to evaluate either __has_nothrow_assign or
4995 __has_nothrow_copy, depending on assign_p. */
4998 classtype_has_nothrow_assign_or_copy_p (tree type
, bool assign_p
)
5005 ix
= lookup_fnfields_1 (type
, ansi_assopname (NOP_EXPR
));
5008 fns
= VEC_index (tree
, CLASSTYPE_METHOD_VEC (type
), ix
);
5010 else if (TYPE_HAS_COPY_CTOR (type
))
5012 /* If construction of the copy constructor was postponed, create
5014 if (CLASSTYPE_LAZY_COPY_CTOR (type
))
5015 lazily_declare_fn (sfk_copy_constructor
, type
);
5016 if (CLASSTYPE_LAZY_MOVE_CTOR (type
))
5017 lazily_declare_fn (sfk_move_constructor
, type
);
5018 fns
= CLASSTYPE_CONSTRUCTORS (type
);
5023 for (; fns
; fns
= OVL_NEXT (fns
))
5025 tree fn
= OVL_CURRENT (fns
);
5029 if (copy_fn_p (fn
) == 0)
5032 else if (copy_fn_p (fn
) <= 0)
5035 if (!TYPE_NOTHROW_P (TREE_TYPE (fn
)))
5042 /* Actually evaluates the trait. */
5045 trait_expr_value (cp_trait_kind kind
, tree type1
, tree type2
)
5047 enum tree_code type_code1
;
5050 type_code1
= TREE_CODE (type1
);
5054 case CPTK_HAS_NOTHROW_ASSIGN
:
5055 type1
= strip_array_types (type1
);
5056 return (!CP_TYPE_CONST_P (type1
) && type_code1
!= REFERENCE_TYPE
5057 && (trait_expr_value (CPTK_HAS_TRIVIAL_ASSIGN
, type1
, type2
)
5058 || (CLASS_TYPE_P (type1
)
5059 && classtype_has_nothrow_assign_or_copy_p (type1
,
5062 case CPTK_HAS_TRIVIAL_ASSIGN
:
5063 /* ??? The standard seems to be missing the "or array of such a class
5064 type" wording for this trait. */
5065 type1
= strip_array_types (type1
);
5066 return (!CP_TYPE_CONST_P (type1
) && type_code1
!= REFERENCE_TYPE
5067 && (trivial_type_p (type1
)
5068 || (CLASS_TYPE_P (type1
)
5069 && TYPE_HAS_TRIVIAL_COPY_ASSIGN (type1
))));
5071 case CPTK_HAS_NOTHROW_CONSTRUCTOR
:
5072 type1
= strip_array_types (type1
);
5073 return (trait_expr_value (CPTK_HAS_TRIVIAL_CONSTRUCTOR
, type1
, type2
)
5074 || (CLASS_TYPE_P (type1
)
5075 && (t
= locate_ctor (type1
))
5076 && TYPE_NOTHROW_P (TREE_TYPE (t
))));
5078 case CPTK_HAS_TRIVIAL_CONSTRUCTOR
:
5079 type1
= strip_array_types (type1
);
5080 return (trivial_type_p (type1
)
5081 || (CLASS_TYPE_P (type1
) && TYPE_HAS_TRIVIAL_DFLT (type1
)));
5083 case CPTK_HAS_NOTHROW_COPY
:
5084 type1
= strip_array_types (type1
);
5085 return (trait_expr_value (CPTK_HAS_TRIVIAL_COPY
, type1
, type2
)
5086 || (CLASS_TYPE_P (type1
)
5087 && classtype_has_nothrow_assign_or_copy_p (type1
, false)));
5089 case CPTK_HAS_TRIVIAL_COPY
:
5090 /* ??? The standard seems to be missing the "or array of such a class
5091 type" wording for this trait. */
5092 type1
= strip_array_types (type1
);
5093 return (trivial_type_p (type1
) || type_code1
== REFERENCE_TYPE
5094 || (CLASS_TYPE_P (type1
) && TYPE_HAS_TRIVIAL_COPY_CTOR (type1
)));
5096 case CPTK_HAS_TRIVIAL_DESTRUCTOR
:
5097 type1
= strip_array_types (type1
);
5098 return (trivial_type_p (type1
) || type_code1
== REFERENCE_TYPE
5099 || (CLASS_TYPE_P (type1
)
5100 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type1
)));
5102 case CPTK_HAS_VIRTUAL_DESTRUCTOR
:
5103 return type_has_virtual_destructor (type1
);
5105 case CPTK_IS_ABSTRACT
:
5106 return (CLASS_TYPE_P (type1
) && CLASSTYPE_PURE_VIRTUALS (type1
));
5108 case CPTK_IS_BASE_OF
:
5109 return (NON_UNION_CLASS_TYPE_P (type1
) && NON_UNION_CLASS_TYPE_P (type2
)
5110 && DERIVED_FROM_P (type1
, type2
));
5113 return (NON_UNION_CLASS_TYPE_P (type1
));
5115 case CPTK_IS_CONVERTIBLE_TO
:
5120 return (NON_UNION_CLASS_TYPE_P (type1
) && CLASSTYPE_EMPTY_P (type1
));
5123 return (type_code1
== ENUMERAL_TYPE
);
5126 return (pod_type_p (type1
));
5128 case CPTK_IS_POLYMORPHIC
:
5129 return (CLASS_TYPE_P (type1
) && TYPE_POLYMORPHIC_P (type1
));
5131 case CPTK_IS_STD_LAYOUT
:
5132 return (std_layout_type_p (type1
));
5134 case CPTK_IS_TRIVIAL
:
5135 return (trivial_type_p (type1
));
5138 return (type_code1
== UNION_TYPE
);
5140 case CPTK_IS_LITERAL_TYPE
:
5141 return (literal_type_p (type1
));
5149 /* Returns true if TYPE is a complete type, an array of unknown bound,
5150 or (possibly cv-qualified) void, returns false otherwise. */
5153 check_trait_type (tree type
)
5155 if (COMPLETE_TYPE_P (type
))
5158 if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
)
5159 && COMPLETE_TYPE_P (TREE_TYPE (type
)))
5162 if (VOID_TYPE_P (type
))
5168 /* Process a trait expression. */
5171 finish_trait_expr (cp_trait_kind kind
, tree type1
, tree type2
)
5173 gcc_assert (kind
== CPTK_HAS_NOTHROW_ASSIGN
5174 || kind
== CPTK_HAS_NOTHROW_CONSTRUCTOR
5175 || kind
== CPTK_HAS_NOTHROW_COPY
5176 || kind
== CPTK_HAS_TRIVIAL_ASSIGN
5177 || kind
== CPTK_HAS_TRIVIAL_CONSTRUCTOR
5178 || kind
== CPTK_HAS_TRIVIAL_COPY
5179 || kind
== CPTK_HAS_TRIVIAL_DESTRUCTOR
5180 || kind
== CPTK_HAS_VIRTUAL_DESTRUCTOR
5181 || kind
== CPTK_IS_ABSTRACT
5182 || kind
== CPTK_IS_BASE_OF
5183 || kind
== CPTK_IS_CLASS
5184 || kind
== CPTK_IS_CONVERTIBLE_TO
5185 || kind
== CPTK_IS_EMPTY
5186 || kind
== CPTK_IS_ENUM
5187 || kind
== CPTK_IS_POD
5188 || kind
== CPTK_IS_POLYMORPHIC
5189 || kind
== CPTK_IS_STD_LAYOUT
5190 || kind
== CPTK_IS_TRIVIAL
5191 || kind
== CPTK_IS_LITERAL_TYPE
5192 || kind
== CPTK_IS_UNION
);
5194 if (kind
== CPTK_IS_CONVERTIBLE_TO
)
5196 sorry ("__is_convertible_to");
5197 return error_mark_node
;
5200 if (type1
== error_mark_node
5201 || ((kind
== CPTK_IS_BASE_OF
|| kind
== CPTK_IS_CONVERTIBLE_TO
)
5202 && type2
== error_mark_node
))
5203 return error_mark_node
;
5205 if (processing_template_decl
)
5207 tree trait_expr
= make_node (TRAIT_EXPR
);
5208 TREE_TYPE (trait_expr
) = boolean_type_node
;
5209 TRAIT_EXPR_TYPE1 (trait_expr
) = type1
;
5210 TRAIT_EXPR_TYPE2 (trait_expr
) = type2
;
5211 TRAIT_EXPR_KIND (trait_expr
) = kind
;
5215 complete_type (type1
);
5217 complete_type (type2
);
5221 case CPTK_HAS_NOTHROW_ASSIGN
:
5222 case CPTK_HAS_TRIVIAL_ASSIGN
:
5223 case CPTK_HAS_NOTHROW_CONSTRUCTOR
:
5224 case CPTK_HAS_TRIVIAL_CONSTRUCTOR
:
5225 case CPTK_HAS_NOTHROW_COPY
:
5226 case CPTK_HAS_TRIVIAL_COPY
:
5227 case CPTK_HAS_TRIVIAL_DESTRUCTOR
:
5228 case CPTK_HAS_VIRTUAL_DESTRUCTOR
:
5229 case CPTK_IS_ABSTRACT
:
5232 case CPTK_IS_POLYMORPHIC
:
5233 case CPTK_IS_STD_LAYOUT
:
5234 case CPTK_IS_TRIVIAL
:
5235 case CPTK_IS_LITERAL_TYPE
:
5236 if (!check_trait_type (type1
))
5238 error ("incomplete type %qT not allowed", type1
);
5239 return error_mark_node
;
5243 case CPTK_IS_BASE_OF
:
5244 if (NON_UNION_CLASS_TYPE_P (type1
) && NON_UNION_CLASS_TYPE_P (type2
)
5245 && !same_type_ignoring_top_level_qualifiers_p (type1
, type2
)
5246 && !COMPLETE_TYPE_P (type2
))
5248 error ("incomplete type %qT not allowed", type2
);
5249 return error_mark_node
;
5258 case CPTK_IS_CONVERTIBLE_TO
:
5263 return (trait_expr_value (kind
, type1
, type2
)
5264 ? boolean_true_node
: boolean_false_node
);
5267 /* Do-nothing variants of functions to handle pragma FLOAT_CONST_DECIMAL64,
5268 which is ignored for C++. */
5271 set_float_const_decimal64 (void)
5276 clear_float_const_decimal64 (void)
5281 float_const_decimal64_p (void)
5287 /* Return true if T is a literal type. */
5290 literal_type_p (tree t
)
5292 if (SCALAR_TYPE_P (t
))
5294 if (CLASS_TYPE_P (t
))
5295 return CLASSTYPE_LITERAL_P (t
);
5296 if (TREE_CODE (t
) == ARRAY_TYPE
)
5297 return literal_type_p (strip_array_types (t
));
5301 /* If DECL is a variable declared `constexpr', require its type
5302 be literal. Return the DECL if OK, otherwise NULL. */
5305 ensure_literal_type_for_constexpr_object (tree decl
)
5307 tree type
= TREE_TYPE (decl
);
5308 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_DECLARED_CONSTEXPR_P (decl
)
5309 && !processing_template_decl
5310 /* The call to complete_type is just for initializer_list. */
5311 && !literal_type_p (complete_type (type
)))
5313 error ("the type %qT of constexpr variable %qD is not literal",
5320 /* Representation of entries in the constexpr function definition table. */
5322 typedef struct GTY(()) constexpr_fundef
{
5327 /* This table holds all constexpr function definitions seen in
5328 the current translation unit. */
5330 static GTY ((param_is (constexpr_fundef
))) htab_t constexpr_fundef_table
;
5332 /* Utility function used for managing the constexpr function table.
5333 Return true if the entries pointed to by P and Q are for the
5334 same constexpr function. */
5337 constexpr_fundef_equal (const void *p
, const void *q
)
5339 const constexpr_fundef
*lhs
= (const constexpr_fundef
*) p
;
5340 const constexpr_fundef
*rhs
= (const constexpr_fundef
*) q
;
5341 return lhs
->decl
== rhs
->decl
;
5344 /* Utility function used for managing the constexpr function table.
5345 Return a hash value for the entry pointed to by Q. */
5347 static inline hashval_t
5348 constexpr_fundef_hash (const void *p
)
5350 const constexpr_fundef
*fundef
= (const constexpr_fundef
*) p
;
5351 return DECL_UID (fundef
->decl
);
5354 /* Return a previously saved definition of function FUN. */
5356 static constexpr_fundef
*
5357 retrieve_constexpr_fundef (tree fun
)
5359 constexpr_fundef fundef
= { NULL
, NULL
};
5360 if (constexpr_fundef_table
== NULL
)
5364 return (constexpr_fundef
*) htab_find (constexpr_fundef_table
, &fundef
);
5367 /* Return true if type expression T is a valid parameter type, or
5368 a valid return type, of a constexpr function. */
5371 valid_type_in_constexpr_fundecl_p (tree t
)
5373 return (literal_type_p (t
)
5374 /* FIXME we allow ref to non-literal; should change standard to
5375 match, or change back if not. */
5376 || TREE_CODE (t
) == REFERENCE_TYPE
);
5379 /* Check whether the parameter and return types of FUN are valid for a
5380 constexpr function, and complain if COMPLAIN. */
5383 is_valid_constexpr_fn (tree fun
, bool complain
)
5385 tree parm
= FUNCTION_FIRST_USER_PARM (fun
);
5387 for (; parm
!= NULL
; parm
= TREE_CHAIN (parm
))
5388 if (!valid_type_in_constexpr_fundecl_p (TREE_TYPE (parm
)))
5392 error ("invalid type for parameter %q#D of constexpr function",
5396 if (!DECL_CONSTRUCTOR_P (fun
))
5398 tree rettype
= TREE_TYPE (TREE_TYPE (fun
));
5399 if (!valid_type_in_constexpr_fundecl_p (rettype
))
5403 error ("invalid return type %qT of constexpr function %qD",
5407 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fun
)
5408 && COMPLETE_TYPE_P (DECL_CONTEXT (fun
))
5409 && !valid_type_in_constexpr_fundecl_p (DECL_CONTEXT (fun
)))
5413 error ("enclosing class of %q#D is not a literal type", fun
);
5420 /* Return non-null if FUN certainly designates a valid constexpr function
5421 declaration. Otherwise return NULL. Issue appropriate diagnostics
5422 if necessary. Note that we only check the declaration, not the body
5426 validate_constexpr_fundecl (tree fun
)
5428 constexpr_fundef entry
;
5429 constexpr_fundef
**slot
;
5431 if (processing_template_decl
|| !DECL_DECLARED_CONSTEXPR_P (fun
))
5433 else if (DECL_CLONED_FUNCTION_P (fun
))
5434 /* We already checked the original function. */
5437 if (!is_valid_constexpr_fn (fun
, !DECL_TEMPLATE_INSTANTIATION (fun
)))
5439 DECL_DECLARED_CONSTEXPR_P (fun
) = false;
5443 /* Create the constexpr function table if necessary. */
5444 if (constexpr_fundef_table
== NULL
)
5445 constexpr_fundef_table
= htab_create_ggc (101,
5446 constexpr_fundef_hash
,
5447 constexpr_fundef_equal
,
5451 slot
= (constexpr_fundef
**)
5452 htab_find_slot (constexpr_fundef_table
, &entry
, INSERT
);
5455 *slot
= ggc_alloc_constexpr_fundef ();
5461 /* Subroutine of build_constexpr_constructor_member_initializers.
5462 The expression tree T represents a data member initialization
5463 in a (constexpr) constructor definition. Build a pairing of
5464 the data member with its initializer, and prepend that pair
5465 to the existing initialization pair INITS. */
5468 build_data_member_initialization (tree t
, VEC(constructor_elt
,gc
) **vec
)
5471 if (TREE_CODE (t
) == CLEANUP_POINT_EXPR
)
5472 t
= TREE_OPERAND (t
, 0);
5473 if (TREE_CODE (t
) == EXPR_STMT
)
5474 t
= TREE_OPERAND (t
, 0);
5475 if (t
== error_mark_node
)
5477 if (TREE_CODE (t
) == CLEANUP_STMT
)
5479 /* We can't see a CLEANUP_STMT in a constructor for a literal class,
5480 but we can in a constexpr constructor for a non-literal class. Just
5481 ignore it; either all the initialization will be constant, in which
5482 case the cleanup can't run, or it can't be constexpr.
5483 Still recurse into CLEANUP_BODY. */
5484 t
= CLEANUP_BODY (t
);
5485 if (TREE_CODE (t
) == STATEMENT_LIST
)
5487 tree_stmt_iterator i
;
5488 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
5490 if (! build_data_member_initialization (tsi_stmt (i
), vec
))
5495 return build_data_member_initialization (t
, vec
);
5497 if (TREE_CODE (t
) == CONVERT_EXPR
)
5498 t
= TREE_OPERAND (t
, 0);
5499 if (TREE_CODE (t
) == INIT_EXPR
5500 || TREE_CODE (t
) == MODIFY_EXPR
)
5502 member
= TREE_OPERAND (t
, 0);
5503 init
= unshare_expr (TREE_OPERAND (t
, 1));
5507 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
5508 member
= CALL_EXPR_ARG (t
, 0);
5509 /* We don't use build_cplus_new here because it complains about
5510 abstract bases. Leaving the call unwrapped means that it has the
5511 wrong type, but cxx_eval_constant_expression doesn't care. */
5512 init
= unshare_expr (t
);
5514 if (TREE_CODE (member
) == INDIRECT_REF
)
5515 member
= TREE_OPERAND (member
, 0);
5516 if (TREE_CODE (member
) == NOP_EXPR
)
5520 if (TREE_CODE (op
) == ADDR_EXPR
)
5522 gcc_assert (same_type_ignoring_top_level_qualifiers_p
5523 (TREE_TYPE (TREE_TYPE (op
)),
5524 TREE_TYPE (TREE_TYPE (member
))));
5525 /* Initializing a cv-qualified member; we need to look through
5531 /* We don't put out anything for an empty base. */
5532 gcc_assert (is_empty_class (TREE_TYPE (TREE_TYPE (member
))));
5533 /* But if the initializer isn't constexpr, leave it in so we
5535 if (potential_constant_expression (init
, tf_none
))
5539 if (TREE_CODE (member
) == ADDR_EXPR
)
5540 member
= TREE_OPERAND (member
, 0);
5541 if (TREE_CODE (member
) == COMPONENT_REF
)
5542 member
= TREE_OPERAND (member
, 1);
5543 CONSTRUCTOR_APPEND_ELT (*vec
, member
, init
);
5547 /* Make sure that there are no statements after LAST in the constructor
5548 body represented by LIST. */
5551 check_constexpr_ctor_body (tree last
, tree list
)
5554 if (TREE_CODE (list
) == STATEMENT_LIST
)
5556 tree_stmt_iterator i
= tsi_last (list
);
5557 for (; !tsi_end_p (i
); tsi_prev (&i
))
5559 tree t
= tsi_stmt (i
);
5562 if (TREE_CODE (t
) == BIND_EXPR
)
5564 if (!check_constexpr_ctor_body (last
, BIND_EXPR_BODY (t
)))
5569 /* We currently allow typedefs and static_assert.
5570 FIXME allow them in the standard, too. */
5571 if (TREE_CODE (t
) != STATIC_ASSERT
)
5578 else if (list
!= last
5579 && TREE_CODE (list
) != STATIC_ASSERT
)
5583 error ("constexpr constructor does not have empty body");
5584 DECL_DECLARED_CONSTEXPR_P (current_function_decl
) = false;
5589 /* Build compile-time evalable representations of member-initializer list
5590 for a constexpr constructor. */
5593 build_constexpr_constructor_member_initializers (tree type
, tree body
)
5595 VEC(constructor_elt
,gc
) *vec
= NULL
;
5597 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
5598 || TREE_CODE (body
) == EH_SPEC_BLOCK
)
5599 body
= TREE_OPERAND (body
, 0);
5600 if (TREE_CODE (body
) == STATEMENT_LIST
)
5601 body
= STATEMENT_LIST_HEAD (body
)->stmt
;
5602 body
= BIND_EXPR_BODY (body
);
5603 if (TREE_CODE (body
) == CLEANUP_POINT_EXPR
)
5604 ok
= build_data_member_initialization (body
, &vec
);
5605 else if (TREE_CODE (body
) == STATEMENT_LIST
)
5607 tree_stmt_iterator i
;
5608 for (i
= tsi_start (body
); !tsi_end_p (i
); tsi_next (&i
))
5610 ok
= build_data_member_initialization (tsi_stmt (i
), &vec
);
5616 gcc_assert (errorcount
> 0);
5618 return build_constructor (type
, vec
);
5620 return error_mark_node
;
5623 /* We are processing the definition of the constexpr function FUN.
5624 Check that its BODY fulfills the propriate requirements and
5625 enter it in the constexpr function definition table.
5626 For constructor BODY is actually the TREE_LIST of the
5627 member-initializer list. */
5630 register_constexpr_fundef (tree fun
, tree body
)
5632 constexpr_fundef
*fundef
= retrieve_constexpr_fundef (fun
);
5633 gcc_assert (fundef
!= NULL
&& fundef
->body
== NULL
);
5635 if (DECL_CONSTRUCTOR_P (fun
))
5636 body
= build_constexpr_constructor_member_initializers
5637 (DECL_CONTEXT (fun
), body
);
5640 if (TREE_CODE (body
) == BIND_EXPR
)
5641 body
= BIND_EXPR_BODY (body
);
5642 if (TREE_CODE (body
) == EH_SPEC_BLOCK
)
5643 body
= EH_SPEC_STMTS (body
);
5644 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
5645 body
= TREE_OPERAND (body
, 0);
5646 if (TREE_CODE (body
) == CLEANUP_POINT_EXPR
)
5647 body
= TREE_OPERAND (body
, 0);
5648 if (TREE_CODE (body
) != RETURN_EXPR
)
5650 error ("body of constexpr function %qD not a return-statement", fun
);
5651 DECL_DECLARED_CONSTEXPR_P (fun
) = false;
5654 body
= unshare_expr (TREE_OPERAND (body
, 0));
5657 if (!potential_constant_expression (body
, (DECL_TEMPLATE_INSTANTIATION (fun
)
5658 ? tf_none
: tf_error
)))
5660 DECL_DECLARED_CONSTEXPR_P (fun
) = false;
5663 fundef
->body
= body
;
5667 /* Objects of this type represent calls to constexpr functions
5668 along with the bindings of parameters to their arguments, for
5669 the purpose of compile time evaluation. */
5671 typedef struct GTY(()) constexpr_call
{
5672 /* Description of the constexpr function definition. */
5673 constexpr_fundef
*fundef
;
5674 /* Parameter bindings enironment. A TREE_LIST where each TREE_PURPOSE
5675 is a parameter _DECL and the TREE_VALUE is the value of the parameter.
5676 Note: This arrangement is made to accomodate the use of
5677 iterative_hash_template_arg (see pt.c). If you change this
5678 representation, also change the hash calculation in
5679 cxx_eval_call_expression. */
5681 /* Result of the call.
5682 NULL means the call is being evaluated.
5683 error_mark_node means that the evaluation was erroneous;
5684 otherwise, the actuall value of the call. */
5686 /* The hash of this call; we remember it here to avoid having to
5687 recalculate it when expanding the hash table. */
5691 /* A table of all constexpr calls that have been evaluated by the
5692 compiler in this translation unit. */
5694 static GTY ((param_is (constexpr_call
))) htab_t constexpr_call_table
;
5696 static tree
cxx_eval_constant_expression (const constexpr_call
*, tree
,
5697 bool, bool, bool *);
5699 /* Compute a hash value for a constexpr call representation. */
5702 constexpr_call_hash (const void *p
)
5704 const constexpr_call
*info
= (const constexpr_call
*) p
;
5708 /* Return 1 if the objects pointed to by P and Q represent calls
5709 to the same constexpr function with the same arguments.
5710 Otherwise, return 0. */
5713 constexpr_call_equal (const void *p
, const void *q
)
5715 const constexpr_call
*lhs
= (const constexpr_call
*) p
;
5716 const constexpr_call
*rhs
= (const constexpr_call
*) q
;
5721 if (!constexpr_fundef_equal (lhs
->fundef
, rhs
->fundef
))
5723 lhs_bindings
= lhs
->bindings
;
5724 rhs_bindings
= rhs
->bindings
;
5725 while (lhs_bindings
!= NULL
&& rhs_bindings
!= NULL
)
5727 tree lhs_arg
= TREE_VALUE (lhs_bindings
);
5728 tree rhs_arg
= TREE_VALUE (rhs_bindings
);
5729 gcc_assert (TREE_TYPE (lhs_arg
) == TREE_TYPE (rhs_arg
));
5730 if (!cp_tree_equal (lhs_arg
, rhs_arg
))
5732 lhs_bindings
= TREE_CHAIN (lhs_bindings
);
5733 rhs_bindings
= TREE_CHAIN (rhs_bindings
);
5735 return lhs_bindings
== rhs_bindings
;
5738 /* Initialize the constexpr call table, if needed. */
5741 maybe_initialize_constexpr_call_table (void)
5743 if (constexpr_call_table
== NULL
)
5744 constexpr_call_table
= htab_create_ggc (101,
5745 constexpr_call_hash
,
5746 constexpr_call_equal
,
5750 /* Return true if T designates the implied `this' parameter. */
5753 is_this_parameter (tree t
)
5755 return t
== current_class_ptr
;
5758 /* We have an expression tree T that represents a call, either CALL_EXPR
5759 or AGGR_INIT_EXPR. If the call is lexically to a named function,
5760 retrun the _DECL for that function. */
5763 get_function_named_in_call (tree t
)
5766 switch (TREE_CODE (t
))
5769 fun
= CALL_EXPR_FN (t
);
5772 case AGGR_INIT_EXPR
:
5773 fun
= AGGR_INIT_EXPR_FN (t
);
5780 if (TREE_CODE (fun
) == ADDR_EXPR
5781 && TREE_CODE (TREE_OPERAND (fun
, 0)) == FUNCTION_DECL
)
5782 fun
= TREE_OPERAND (fun
, 0);
5786 /* We have an expression tree T that represents a call, either CALL_EXPR
5787 or AGGR_INIT_EXPR. Return the Nth argument. */
5790 get_nth_callarg (tree t
, int n
)
5792 switch (TREE_CODE (t
))
5795 return CALL_EXPR_ARG (t
, n
);
5797 case AGGR_INIT_EXPR
:
5798 return AGGR_INIT_EXPR_ARG (t
, n
);
5806 /* Look up the binding of the function parameter T in a constexpr
5807 function call context CALL. */
5810 lookup_parameter_binding (const constexpr_call
*call
, tree t
)
5812 tree b
= purpose_member (t
, call
->bindings
);
5813 return TREE_VALUE (b
);
5816 /* Attempt to evaluate T which represents a call to a builtin function.
5817 We assume here that all builtin functions evaluate to scalar types
5818 represented by _CST nodes. */
5821 cxx_eval_builtin_function_call (const constexpr_call
*call
, tree t
,
5822 bool allow_non_constant
, bool addr
,
5823 bool *non_constant_p
)
5825 const int nargs
= call_expr_nargs (t
);
5826 tree
*args
= (tree
*) alloca (nargs
* sizeof (tree
));
5829 for (i
= 0; i
< nargs
; ++i
)
5831 args
[i
] = cxx_eval_constant_expression (call
, CALL_EXPR_ARG (t
, i
),
5832 allow_non_constant
, addr
,
5834 if (allow_non_constant
&& *non_constant_p
)
5837 if (*non_constant_p
)
5839 new_call
= build_call_array_loc (EXPR_LOCATION (t
), TREE_TYPE (t
),
5840 CALL_EXPR_FN (t
), nargs
, args
);
5841 return fold (new_call
);
5844 /* TEMP is the constant value of a temporary object of type TYPE. Adjust
5845 the type of the value to match. */
5848 adjust_temp_type (tree type
, tree temp
)
5850 if (TREE_TYPE (temp
) == type
)
5852 /* Avoid wrapping an aggregate value in a NOP_EXPR. */
5853 if (TREE_CODE (temp
) == CONSTRUCTOR
)
5854 return build_constructor (type
, CONSTRUCTOR_ELTS (temp
));
5855 gcc_assert (SCALAR_TYPE_P (type
));
5856 return cp_fold_convert (type
, temp
);
5859 /* Subroutine of cxx_eval_call_expression.
5860 We are processing a call expression (either CALL_EXPR or
5861 AGGR_INIT_EXPR) in the call context of OLD_CALL. Evaluate
5862 all arguments and bind their values to correspondings
5863 parameters, making up the NEW_CALL context. */
5866 cxx_bind_parameters_in_call (const constexpr_call
*old_call
, tree t
,
5867 constexpr_call
*new_call
,
5868 bool allow_non_constant
,
5869 bool *non_constant_p
)
5871 const int nargs
= call_expr_nargs (t
);
5872 tree fun
= new_call
->fundef
->decl
;
5873 tree parms
= DECL_ARGUMENTS (fun
);
5875 for (i
= 0; i
< nargs
; ++i
)
5878 tree type
= parms
? TREE_TYPE (parms
) : void_type_node
;
5879 /* For member function, the first argument is a pointer to the implied
5880 object. And for an object contruction, don't bind `this' before
5881 it is fully constructed. */
5882 if (i
== 0 && DECL_CONSTRUCTOR_P (fun
))
5884 x
= get_nth_callarg (t
, i
);
5885 arg
= cxx_eval_constant_expression (old_call
, x
, allow_non_constant
,
5886 TREE_CODE (type
) == REFERENCE_TYPE
,
5888 /* Don't VERIFY_CONSTANT here. */
5889 if (*non_constant_p
&& allow_non_constant
)
5891 /* Just discard ellipsis args after checking their constantitude. */
5895 /* Make sure the binding has the same type as the parm. */
5896 if (TREE_CODE (type
) != REFERENCE_TYPE
)
5897 arg
= adjust_temp_type (type
, arg
);
5898 new_call
->bindings
= tree_cons (parms
, arg
, new_call
->bindings
);
5900 parms
= TREE_CHAIN (parms
);
5904 /* Variables and functions to manage constexpr call expansion context.
5905 These do not need to be marked for PCH or GC. */
5907 static VEC(tree
,heap
) *call_stack
= NULL
;
5908 static int call_stack_tick
;
5909 static int last_cx_error_tick
;
5912 push_cx_call_context (tree call
)
5915 if (!EXPR_HAS_LOCATION (call
))
5916 SET_EXPR_LOCATION (call
, input_location
);
5917 VEC_safe_push (tree
, heap
, call_stack
, call
);
5921 pop_cx_call_context (void)
5924 VEC_pop (tree
, call_stack
);
5928 cx_error_context (void)
5930 VEC(tree
,heap
) *r
= NULL
;
5931 if (call_stack_tick
!= last_cx_error_tick
5932 && !VEC_empty (tree
, call_stack
))
5934 last_cx_error_tick
= call_stack_tick
;
5938 /* Subroutine of cxx_eval_constant_expression.
5939 Evaluate the call expression tree T in the context of OLD_CALL expression
5943 cxx_eval_call_expression (const constexpr_call
*old_call
, tree t
,
5944 bool allow_non_constant
, bool addr
,
5945 bool *non_constant_p
)
5947 location_t loc
= EXPR_LOC_OR_HERE (t
);
5948 tree fun
= get_function_named_in_call (t
);
5950 constexpr_call new_call
= { NULL
, NULL
, NULL
, 0 };
5951 constexpr_call
**slot
;
5952 if (TREE_CODE (fun
) != FUNCTION_DECL
)
5954 /* Might be a constexpr function pointer. */
5955 fun
= cxx_eval_constant_expression (old_call
, fun
, allow_non_constant
,
5956 /*addr*/false, non_constant_p
);
5957 if (TREE_CODE (fun
) == ADDR_EXPR
)
5958 fun
= TREE_OPERAND (fun
, 0);
5960 if (TREE_CODE (fun
) != FUNCTION_DECL
)
5962 if (!allow_non_constant
)
5963 error_at (loc
, "expression %qE does not designate a constexpr "
5965 *non_constant_p
= true;
5968 if (DECL_CLONED_FUNCTION_P (fun
))
5969 fun
= DECL_CLONED_FUNCTION (fun
);
5970 if (is_builtin_fn (fun
))
5971 return cxx_eval_builtin_function_call (old_call
, t
, allow_non_constant
,
5972 addr
, non_constant_p
);
5973 if (!DECL_DECLARED_CONSTEXPR_P (fun
))
5975 if (!allow_non_constant
)
5977 error_at (loc
, "%qD is not a constexpr function", fun
);
5978 if (DECL_TEMPLATE_INSTANTIATION (fun
)
5979 && DECL_DECLARED_CONSTEXPR_P (DECL_TEMPLATE_RESULT
5980 (DECL_TI_TEMPLATE (fun
))))
5981 is_valid_constexpr_fn (fun
, true);
5983 *non_constant_p
= true;
5987 /* If in direct recursive call, optimize definition search. */
5988 if (old_call
!= NULL
&& old_call
->fundef
->decl
== fun
)
5989 new_call
.fundef
= old_call
->fundef
;
5992 new_call
.fundef
= retrieve_constexpr_fundef (fun
);
5993 if (new_call
.fundef
== NULL
|| new_call
.fundef
->body
== NULL
)
5995 if (!allow_non_constant
)
5996 error_at (loc
, "%qD used before its definition", fun
);
5997 *non_constant_p
= true;
6001 cxx_bind_parameters_in_call (old_call
, t
, &new_call
,
6002 allow_non_constant
, non_constant_p
);
6003 if (*non_constant_p
)
6006 push_cx_call_context (t
);
6009 = iterative_hash_template_arg (new_call
.bindings
,
6010 constexpr_fundef_hash (new_call
.fundef
));
6012 /* If we have seen this call before, we are done. */
6013 maybe_initialize_constexpr_call_table ();
6014 slot
= (constexpr_call
**)
6015 htab_find_slot (constexpr_call_table
, &new_call
, INSERT
);
6018 /* Calls which are in progress have their result set to NULL
6019 so that we can detect circular dependencies. */
6020 if ((*slot
)->result
== NULL
)
6022 if (!allow_non_constant
)
6023 error ("call has circular dependency");
6024 (*slot
)->result
= result
= error_mark_node
;
6028 result
= (*slot
)->result
;
6029 if (result
== error_mark_node
&& !allow_non_constant
)
6030 /* Re-evaluate to get the error. */
6031 cxx_eval_constant_expression (&new_call
, new_call
.fundef
->body
,
6032 allow_non_constant
, addr
,
6038 /* We need to keep a pointer to the entry, not just the slot, as the
6039 slot can move in the call to cxx_eval_builtin_function_call. */
6040 constexpr_call
*entry
= ggc_alloc_constexpr_call ();
6044 = cxx_eval_constant_expression (&new_call
, new_call
.fundef
->body
,
6045 allow_non_constant
, addr
,
6047 if (*non_constant_p
)
6048 entry
->result
= result
= error_mark_node
;
6051 /* If this was a call to initialize an object, set the type of
6052 the CONSTRUCTOR to the type of that object. */
6053 if (DECL_CONSTRUCTOR_P (fun
))
6055 tree ob_arg
= get_nth_callarg (t
, 0);
6056 STRIP_NOPS (ob_arg
);
6057 gcc_assert (TREE_CODE (TREE_TYPE (ob_arg
)) == POINTER_TYPE
6058 && CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (ob_arg
))));
6059 result
= adjust_temp_type (TREE_TYPE (TREE_TYPE (ob_arg
)),
6062 entry
->result
= result
;
6066 pop_cx_call_context ();
6067 return unshare_expr (result
);
6070 /* FIXME speed this up, it's taking 16% of compile time on sieve testcase. */
6073 reduced_constant_expression_p (tree t
)
6075 if (TREE_OVERFLOW_P (t
))
6076 /* Integer overflow makes this not a constant expression. */
6078 /* FIXME are we calling this too much? */
6079 return initializer_constant_valid_p (t
, TREE_TYPE (t
)) != NULL_TREE
;
6082 /* Some expressions may have constant operands but are not constant
6083 themselves, such as 1/0. Call this function (or rather, the macro
6084 following it) to check for that condition.
6086 We only call this in places that require an arithmetic constant, not in
6087 places where we might have a non-constant expression that can be a
6088 component of a constant expression, such as the address of a constexpr
6089 variable that might be dereferenced later. */
6092 verify_constant (tree t
, bool allow_non_constant
, bool *non_constant_p
)
6094 if (!*non_constant_p
&& !reduced_constant_expression_p (t
))
6096 if (!allow_non_constant
)
6098 /* If T was already folded to a _CST with TREE_OVERFLOW set,
6099 printing the folded constant isn't helpful. */
6100 if (TREE_OVERFLOW_P (t
))
6102 permerror (input_location
, "overflow in constant expression");
6103 /* If we're being permissive (and are in an enforcing
6104 context), consider this constant. */
6105 if (flag_permissive
)
6109 error ("%q+E is not a constant expression", t
);
6111 *non_constant_p
= true;
6113 return *non_constant_p
;
6115 #define VERIFY_CONSTANT(X) \
6117 if (verify_constant ((X), allow_non_constant, non_constant_p)) \
6121 /* Subroutine of cxx_eval_constant_expression.
6122 Attempt to reduce the unary expression tree T to a compile time value.
6123 If successful, return the value. Otherwise issue a diagnostic
6124 and return error_mark_node. */
6127 cxx_eval_unary_expression (const constexpr_call
*call
, tree t
,
6128 bool allow_non_constant
, bool addr
,
6129 bool *non_constant_p
)
6132 tree orig_arg
= TREE_OPERAND (t
, 0);
6133 tree arg
= cxx_eval_constant_expression (call
, orig_arg
, allow_non_constant
,
6134 addr
, non_constant_p
);
6135 VERIFY_CONSTANT (arg
);
6136 if (arg
== orig_arg
)
6138 r
= fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), arg
);
6139 VERIFY_CONSTANT (r
);
6143 /* Subroutine of cxx_eval_constant_expression.
6144 Like cxx_eval_unary_expression, except for binary expressions. */
6147 cxx_eval_binary_expression (const constexpr_call
*call
, tree t
,
6148 bool allow_non_constant
, bool addr
,
6149 bool *non_constant_p
)
6152 tree orig_lhs
= TREE_OPERAND (t
, 0);
6153 tree orig_rhs
= TREE_OPERAND (t
, 1);
6155 lhs
= cxx_eval_constant_expression (call
, orig_lhs
,
6156 allow_non_constant
, addr
,
6158 VERIFY_CONSTANT (lhs
);
6159 rhs
= cxx_eval_constant_expression (call
, orig_rhs
,
6160 allow_non_constant
, addr
,
6162 VERIFY_CONSTANT (rhs
);
6163 if (lhs
== orig_lhs
&& rhs
== orig_rhs
)
6165 r
= fold_build2 (TREE_CODE (t
), TREE_TYPE (t
), lhs
, rhs
);
6166 VERIFY_CONSTANT (r
);
6170 /* Subroutine of cxx_eval_constant_expression.
6171 Attempt to evaluate condition expressions. Dead branches are not
6175 cxx_eval_conditional_expression (const constexpr_call
*call
, tree t
,
6176 bool allow_non_constant
, bool addr
,
6177 bool *non_constant_p
)
6179 tree val
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 0),
6180 allow_non_constant
, addr
,
6182 VERIFY_CONSTANT (val
);
6183 if (val
== boolean_true_node
)
6184 return cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 1),
6185 allow_non_constant
, addr
,
6187 gcc_assert (val
== boolean_false_node
);
6188 /* Don't VERIFY_CONSTANT here. */
6189 return cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 2),
6190 allow_non_constant
, addr
,
6194 /* Subroutine of cxx_eval_constant_expression.
6195 Attempt to reduce a reference to an array slot. */
6198 cxx_eval_array_reference (const constexpr_call
*call
, tree t
,
6199 bool allow_non_constant
, bool addr
,
6200 bool *non_constant_p
)
6202 tree oldary
= TREE_OPERAND (t
, 0);
6203 tree ary
= cxx_eval_constant_expression (call
, oldary
,
6204 allow_non_constant
, addr
,
6209 if (*non_constant_p
)
6211 oldidx
= TREE_OPERAND (t
, 1);
6212 index
= cxx_eval_constant_expression (call
, oldidx
,
6213 allow_non_constant
, false,
6215 VERIFY_CONSTANT (index
);
6216 if (addr
&& ary
== oldary
&& index
== oldidx
)
6219 return build4 (ARRAY_REF
, TREE_TYPE (t
), ary
, index
, NULL
, NULL
);
6220 len
= (TREE_CODE (ary
) == CONSTRUCTOR
6221 ? CONSTRUCTOR_NELTS (ary
)
6222 : (unsigned)TREE_STRING_LENGTH (ary
));
6223 if (compare_tree_int (index
, len
) >= 0)
6225 if (!allow_non_constant
)
6226 error ("array subscript out of bound");
6227 *non_constant_p
= true;
6230 i
= tree_low_cst (index
, 0);
6231 if (TREE_CODE (ary
) == CONSTRUCTOR
)
6232 return VEC_index (constructor_elt
, CONSTRUCTOR_ELTS (ary
), i
)->value
;
6234 return build_int_cst (cv_unqualified (TREE_TYPE (TREE_TYPE (ary
))),
6235 TREE_STRING_POINTER (ary
)[i
]);
6236 /* Don't VERIFY_CONSTANT here. */
6239 /* Subroutine of cxx_eval_constant_expression.
6240 Attempt to reduce a field access of a value of class type. */
6243 cxx_eval_component_reference (const constexpr_call
*call
, tree t
,
6244 bool allow_non_constant
, bool addr
,
6245 bool *non_constant_p
)
6247 unsigned HOST_WIDE_INT i
;
6250 tree part
= TREE_OPERAND (t
, 1);
6251 tree orig_whole
= TREE_OPERAND (t
, 0);
6252 tree whole
= cxx_eval_constant_expression (call
, orig_whole
,
6253 allow_non_constant
, addr
,
6255 if (whole
== orig_whole
)
6258 return fold_build3 (COMPONENT_REF
, TREE_TYPE (t
),
6259 whole
, part
, NULL_TREE
);
6260 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
6262 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
6264 if (!allow_non_constant
)
6265 error ("%qE is not a constant expression", orig_whole
);
6266 *non_constant_p
= true;
6268 if (*non_constant_p
)
6270 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
6275 if (TREE_CODE (TREE_TYPE (whole
)) == UNION_TYPE
)
6277 /* FIXME Mike Miller wants this to be OK. */
6278 if (!allow_non_constant
)
6279 error ("accessing %qD member instead of initialized %qD member in "
6280 "constant expression", part
, CONSTRUCTOR_ELT (whole
, 0)->index
);
6281 *non_constant_p
= true;
6285 return error_mark_node
;
6288 /* Subroutine of cxx_eval_constant_expression.
6289 Attempt to reduce a field access of a value of class type that is
6290 expressed as a BIT_FIELD_REF. */
6293 cxx_eval_bit_field_ref (const constexpr_call
*call
, tree t
,
6294 bool allow_non_constant
, bool addr
,
6295 bool *non_constant_p
)
6297 tree orig_whole
= TREE_OPERAND (t
, 0);
6298 tree whole
= cxx_eval_constant_expression (call
, orig_whole
,
6299 allow_non_constant
, addr
,
6301 tree start
, field
, value
;
6302 unsigned HOST_WIDE_INT i
;
6304 if (whole
== orig_whole
)
6306 /* Don't VERIFY_CONSTANT here; we only want to check that we got a
6308 if (!*non_constant_p
&& TREE_CODE (whole
) != CONSTRUCTOR
)
6310 if (!allow_non_constant
)
6311 error ("%qE is not a constant expression", orig_whole
);
6312 *non_constant_p
= true;
6314 if (*non_constant_p
)
6317 start
= TREE_OPERAND (t
, 2);
6318 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (whole
), i
, field
, value
)
6320 if (bit_position (field
) == start
)
6324 return error_mark_node
;
6327 /* Subroutine of cxx_eval_constant_expression.
6328 Evaluate a short-circuited logical expression T in the context
6329 of a given constexpr CALL. BAILOUT_VALUE is the value for
6330 early return. CONTINUE_VALUE is used here purely for
6331 sanity check purposes. */
6334 cxx_eval_logical_expression (const constexpr_call
*call
, tree t
,
6335 tree bailout_value
, tree continue_value
,
6336 bool allow_non_constant
, bool addr
,
6337 bool *non_constant_p
)
6340 tree lhs
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 0),
6341 allow_non_constant
, addr
,
6343 VERIFY_CONSTANT (lhs
);
6344 if (lhs
== bailout_value
)
6346 gcc_assert (lhs
== continue_value
);
6347 r
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 1),
6348 allow_non_constant
, addr
, non_constant_p
);
6349 VERIFY_CONSTANT (r
);
6353 /* Subroutine of cxx_eval_constant_expression.
6354 The expression tree T denotes a C-style array or a C-style
6355 aggregate. Reduce it to a constant expression. */
6358 cxx_eval_bare_aggregate (const constexpr_call
*call
, tree t
,
6359 bool allow_non_constant
, bool addr
,
6360 bool *non_constant_p
)
6362 VEC(constructor_elt
,gc
) *v
= CONSTRUCTOR_ELTS (t
);
6363 VEC(constructor_elt
,gc
) *n
= VEC_alloc (constructor_elt
, gc
,
6364 VEC_length (constructor_elt
, v
));
6365 constructor_elt
*ce
;
6367 bool changed
= false;
6368 tree type
= TREE_TYPE (t
);
6369 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (t
));
6370 for (i
= 0; VEC_iterate (constructor_elt
, v
, i
, ce
); ++i
)
6372 tree elt
= cxx_eval_constant_expression (call
, ce
->value
,
6373 allow_non_constant
, addr
,
6375 /* Don't VERIFY_CONSTANT here. */
6376 if (allow_non_constant
&& *non_constant_p
)
6378 if (elt
!= ce
->value
)
6380 if (TREE_CODE (type
) != ARRAY_TYPE
6381 && !(same_type_ignoring_top_level_qualifiers_p
6382 (DECL_CONTEXT (ce
->index
), type
)))
6384 /* Push our vtable pointer down into the base where it belongs. */
6385 tree vptr_base
= DECL_CONTEXT (ce
->index
);
6387 gcc_assert (ce
->index
== TYPE_VFIELD (type
));
6388 for (base_ctor
= VEC_index (constructor_elt
, n
, 0)->value
; ;
6389 base_ctor
= CONSTRUCTOR_ELT (base_ctor
, 0)->value
)
6390 if (TREE_TYPE (base_ctor
) == vptr_base
)
6392 constructor_elt
*p
= CONSTRUCTOR_ELT (base_ctor
, 0);
6393 gcc_assert (p
->index
== ce
->index
);
6399 CONSTRUCTOR_APPEND_ELT (n
, ce
->index
, elt
);
6401 if (*non_constant_p
|| !changed
)
6404 VEC_free (constructor_elt
, gc
, n
);
6407 t
= build_constructor (TREE_TYPE (t
), n
);
6408 TREE_CONSTANT (t
) = true;
6412 /* Subroutine of cxx_eval_constant_expression.
6413 The expression tree T is a VEC_INIT_EXPR which denotes the desired
6414 initialization of a non-static data member of array type. Reduce it to a
6417 Note that apart from value-initialization (when VALUE_INIT is true),
6418 this is only intended to support value-initialization and the
6419 initializations done by defaulted constructors for classes with
6420 non-static data members of array type. In this case, VEC_INIT_EXPR_INIT
6421 will either be NULL_TREE for the default constructor, or a COMPONENT_REF
6422 for the copy/move constructor. */
6425 cxx_eval_vec_init_1 (const constexpr_call
*call
, tree atype
, tree init
,
6426 bool value_init
, bool allow_non_constant
, bool addr
,
6427 bool *non_constant_p
)
6429 tree elttype
= TREE_TYPE (atype
);
6430 int max
= tree_low_cst (array_type_nelts (atype
), 0);
6431 VEC(constructor_elt
,gc
) *n
= VEC_alloc (constructor_elt
, gc
, max
+ 1);
6434 /* For the default constructor, build up a call to the default
6435 constructor of the element type. We only need to handle class types
6436 here, as for a constructor to be constexpr, all members must be
6437 initialized, which for a defaulted default constructor means they must
6438 be of a class type with a constexpr default constructor. */
6443 VEC(tree
,gc
) *argvec
= make_tree_vector ();
6444 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
6445 &argvec
, elttype
, LOOKUP_NORMAL
,
6446 tf_warning_or_error
);
6447 release_tree_vector (argvec
);
6448 init
= cxx_eval_constant_expression (call
, init
, allow_non_constant
,
6449 addr
, non_constant_p
);
6452 if (*non_constant_p
&& !allow_non_constant
)
6455 for (i
= 0; i
<= max
; ++i
)
6457 tree idx
= build_int_cst (size_type_node
, i
);
6459 if (TREE_CODE (elttype
) == ARRAY_TYPE
)
6461 /* A multidimensional array; recurse. */
6463 eltinit
= NULL_TREE
;
6465 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
6466 tf_warning_or_error
);
6467 eltinit
= cxx_eval_vec_init_1 (call
, elttype
, eltinit
, value_init
,
6468 allow_non_constant
, addr
,
6471 else if (value_init
)
6473 eltinit
= build_value_init (elttype
, tf_warning_or_error
);
6474 eltinit
= cxx_eval_constant_expression
6475 (call
, eltinit
, allow_non_constant
, addr
, non_constant_p
);
6477 else if (TREE_CODE (init
) == CONSTRUCTOR
)
6479 /* Initializing an element using the call to the default
6480 constructor we just built above. */
6481 eltinit
= unshare_expr (init
);
6485 /* Copying an element. */
6486 VEC(tree
,gc
) *argvec
;
6487 gcc_assert (same_type_ignoring_top_level_qualifiers_p
6488 (atype
, TREE_TYPE (init
)));
6489 eltinit
= cp_build_array_ref (input_location
, init
, idx
,
6490 tf_warning_or_error
);
6491 if (!real_lvalue_p (init
))
6492 eltinit
= move (eltinit
);
6493 argvec
= make_tree_vector ();
6494 VEC_quick_push (tree
, argvec
, eltinit
);
6495 eltinit
= (build_special_member_call
6496 (NULL_TREE
, complete_ctor_identifier
, &argvec
,
6497 elttype
, LOOKUP_NORMAL
, tf_warning_or_error
));
6498 release_tree_vector (argvec
);
6499 eltinit
= cxx_eval_constant_expression
6500 (call
, eltinit
, allow_non_constant
, addr
, non_constant_p
);
6502 if (*non_constant_p
&& !allow_non_constant
)
6504 CONSTRUCTOR_APPEND_ELT (n
, idx
, eltinit
);
6507 if (!*non_constant_p
)
6509 init
= build_constructor (TREE_TYPE (atype
), n
);
6510 TREE_CONSTANT (init
) = true;
6515 VEC_free (constructor_elt
, gc
, n
);
6520 cxx_eval_vec_init (const constexpr_call
*call
, tree t
,
6521 bool allow_non_constant
, bool addr
,
6522 bool *non_constant_p
)
6524 tree atype
= TREE_TYPE (t
);
6525 tree init
= VEC_INIT_EXPR_INIT (t
);
6526 tree r
= cxx_eval_vec_init_1 (call
, atype
, init
,
6527 VEC_INIT_EXPR_VALUE_INIT (t
),
6528 allow_non_constant
, addr
, non_constant_p
);
6529 if (*non_constant_p
)
6535 /* A less strict version of fold_indirect_ref_1, which requires cv-quals to
6536 match. We want to be less strict for simple *& folding; if we have a
6537 non-const temporary that we access through a const pointer, that should
6538 work. We handle this here rather than change fold_indirect_ref_1
6539 because we're dealing with things like ADDR_EXPR of INTEGER_CST which
6540 don't really make sense outside of constant expression evaluation. Also
6541 we want to allow folding to COMPONENT_REF, which could cause trouble
6542 with TBAA in fold_indirect_ref_1. */
6545 cxx_eval_indirect_ref (const constexpr_call
*call
, tree t
,
6546 bool allow_non_constant
, bool addr
,
6547 bool *non_constant_p
)
6549 tree orig_op0
= TREE_OPERAND (t
, 0);
6550 tree op0
= cxx_eval_constant_expression (call
, orig_op0
, allow_non_constant
,
6551 /*addr*/false, non_constant_p
);
6552 tree type
, sub
, subtype
, r
;
6555 /* Don't VERIFY_CONSTANT here. */
6556 if (*non_constant_p
)
6559 type
= TREE_TYPE (t
);
6565 subtype
= TREE_TYPE (sub
);
6566 gcc_assert (POINTER_TYPE_P (subtype
));
6568 if (TREE_CODE (sub
) == ADDR_EXPR
)
6570 tree op
= TREE_OPERAND (sub
, 0);
6571 tree optype
= TREE_TYPE (op
);
6573 if (same_type_ignoring_top_level_qualifiers_p (optype
, type
))
6575 /* Also handle conversion to an empty base class, which
6576 is represented with a NOP_EXPR. */
6577 else if (!addr
&& is_empty_class (type
)
6578 && CLASS_TYPE_P (optype
)
6579 && DERIVED_FROM_P (type
, optype
))
6584 /* *(foo *)&struct_with_foo_field => COMPONENT_REF */
6585 else if (RECORD_OR_UNION_TYPE_P (optype
))
6587 tree field
= TYPE_FIELDS (optype
);
6588 for (; field
; field
= DECL_CHAIN (field
))
6589 if (TREE_CODE (field
) == FIELD_DECL
6590 && integer_zerop (byte_position (field
))
6591 && (same_type_ignoring_top_level_qualifiers_p
6592 (TREE_TYPE (field
), type
)))
6594 r
= fold_build3 (COMPONENT_REF
, type
, op
, field
, NULL_TREE
);
6599 else if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
6600 && TREE_CODE (TREE_OPERAND (sub
, 1)) == INTEGER_CST
)
6602 tree op00
= TREE_OPERAND (sub
, 0);
6603 tree op01
= TREE_OPERAND (sub
, 1);
6606 if (TREE_CODE (op00
) == ADDR_EXPR
)
6609 op00
= TREE_OPERAND (op00
, 0);
6610 op00type
= TREE_TYPE (op00
);
6612 /* ((foo *)&struct_with_foo_field)[1] => COMPONENT_REF */
6613 if (RECORD_OR_UNION_TYPE_P (op00type
))
6615 tree field
= TYPE_FIELDS (op00type
);
6616 for (; field
; field
= DECL_CHAIN (field
))
6617 if (TREE_CODE (field
) == FIELD_DECL
6618 && tree_int_cst_equal (byte_position (field
), op01
)
6619 && (same_type_ignoring_top_level_qualifiers_p
6620 (TREE_TYPE (field
), type
)))
6622 r
= fold_build3 (COMPONENT_REF
, type
, op00
,
6630 /* Let build_fold_indirect_ref handle the cases it does fine with. */
6632 r
= build_fold_indirect_ref (op0
);
6633 if (TREE_CODE (r
) != INDIRECT_REF
)
6634 r
= cxx_eval_constant_expression (call
, r
, allow_non_constant
,
6635 addr
, non_constant_p
);
6636 else if (TREE_CODE (sub
) == ADDR_EXPR
6637 || TREE_CODE (sub
) == POINTER_PLUS_EXPR
)
6639 gcc_assert (!same_type_ignoring_top_level_qualifiers_p
6640 (TREE_TYPE (TREE_TYPE (sub
)), TREE_TYPE (t
)));
6641 /* FIXME Mike Miller wants this to be OK. */
6642 if (!allow_non_constant
)
6643 error ("accessing value of %qE through a %qT glvalue in a "
6644 "constant expression", build_fold_indirect_ref (sub
),
6646 *non_constant_p
= true;
6650 /* If we're pulling out the value of an empty base, make sure
6651 that the whole object is constant and then return an empty
6655 VERIFY_CONSTANT (r
);
6656 r
= build_constructor (TREE_TYPE (t
), NULL
);
6657 TREE_CONSTANT (r
) = true;
6660 if (TREE_CODE (r
) == INDIRECT_REF
&& TREE_OPERAND (r
, 0) == orig_op0
)
6665 /* Attempt to reduce the expression T to a constant value.
6666 On failure, issue diagnostic and return error_mark_node. */
6667 /* FIXME unify with c_fully_fold */
6670 cxx_eval_constant_expression (const constexpr_call
*call
, tree t
,
6671 bool allow_non_constant
, bool addr
,
6672 bool *non_constant_p
)
6676 if (t
== error_mark_node
)
6678 *non_constant_p
= true;
6681 if (CONSTANT_CLASS_P (t
))
6683 if (TREE_CODE (t
) == PTRMEM_CST
)
6684 t
= cplus_expand_constant (t
);
6687 if (TREE_CODE (t
) != NOP_EXPR
6688 && reduced_constant_expression_p (t
))
6691 switch (TREE_CODE (t
))
6696 /* else fall through. */
6698 r
= integral_constant_value (t
);
6699 if (TREE_CODE (r
) == TARGET_EXPR
6700 && TREE_CODE (TARGET_EXPR_INITIAL (r
)) == CONSTRUCTOR
)
6701 r
= TARGET_EXPR_INITIAL (r
);
6704 if (!allow_non_constant
)
6706 tree type
= TREE_TYPE (r
);
6707 error ("the value of %qD is not usable in a constant "
6709 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
6711 if (!CP_TYPE_CONST_P (type
))
6712 inform (DECL_SOURCE_LOCATION (r
),
6713 "%q#D is not const", r
);
6714 else if (CP_TYPE_VOLATILE_P (type
))
6715 inform (DECL_SOURCE_LOCATION (r
),
6716 "%q#D is volatile", r
);
6717 else if (!DECL_INITIAL (r
))
6718 inform (DECL_SOURCE_LOCATION (r
),
6719 "%qD was not initialized with a constant "
6726 if (cxx_dialect
>= cxx0x
&& !DECL_DECLARED_CONSTEXPR_P (r
))
6727 inform (DECL_SOURCE_LOCATION (r
),
6728 "%qD was not declared %<constexpr%>", r
);
6730 inform (DECL_SOURCE_LOCATION (r
),
6731 "%qD does not have integral or enumeration type",
6735 *non_constant_p
= true;
6744 if (call
&& DECL_CONTEXT (t
) == call
->fundef
->decl
)
6745 r
= lookup_parameter_binding (call
, t
);
6747 /* Defer in case this is only used for its type. */;
6750 if (!allow_non_constant
)
6751 error ("%qE is not a constant expression", t
);
6752 *non_constant_p
= true;
6757 case AGGR_INIT_EXPR
:
6758 r
= cxx_eval_call_expression (call
, t
, allow_non_constant
, addr
,
6764 /* Pass false for 'addr' because these codes indicate
6765 initialization of a temporary. */
6766 r
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 1),
6767 allow_non_constant
, false,
6769 if (!*non_constant_p
)
6770 /* Adjust the type of the result to the type of the temporary. */
6771 r
= adjust_temp_type (TREE_TYPE (t
), r
);
6775 r
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 1),
6776 allow_non_constant
, addr
,
6781 case NON_LVALUE_EXPR
:
6782 case TRY_CATCH_EXPR
:
6783 case CLEANUP_POINT_EXPR
:
6784 case MUST_NOT_THROW_EXPR
:
6786 r
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 0),
6787 allow_non_constant
, addr
,
6791 /* These differ from cxx_eval_unary_expression in that this doesn't
6792 check for a constant operand or result; an address can be
6793 constant without its operand being, and vice versa. */
6795 r
= cxx_eval_indirect_ref (call
, t
, allow_non_constant
, addr
,
6801 tree oldop
= TREE_OPERAND (t
, 0);
6802 tree op
= cxx_eval_constant_expression (call
, oldop
,
6806 /* Don't VERIFY_CONSTANT here. */
6807 if (*non_constant_p
)
6809 /* This function does more aggressive folding than fold itself. */
6810 r
= build_fold_addr_expr_with_type (op
, TREE_TYPE (t
));
6811 if (TREE_CODE (r
) == ADDR_EXPR
&& TREE_OPERAND (r
, 0) == oldop
)
6819 case FIX_TRUNC_EXPR
:
6824 case TRUTH_NOT_EXPR
:
6825 case FIXED_CONVERT_EXPR
:
6826 r
= cxx_eval_unary_expression (call
, t
, allow_non_constant
, addr
,
6832 /* check_return_expr sometimes wraps a TARGET_EXPR in a
6833 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
6834 introduced by build_call_a. */
6835 tree op0
= TREE_OPERAND (t
, 0);
6836 tree op1
= TREE_OPERAND (t
, 1);
6838 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
6839 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
6840 r
= cxx_eval_constant_expression (call
, op0
, allow_non_constant
,
6841 addr
, non_constant_p
);
6847 case POINTER_PLUS_EXPR
:
6851 case TRUNC_DIV_EXPR
:
6853 case FLOOR_DIV_EXPR
:
6854 case ROUND_DIV_EXPR
:
6855 case TRUNC_MOD_EXPR
:
6857 case ROUND_MOD_EXPR
:
6859 case EXACT_DIV_EXPR
:
6869 case TRUTH_XOR_EXPR
:
6876 case UNORDERED_EXPR
:
6886 r
= cxx_eval_binary_expression (call
, t
, allow_non_constant
, addr
,
6890 /* fold can introduce non-IF versions of these; still treat them as
6891 short-circuiting. */
6892 case TRUTH_AND_EXPR
:
6893 case TRUTH_ANDIF_EXPR
:
6894 r
= cxx_eval_logical_expression (call
, t
, boolean_false_node
,
6896 allow_non_constant
, addr
,
6901 case TRUTH_ORIF_EXPR
:
6902 r
= cxx_eval_logical_expression (call
, t
, boolean_true_node
,
6904 allow_non_constant
, addr
,
6909 r
= cxx_eval_array_reference (call
, t
, allow_non_constant
, addr
,
6914 r
= cxx_eval_component_reference (call
, t
, allow_non_constant
, addr
,
6919 r
= cxx_eval_bit_field_ref (call
, t
, allow_non_constant
, addr
,
6925 r
= cxx_eval_conditional_expression (call
, t
, allow_non_constant
, addr
,
6930 r
= cxx_eval_bare_aggregate (call
, t
, allow_non_constant
, addr
,
6935 /* We can get this in a defaulted constructor for a class with a
6936 non-static data member of array type. Either the initializer will
6937 be NULL, meaning default-initialization, or it will be an lvalue
6938 or xvalue of the same type, meaning direct-initialization from the
6939 corresponding member. */
6940 r
= cxx_eval_vec_init (call
, t
, allow_non_constant
, addr
,
6945 case VIEW_CONVERT_EXPR
:
6948 tree oldop
= TREE_OPERAND (t
, 0);
6950 tree to
= TREE_TYPE (t
);
6951 tree source
= TREE_TYPE (op
);
6952 if (TYPE_PTR_P (source
) && ARITHMETIC_TYPE_P (to
)
6953 && !(TREE_CODE (op
) == COMPONENT_REF
6954 && TYPE_PTRMEMFUNC_P (TREE_TYPE (TREE_OPERAND (op
, 0)))))
6956 if (!allow_non_constant
)
6957 error ("conversion of expression %qE of pointer type "
6958 "cannot yield a constant expression", op
);
6959 *non_constant_p
= true;
6962 op
= cxx_eval_constant_expression (call
, TREE_OPERAND (t
, 0),
6963 allow_non_constant
, addr
,
6965 if (*non_constant_p
)
6968 /* We didn't fold at the top so we could check for ptr-int
6971 r
= fold_build1 (TREE_CODE (t
), to
, op
);
6975 case EMPTY_CLASS_EXPR
:
6976 /* This is good enough for a function argument that might not get
6977 used, and they can't do anything with it, so just return it. */
6981 case DYNAMIC_CAST_EXPR
:
6982 case PSEUDO_DTOR_EXPR
:
6983 case PREINCREMENT_EXPR
:
6984 case POSTINCREMENT_EXPR
:
6985 case PREDECREMENT_EXPR
:
6986 case POSTDECREMENT_EXPR
:
6990 case VEC_DELETE_EXPR
:
6994 /* GCC internal stuff. */
6997 case WITH_CLEANUP_EXPR
:
6998 case STATEMENT_LIST
:
7000 case NON_DEPENDENT_EXPR
:
7003 if (!allow_non_constant
)
7004 error_at (EXPR_LOC_OR_HERE (t
),
7005 "expression %qE is not a constant-expression", t
);
7006 *non_constant_p
= true;
7010 internal_error ("unexpected expression %qE of kind %s", t
,
7011 tree_code_name
[TREE_CODE (t
)]);
7012 *non_constant_p
= true;
7016 if (r
== error_mark_node
)
7017 *non_constant_p
= true;
7019 if (*non_constant_p
)
7026 cxx_eval_outermost_constant_expr (tree t
, bool allow_non_constant
)
7028 bool non_constant_p
= false;
7029 tree r
= cxx_eval_constant_expression (NULL
, t
, allow_non_constant
,
7030 false, &non_constant_p
);
7032 verify_constant (r
, allow_non_constant
, &non_constant_p
);
7034 if (non_constant_p
&& !allow_non_constant
)
7035 return error_mark_node
;
7036 else if (non_constant_p
&& TREE_CONSTANT (t
))
7038 /* This isn't actually constant, so unset TREE_CONSTANT. */
7039 if (EXPR_P (t
) || TREE_CODE (t
) == CONSTRUCTOR
)
7042 r
= build_nop (TREE_TYPE (t
), t
);
7043 TREE_CONSTANT (r
) = false;
7046 else if (non_constant_p
|| r
== t
)
7048 else if (TREE_CODE (r
) == CONSTRUCTOR
&& CLASS_TYPE_P (TREE_TYPE (r
)))
7050 if (TREE_CODE (t
) == TARGET_EXPR
7051 && TARGET_EXPR_INITIAL (t
) == r
)
7055 r
= get_target_expr (r
);
7056 TREE_CONSTANT (r
) = true;
7064 /* Returns true if T is a valid subexpression of a constant expression,
7065 even if it isn't itself a constant expression. */
7068 is_sub_constant_expr (tree t
)
7070 bool non_constant_p
= false;
7071 cxx_eval_constant_expression (NULL
, t
, true, false, &non_constant_p
);
7072 return !non_constant_p
;
7075 /* If T represents a constant expression returns its reduced value.
7076 Otherwise return error_mark_node. If T is dependent, then
7080 cxx_constant_value (tree t
)
7082 return cxx_eval_outermost_constant_expr (t
, false);
7085 /* If T is a constant expression, returns its reduced value.
7086 Otherwise, if T does not have TREE_CONSTANT set, returns T.
7087 Otherwise, returns a version of T without TREE_CONSTANT. */
7090 maybe_constant_value (tree t
)
7094 if (type_dependent_expression_p (t
)
7095 /* FIXME shouldn't check value-dependence first; see comment before
7096 value_dependent_expression_p. */
7097 || value_dependent_expression_p (t
))
7100 r
= cxx_eval_outermost_constant_expr (t
, true);
7101 #ifdef ENABLE_CHECKING
7102 /* cp_tree_equal looks through NOPs, so allow them. */
7104 || CONVERT_EXPR_P (t
)
7105 || (TREE_CONSTANT (t
) && !TREE_CONSTANT (r
))
7106 || !cp_tree_equal (r
, t
));
7111 /* Like maybe_constant_value, but returns a CONSTRUCTOR directly, rather
7112 than wrapped in a TARGET_EXPR. */
7115 maybe_constant_init (tree t
)
7117 t
= maybe_constant_value (t
);
7118 if (TREE_CODE (t
) == TARGET_EXPR
)
7120 tree init
= TARGET_EXPR_INITIAL (t
);
7121 if (TREE_CODE (init
) == CONSTRUCTOR
7122 && TREE_CONSTANT (init
))
7128 /* Return true if the object referred to by REF has automatic or thread
7131 enum { ck_ok
, ck_bad
, ck_unknown
};
7133 check_automatic_or_tls (tree ref
)
7135 enum machine_mode mode
;
7136 HOST_WIDE_INT bitsize
, bitpos
;
7138 int volatilep
= 0, unsignedp
= 0;
7139 tree decl
= get_inner_reference (ref
, &bitsize
, &bitpos
, &offset
,
7140 &mode
, &unsignedp
, &volatilep
, false);
7143 /* If there isn't a decl in the middle, we don't know the linkage here,
7144 and this isn't a constant expression anyway. */
7147 dk
= decl_storage_duration (decl
);
7148 return (dk
== dk_auto
|| dk
== dk_thread
) ? ck_bad
: ck_ok
;
7151 /* Return true if the DECL designates a builtin function that is
7152 morally constexpr, in the sense that its parameter types and
7153 return type are literal types and the compiler is allowed to
7154 fold its invocations. */
7157 morally_constexpr_builtin_function_p (tree decl
)
7159 tree funtype
= TREE_TYPE (decl
);
7162 if (!is_builtin_fn (decl
))
7164 if (!literal_type_p (TREE_TYPE (funtype
)))
7166 for (t
= TYPE_ARG_TYPES (funtype
); t
!= NULL
; t
= TREE_CHAIN (t
))
7168 if (t
== void_list_node
)
7170 if (!literal_type_p (TREE_VALUE (t
)))
7173 /* We assume no varargs builtins are suitable. */
7177 /* Return true if T denotes a constant expression, or potential constant
7178 expression if POTENTIAL is true.
7179 Issue diagnostic as appropriate under control of flags. Variables
7180 with static storage duration initialized by constant expressions
7181 are guaranteed to be statically initialized.
7185 6 An expression is a potential constant expression if it is
7186 a constant expression where all occurences of function
7187 parameters are replaced by arbitrary constant expressions
7188 of the appropriate type.
7190 2 A conditional expression is a constant expression unless it
7191 involves one of the following as a potentially evaluated
7192 subexpression (3.2), but subexpressions of logical AND (5.14),
7193 logical OR (5.15), and conditional (5.16) operations that are
7194 not evaluated are not considered. */
7197 potential_constant_expression (tree t
, tsubst_flags_t flags
)
7201 if (t
== error_mark_node
)
7203 if (TREE_THIS_VOLATILE (t
))
7205 if (flags
& tf_error
)
7206 error ("expression %qE has side-effects", t
);
7209 if (CONSTANT_CLASS_P (t
))
7212 switch (TREE_CODE (t
))
7220 /* -- this (5.1) unless it appears as the postfix-expression in a
7221 class member access expression, including the result of the
7222 implicit transformation in the body of the non-static
7223 member function (9.3.1); */
7224 if (is_this_parameter (t
))
7226 if (flags
& tf_error
)
7227 error ("%qE is not a potential constant expression", t
);
7232 case AGGR_INIT_EXPR
:
7234 /* -- an invocation of a function other than a constexpr function
7235 or a constexpr constructor. */
7237 tree fun
= get_function_named_in_call (t
);
7238 const int nargs
= call_expr_nargs (t
);
7239 if (TREE_CODE (fun
) != FUNCTION_DECL
)
7241 if (potential_constant_expression (fun
, flags
))
7242 /* Might end up being a constant function pointer. */
7244 if (flags
& tf_error
)
7245 error ("%qE is not a function name", fun
);
7248 /* Skip initial arguments to base constructors. */
7249 if (DECL_BASE_CONSTRUCTOR_P (fun
))
7250 i
= num_artificial_parms_for (fun
);
7253 fun
= DECL_ORIGIN (fun
);
7254 if (builtin_valid_in_constant_expr_p (fun
))
7256 if (!DECL_DECLARED_CONSTEXPR_P (fun
)
7257 && !morally_constexpr_builtin_function_p (fun
))
7259 if (flags
& tf_error
)
7260 error ("%qD is not %<constexpr%>", fun
);
7263 for (; i
< nargs
; ++i
)
7265 tree x
= get_nth_callarg (t
, i
);
7266 /* A call to a non-static member function takes the
7267 address of the object as the first argument.
7268 But in a constant expression the address will be folded
7269 away, so look through it now. */
7270 if (i
== 0 && DECL_NONSTATIC_MEMBER_P (fun
)
7271 && !DECL_CONSTRUCTOR_P (fun
))
7273 if (TREE_CODE (x
) == ADDR_EXPR
)
7274 x
= TREE_OPERAND (x
, 0);
7275 if (is_this_parameter (x
))
7277 else if (!potential_constant_expression (x
, flags
))
7279 if (flags
& tf_error
)
7280 error ("object argument is not a potential constant "
7285 else if (!potential_constant_expression (x
, flags
))
7287 if (flags
& tf_error
)
7288 error ("argument in position %qP is not a "
7289 "potential constant expression", i
);
7296 case NON_LVALUE_EXPR
:
7297 /* -- an lvalue-to-rvalue conversion (4.1) unless it is applied to
7298 -- an lvalue of integral type that refers to a non-volatile
7299 const variable or static data member initialized with
7300 constant expressions, or
7302 -- an lvalue of literal type that refers to non-volatile
7303 object defined with constexpr, or that refers to a
7304 sub-object of such an object; */
7305 return potential_constant_expression (TREE_OPERAND (t
, 0), flags
);
7308 if (!decl_constant_var_p (t
))
7310 if (flags
& tf_error
)
7311 error ("variable %qD is not declared constexpr", t
);
7318 case VIEW_CONVERT_EXPR
:
7319 /* -- an array-to-pointer conversion that is applied to an lvalue
7320 that designates an object with thread or automatic storage
7321 duration; FIXME not implemented as it breaks constexpr arrays;
7322 need to fix the standard
7323 -- a type conversion from a pointer or pointer-to-member type
7324 to a literal type. */
7326 tree from
= TREE_OPERAND (t
, 0);
7327 tree source
= TREE_TYPE (from
);
7328 tree target
= TREE_TYPE (t
);
7329 if (TYPE_PTR_P (source
) && ARITHMETIC_TYPE_P (target
)
7330 && !(TREE_CODE (from
) == COMPONENT_REF
7331 && TYPE_PTRMEMFUNC_P (TREE_TYPE (TREE_OPERAND (from
, 0)))))
7333 if (flags
& tf_error
)
7334 error ("conversion of expression %qE of pointer type "
7335 "cannot yield a constant expression", from
);
7338 return potential_constant_expression (from
, flags
);
7342 /* -- a unary operator & that is applied to an lvalue that
7343 designates an object with thread or automatic storage
7345 t
= TREE_OPERAND (t
, 0);
7346 i
= check_automatic_or_tls (t
);
7351 if (flags
& tf_error
)
7352 error ("address-of an object %qE with thread local or "
7353 "automatic storage is not a constant expression", t
);
7356 return potential_constant_expression (t
, flags
);
7360 /* -- a class member access unless its postfix-expression is
7361 of literal type or of pointer to literal type. */
7362 /* This test would be redundant, as it follows from the
7363 postfix-expression being a potential constant expression. */
7364 return potential_constant_expression (TREE_OPERAND (t
, 0), flags
);
7368 tree x
= TREE_OPERAND (t
, 0);
7370 if (is_this_parameter (x
))
7372 return potential_constant_expression (x
, flags
);
7376 case DYNAMIC_CAST_EXPR
:
7377 case PSEUDO_DTOR_EXPR
:
7378 case PREINCREMENT_EXPR
:
7379 case POSTINCREMENT_EXPR
:
7380 case PREDECREMENT_EXPR
:
7381 case POSTDECREMENT_EXPR
:
7385 case VEC_DELETE_EXPR
:
7389 /* GCC internal stuff. */
7392 case WITH_CLEANUP_EXPR
:
7393 case CLEANUP_POINT_EXPR
:
7394 case MUST_NOT_THROW_EXPR
:
7395 case TRY_CATCH_EXPR
:
7396 case STATEMENT_LIST
:
7398 if (flags
& tf_error
)
7399 error ("expression %qE is not a constant-expression", t
);
7403 /* -- a typeid expression whose operand is of polymorphic
7406 tree e
= TREE_OPERAND (t
, 0);
7407 if (!TYPE_P (e
) && TYPE_POLYMORPHIC_P (TREE_TYPE (e
)))
7409 if (flags
& tf_error
)
7410 error ("typeid-expression is not a constant expression "
7411 "because %qE is of polymorphic type", e
);
7418 /* -- a subtraction where both operands are pointers. */
7419 if (TYPE_PTR_P (TREE_OPERAND (t
, 0))
7420 && TYPE_PTR_P (TREE_OPERAND (t
, 1)))
7422 if (flags
& tf_error
)
7423 error ("difference of two pointer expressions is not "
7424 "a constant expression");
7435 /* -- a relational or equality operator where at least
7436 one of the operands is a pointer. */
7437 if (TYPE_PTR_P (TREE_OPERAND (t
, 0))
7438 || TYPE_PTR_P (TREE_OPERAND (t
, 1)))
7440 if (flags
& tf_error
)
7441 error ("pointer comparison expression is not a "
7442 "constant expression");
7451 case FIX_TRUNC_EXPR
:
7456 case TRUTH_NOT_EXPR
:
7458 case FIXED_CONVERT_EXPR
:
7459 /* For convenience. */
7461 return potential_constant_expression (TREE_OPERAND (t
, 0), flags
);
7465 return potential_constant_expression (TREE_OPERAND (t
, 1), flags
);
7469 VEC(constructor_elt
, gc
) *v
= CONSTRUCTOR_ELTS (t
);
7470 constructor_elt
*ce
;
7471 for (i
= 0; VEC_iterate (constructor_elt
, v
, i
, ce
); ++i
)
7472 if (!potential_constant_expression (ce
->value
, flags
))
7479 gcc_assert (TREE_PURPOSE (t
) == NULL_TREE
7480 || DECL_P (TREE_PURPOSE (t
)));
7481 if (!potential_constant_expression (TREE_VALUE (t
), flags
))
7483 if (TREE_CHAIN (t
) == NULL_TREE
)
7485 return potential_constant_expression (TREE_CHAIN (t
), flags
);
7488 case TRUNC_DIV_EXPR
:
7490 case FLOOR_DIV_EXPR
:
7491 case ROUND_DIV_EXPR
:
7492 case TRUNC_MOD_EXPR
:
7494 case ROUND_MOD_EXPR
:
7495 if (integer_zerop (maybe_constant_value (TREE_OPERAND (t
, 1))))
7502 /* check_return_expr sometimes wraps a TARGET_EXPR in a
7503 COMPOUND_EXPR; don't get confused. Also handle EMPTY_CLASS_EXPR
7504 introduced by build_call_a. */
7505 tree op0
= TREE_OPERAND (t
, 0);
7506 tree op1
= TREE_OPERAND (t
, 1);
7508 if ((TREE_CODE (op0
) == TARGET_EXPR
&& op1
== TARGET_EXPR_SLOT (op0
))
7509 || TREE_CODE (op1
) == EMPTY_CLASS_EXPR
)
7510 return potential_constant_expression (op0
, flags
);
7515 /* If the first operand is the non-short-circuit constant, look at
7516 the second operand; otherwise we only care about the first one for
7518 case TRUTH_AND_EXPR
:
7519 case TRUTH_ANDIF_EXPR
:
7520 tmp
= boolean_true_node
;
7523 case TRUTH_ORIF_EXPR
:
7524 tmp
= boolean_false_node
;
7526 if (TREE_OPERAND (t
, 0) == tmp
)
7527 return potential_constant_expression (TREE_OPERAND (t
, 1), flags
);
7529 return potential_constant_expression (TREE_OPERAND (t
, 0), flags
);
7532 case ARRAY_RANGE_REF
:
7535 case POINTER_PLUS_EXPR
:
7537 case EXACT_DIV_EXPR
:
7555 for (i
= 0; i
< 2; ++i
)
7556 if (!potential_constant_expression (TREE_OPERAND (t
, i
),
7563 /* If the condition is a known constant, we know which of the legs we
7564 care about; otherwise we only require that the condition and
7565 either of the legs be potentially constant. */
7566 tmp
= TREE_OPERAND (t
, 0);
7567 if (!potential_constant_expression (tmp
, flags
))
7569 else if (tmp
== boolean_true_node
)
7570 return potential_constant_expression (TREE_OPERAND (t
, 1), flags
);
7571 else if (tmp
== boolean_false_node
)
7572 return potential_constant_expression (TREE_OPERAND (t
, 2), flags
);
7573 for (i
= 1; i
< 3; ++i
)
7574 if (potential_constant_expression (TREE_OPERAND (t
, i
), tf_none
))
7576 if (flags
& tf_error
)
7577 error ("expression %qE is not a constant-expression", t
);
7581 return VEC_INIT_EXPR_IS_CONSTEXPR (t
);
7584 sorry ("unexpected ast of kind %s", tree_code_name
[TREE_CODE (t
)]);
7591 /* Constructor for a lambda expression. */
7594 build_lambda_expr (void)
7596 tree lambda
= make_node (LAMBDA_EXPR
);
7597 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda
) = CPLD_NONE
;
7598 LAMBDA_EXPR_CAPTURE_LIST (lambda
) = NULL_TREE
;
7599 LAMBDA_EXPR_THIS_CAPTURE (lambda
) = NULL_TREE
;
7600 LAMBDA_EXPR_RETURN_TYPE (lambda
) = NULL_TREE
;
7601 LAMBDA_EXPR_MUTABLE_P (lambda
) = false;
7605 /* Create the closure object for a LAMBDA_EXPR. */
7608 build_lambda_object (tree lambda_expr
)
7610 /* Build aggregate constructor call.
7611 - cp_parser_braced_list
7612 - cp_parser_functional_cast */
7613 VEC(constructor_elt
,gc
) *elts
= NULL
;
7614 tree node
, expr
, type
;
7615 location_t saved_loc
;
7617 if (processing_template_decl
)
7620 /* Make sure any error messages refer to the lambda-introducer. */
7621 saved_loc
= input_location
;
7622 input_location
= LAMBDA_EXPR_LOCATION (lambda_expr
);
7624 for (node
= LAMBDA_EXPR_CAPTURE_LIST (lambda_expr
);
7626 node
= TREE_CHAIN (node
))
7628 tree field
= TREE_PURPOSE (node
);
7629 tree val
= TREE_VALUE (node
);
7634 /* Mere mortals can't copy arrays with aggregate initialization, so
7635 do some magic to make it work here. */
7636 if (TREE_CODE (TREE_TYPE (field
)) == ARRAY_TYPE
)
7637 val
= build_array_copy (val
);
7638 else if (DECL_NORMAL_CAPTURE_P (field
)
7639 && TREE_CODE (TREE_TYPE (field
)) != REFERENCE_TYPE
)
7641 /* "the entities that are captured by copy are used to
7642 direct-initialize each corresponding non-static data
7643 member of the resulting closure object."
7645 There's normally no way to express direct-initialization
7646 from an element of a CONSTRUCTOR, so we build up a special
7647 TARGET_EXPR to bypass the usual copy-initialization. */
7648 val
= force_rvalue (val
);
7649 if (TREE_CODE (val
) == TARGET_EXPR
)
7650 TARGET_EXPR_DIRECT_INIT_P (val
) = true;
7653 CONSTRUCTOR_APPEND_ELT (elts
, DECL_NAME (field
), val
);
7656 expr
= build_constructor (init_list_type_node
, elts
);
7657 CONSTRUCTOR_IS_DIRECT_INIT (expr
) = 1;
7659 /* N2927: "[The closure] class type is not an aggregate."
7660 But we briefly treat it as an aggregate to make this simpler. */
7661 type
= TREE_TYPE (lambda_expr
);
7662 CLASSTYPE_NON_AGGREGATE (type
) = 0;
7663 expr
= finish_compound_literal (type
, expr
);
7664 CLASSTYPE_NON_AGGREGATE (type
) = 1;
7666 input_location
= saved_loc
;
7670 /* Return an initialized RECORD_TYPE for LAMBDA.
7671 LAMBDA must have its explicit captures already. */
7674 begin_lambda_type (tree lambda
)
7679 /* Unique name. This is just like an unnamed class, but we cannot use
7680 make_anon_name because of certain checks against TYPE_ANONYMOUS_P. */
7682 name
= make_lambda_name ();
7684 /* Create the new RECORD_TYPE for this lambda. */
7685 type
= xref_tag (/*tag_code=*/record_type
,
7687 /*scope=*/ts_within_enclosing_non_class
,
7688 /*template_header_p=*/false);
7691 /* Designate it as a struct so that we can use aggregate initialization. */
7692 CLASSTYPE_DECLARED_CLASS (type
) = false;
7694 /* Clear base types. */
7695 xref_basetypes (type
, /*bases=*/NULL_TREE
);
7697 /* Start the class. */
7698 type
= begin_class_definition (type
, /*attributes=*/NULL_TREE
);
7700 /* Cross-reference the expression and the type. */
7701 TREE_TYPE (lambda
) = type
;
7702 CLASSTYPE_LAMBDA_EXPR (type
) = lambda
;
7707 /* Returns the type to use for the return type of the operator() of a
7711 lambda_return_type (tree expr
)
7714 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
7716 warning (0, "cannot deduce lambda return type from a braced-init-list");
7717 return void_type_node
;
7719 if (type_dependent_expression_p (expr
))
7721 type
= cxx_make_type (DECLTYPE_TYPE
);
7722 DECLTYPE_TYPE_EXPR (type
) = expr
;
7723 DECLTYPE_FOR_LAMBDA_RETURN (type
) = true;
7724 SET_TYPE_STRUCTURAL_EQUALITY (type
);
7727 type
= type_decays_to (unlowered_expr_type (expr
));
7731 /* Given a LAMBDA_EXPR or closure type LAMBDA, return the op() of the
7735 lambda_function (tree lambda
)
7738 if (TREE_CODE (lambda
) == LAMBDA_EXPR
)
7739 type
= TREE_TYPE (lambda
);
7742 gcc_assert (LAMBDA_TYPE_P (type
));
7743 /* Don't let debug_tree cause instantiation. */
7744 if (CLASSTYPE_TEMPLATE_INSTANTIATION (type
) && !COMPLETE_TYPE_P (type
))
7746 lambda
= lookup_member (type
, ansi_opname (CALL_EXPR
),
7747 /*protect=*/0, /*want_type=*/false);
7749 lambda
= BASELINK_FUNCTIONS (lambda
);
7753 /* Returns the type to use for the FIELD_DECL corresponding to the
7755 The caller should add REFERENCE_TYPE for capture by reference. */
7758 lambda_capture_field_type (tree expr
)
7761 if (type_dependent_expression_p (expr
))
7763 type
= cxx_make_type (DECLTYPE_TYPE
);
7764 DECLTYPE_TYPE_EXPR (type
) = expr
;
7765 DECLTYPE_FOR_LAMBDA_CAPTURE (type
) = true;
7766 SET_TYPE_STRUCTURAL_EQUALITY (type
);
7769 type
= non_reference (unlowered_expr_type (expr
));
7773 /* Recompute the return type for LAMBDA with body of the form:
7774 { return EXPR ; } */
7777 apply_lambda_return_type (tree lambda
, tree return_type
)
7779 tree fco
= lambda_function (lambda
);
7782 LAMBDA_EXPR_RETURN_TYPE (lambda
) = return_type
;
7784 /* If we got a DECLTYPE_TYPE, don't stick it in the function yet,
7785 it would interfere with instantiating the closure type. */
7786 if (dependent_type_p (return_type
))
7788 if (return_type
== error_mark_node
)
7791 /* TREE_TYPE (FUNCTION_DECL) == METHOD_TYPE
7792 TREE_TYPE (METHOD_TYPE) == return-type */
7793 TREE_TYPE (fco
) = change_return_type (return_type
, TREE_TYPE (fco
));
7795 result
= DECL_RESULT (fco
);
7796 if (result
== NULL_TREE
)
7799 /* We already have a DECL_RESULT from start_preparsed_function.
7800 Now we need to redo the work it and allocate_struct_function
7801 did to reflect the new type. */
7802 result
= build_decl (input_location
, RESULT_DECL
, NULL_TREE
,
7803 TYPE_MAIN_VARIANT (return_type
));
7804 DECL_ARTIFICIAL (result
) = 1;
7805 DECL_IGNORED_P (result
) = 1;
7806 cp_apply_type_quals_to_decl (cp_type_quals (return_type
),
7809 DECL_RESULT (fco
) = result
;
7811 if (!processing_template_decl
&& aggregate_value_p (result
, fco
))
7813 #ifdef PCC_STATIC_STRUCT_RETURN
7814 cfun
->returns_pcc_struct
= 1;
7816 cfun
->returns_struct
= 1;
7821 /* DECL is a local variable or parameter from the surrounding scope of a
7822 lambda-expression. Returns the decltype for a use of the capture field
7823 for DECL even if it hasn't been captured yet. */
7826 capture_decltype (tree decl
)
7828 tree lam
= CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (current_function_decl
));
7829 /* FIXME do lookup instead of list walk? */
7830 tree cap
= value_member (decl
, LAMBDA_EXPR_CAPTURE_LIST (lam
));
7834 type
= TREE_TYPE (TREE_PURPOSE (cap
));
7836 switch (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lam
))
7839 error ("%qD is not captured", decl
);
7840 return error_mark_node
;
7843 type
= TREE_TYPE (decl
);
7844 if (TREE_CODE (type
) == REFERENCE_TYPE
7845 && TREE_CODE (TREE_TYPE (type
)) != FUNCTION_TYPE
)
7846 type
= TREE_TYPE (type
);
7849 case CPLD_REFERENCE
:
7850 type
= TREE_TYPE (decl
);
7851 if (TREE_CODE (type
) != REFERENCE_TYPE
)
7852 type
= build_reference_type (TREE_TYPE (decl
));
7859 if (TREE_CODE (type
) != REFERENCE_TYPE
)
7861 if (!LAMBDA_EXPR_MUTABLE_P (lam
))
7862 type
= cp_build_qualified_type (type
, (cp_type_quals (type
)
7864 type
= build_reference_type (type
);
7869 /* From an ID and INITIALIZER, create a capture (by reference if
7870 BY_REFERENCE_P is true), add it to the capture-list for LAMBDA,
7874 add_capture (tree lambda
, tree id
, tree initializer
, bool by_reference_p
,
7875 bool explicit_init_p
)
7880 type
= lambda_capture_field_type (initializer
);
7883 type
= build_reference_type (type
);
7884 if (!real_lvalue_p (initializer
))
7885 error ("cannot capture %qE by reference", initializer
);
7888 /* Make member variable. */
7889 member
= build_lang_decl (FIELD_DECL
, id
, type
);
7890 if (!explicit_init_p
)
7891 /* Normal captures are invisible to name lookup but uses are replaced
7892 with references to the capture field; we implement this by only
7893 really making them invisible in unevaluated context; see
7894 qualify_lookup. For now, let's make explicitly initialized captures
7896 DECL_NORMAL_CAPTURE_P (member
) = true;
7898 /* Add it to the appropriate closure class if we've started it. */
7899 if (current_class_type
&& current_class_type
== TREE_TYPE (lambda
))
7900 finish_member_declaration (member
);
7902 LAMBDA_EXPR_CAPTURE_LIST (lambda
)
7903 = tree_cons (member
, initializer
, LAMBDA_EXPR_CAPTURE_LIST (lambda
));
7905 if (id
== get_identifier ("__this"))
7907 if (LAMBDA_EXPR_CAPTURES_THIS_P (lambda
))
7908 error ("already captured %<this%> in lambda expression");
7909 LAMBDA_EXPR_THIS_CAPTURE (lambda
) = member
;
7915 /* Register all the capture members on the list CAPTURES, which is the
7916 LAMBDA_EXPR_CAPTURE_LIST for the lambda after the introducer. */
7918 void register_capture_members (tree captures
)
7922 register_capture_members (TREE_CHAIN (captures
));
7923 finish_member_declaration (TREE_PURPOSE (captures
));
7927 /* Given a FIELD_DECL decl belonging to a closure type, return a
7928 COMPONENT_REF of it relative to the 'this' parameter of the op() for
7932 thisify_lambda_field (tree decl
)
7934 tree context
= lambda_function (DECL_CONTEXT (decl
));
7935 tree object
= cp_build_indirect_ref (DECL_ARGUMENTS (context
),
7937 tf_warning_or_error
);
7938 return finish_non_static_data_member (decl
, object
,
7939 /*qualifying_scope*/NULL_TREE
);
7942 /* Similar to add_capture, except this works on a stack of nested lambdas.
7943 BY_REFERENCE_P in this case is derived from the default capture mode.
7944 Returns the capture for the lambda at the bottom of the stack. */
7947 add_default_capture (tree lambda_stack
, tree id
, tree initializer
)
7949 bool this_capture_p
= (id
== get_identifier ("__this"));
7951 tree member
= NULL_TREE
;
7953 tree saved_class_type
= current_class_type
;
7957 for (node
= lambda_stack
;
7959 node
= TREE_CHAIN (node
))
7961 tree lambda
= TREE_VALUE (node
);
7963 current_class_type
= TREE_TYPE (lambda
);
7964 member
= add_capture (lambda
,
7969 && (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda
)
7970 == CPLD_REFERENCE
)),
7971 /*explicit_init_p=*/false);
7972 initializer
= thisify_lambda_field (member
);
7975 current_class_type
= saved_class_type
;
7980 /* Return the capture pertaining to a use of 'this' in LAMBDA, in the form of an
7981 INDIRECT_REF, possibly adding it through default capturing. */
7984 lambda_expr_this_capture (tree lambda
)
7988 tree this_capture
= LAMBDA_EXPR_THIS_CAPTURE (lambda
);
7990 /* Try to default capture 'this' if we can. */
7992 && LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda
) != CPLD_NONE
)
7994 tree containing_function
= TYPE_CONTEXT (TREE_TYPE (lambda
));
7995 tree lambda_stack
= tree_cons (NULL_TREE
, lambda
, NULL_TREE
);
7996 tree init
= NULL_TREE
;
7998 /* If we are in a lambda function, we can move out until we hit:
7999 1. a non-lambda function,
8000 2. a lambda function capturing 'this', or
8001 3. a non-default capturing lambda function. */
8002 while (LAMBDA_FUNCTION_P (containing_function
))
8005 = CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (containing_function
));
8007 if (LAMBDA_EXPR_THIS_CAPTURE (lambda
))
8009 /* An outer lambda has already captured 'this'. */
8010 tree cap
= LAMBDA_EXPR_THIS_CAPTURE (lambda
);
8011 init
= thisify_lambda_field (cap
);
8015 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda
) == CPLD_NONE
)
8016 /* An outer lambda won't let us capture 'this'. */
8019 lambda_stack
= tree_cons (NULL_TREE
,
8023 containing_function
= decl_function_context (containing_function
);
8026 if (!init
&& DECL_NONSTATIC_MEMBER_FUNCTION_P (containing_function
)
8027 && !LAMBDA_FUNCTION_P (containing_function
))
8028 /* First parameter is 'this'. */
8029 init
= DECL_ARGUMENTS (containing_function
);
8032 this_capture
= add_default_capture (lambda_stack
,
8033 /*id=*/get_identifier ("__this"),
8039 error ("%<this%> was not captured for this lambda function");
8040 result
= error_mark_node
;
8044 /* To make sure that current_class_ref is for the lambda. */
8045 gcc_assert (TYPE_MAIN_VARIANT (TREE_TYPE (current_class_ref
)) == TREE_TYPE (lambda
));
8047 result
= finish_non_static_data_member (this_capture
,
8049 /*qualifying_scope=*/NULL_TREE
);
8051 /* If 'this' is captured, each use of 'this' is transformed into an
8052 access to the corresponding unnamed data member of the closure
8053 type cast (_expr.cast_ 5.4) to the type of 'this'. [ The cast
8054 ensures that the transformed expression is an rvalue. ] */
8055 result
= rvalue (result
);
8061 /* Returns the method basetype of the innermost non-lambda function, or
8062 NULL_TREE if none. */
8065 nonlambda_method_basetype (void)
8068 if (!current_class_ref
)
8071 type
= current_class_type
;
8072 if (!LAMBDA_TYPE_P (type
))
8075 /* Find the nearest enclosing non-lambda function. */
8076 fn
= TYPE_NAME (type
);
8078 fn
= decl_function_context (fn
);
8079 while (fn
&& LAMBDA_FUNCTION_P (fn
));
8081 if (!fn
|| !DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
))
8084 return TYPE_METHOD_BASETYPE (TREE_TYPE (fn
));
8087 /* If the closure TYPE has a static op(), also add a conversion to function
8091 maybe_add_lambda_conv_op (tree type
)
8093 bool nested
= (current_function_decl
!= NULL_TREE
);
8094 tree callop
= lambda_function (type
);
8095 tree rettype
, name
, fntype
, fn
, body
, compound_stmt
;
8096 tree thistype
, stattype
, statfn
, convfn
, call
, arg
;
8097 VEC (tree
, gc
) *argvec
;
8099 if (LAMBDA_EXPR_CAPTURE_LIST (CLASSTYPE_LAMBDA_EXPR (type
)) != NULL_TREE
)
8102 stattype
= build_function_type (TREE_TYPE (TREE_TYPE (callop
)),
8103 FUNCTION_ARG_CHAIN (callop
));
8105 /* First build up the conversion op. */
8107 rettype
= build_pointer_type (stattype
);
8108 name
= mangle_conv_op_name_for_type (rettype
);
8109 thistype
= cp_build_qualified_type (type
, TYPE_QUAL_CONST
);
8110 fntype
= build_method_type_directly (thistype
, rettype
, void_list_node
);
8111 fn
= convfn
= build_lang_decl (FUNCTION_DECL
, name
, fntype
);
8112 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (callop
);
8114 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
8115 && DECL_ALIGN (fn
) < 2 * BITS_PER_UNIT
)
8116 DECL_ALIGN (fn
) = 2 * BITS_PER_UNIT
;
8118 SET_OVERLOADED_OPERATOR_CODE (fn
, TYPE_EXPR
);
8119 grokclassfn (type
, fn
, NO_SPECIAL
);
8120 set_linkage_according_to_type (type
, fn
);
8121 rest_of_decl_compilation (fn
, toplevel_bindings_p (), at_eof
);
8122 DECL_IN_AGGR_P (fn
) = 1;
8123 DECL_ARTIFICIAL (fn
) = 1;
8124 DECL_NOT_REALLY_EXTERN (fn
) = 1;
8125 DECL_DECLARED_INLINE_P (fn
) = 1;
8126 DECL_ARGUMENTS (fn
) = build_this_parm (fntype
, TYPE_QUAL_CONST
);
8128 DECL_INTERFACE_KNOWN (fn
) = 1;
8130 add_method (type
, fn
, NULL_TREE
);
8132 /* Generic thunk code fails for varargs; we'll complain in mark_used if
8133 the conversion op is used. */
8134 if (varargs_function_p (callop
))
8136 DECL_DELETED_FN (fn
) = 1;
8140 /* Now build up the thunk to be returned. */
8142 name
= get_identifier ("_FUN");
8143 fn
= statfn
= build_lang_decl (FUNCTION_DECL
, name
, stattype
);
8144 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (callop
);
8145 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
8146 && DECL_ALIGN (fn
) < 2 * BITS_PER_UNIT
)
8147 DECL_ALIGN (fn
) = 2 * BITS_PER_UNIT
;
8148 grokclassfn (type
, fn
, NO_SPECIAL
);
8149 set_linkage_according_to_type (type
, fn
);
8150 rest_of_decl_compilation (fn
, toplevel_bindings_p (), at_eof
);
8151 DECL_IN_AGGR_P (fn
) = 1;
8152 DECL_ARTIFICIAL (fn
) = 1;
8153 DECL_NOT_REALLY_EXTERN (fn
) = 1;
8154 DECL_DECLARED_INLINE_P (fn
) = 1;
8155 DECL_STATIC_FUNCTION_P (fn
) = 1;
8156 DECL_ARGUMENTS (fn
) = copy_list (DECL_CHAIN (DECL_ARGUMENTS (callop
)));
8157 for (arg
= DECL_ARGUMENTS (fn
); arg
; arg
= DECL_CHAIN (arg
))
8158 DECL_CONTEXT (arg
) = fn
;
8160 DECL_INTERFACE_KNOWN (fn
) = 1;
8162 add_method (type
, fn
, NULL_TREE
);
8165 push_function_context ();
8167 /* Generate the body of the thunk. */
8169 start_preparsed_function (statfn
, NULL_TREE
,
8170 SF_PRE_PARSED
| SF_INCLASS_INLINE
);
8171 if (DECL_ONE_ONLY (statfn
))
8173 /* Put the thunk in the same comdat group as the call op. */
8174 struct cgraph_node
*callop_node
, *thunk_node
;
8175 DECL_COMDAT_GROUP (statfn
) = DECL_COMDAT_GROUP (callop
);
8176 callop_node
= cgraph_node (callop
);
8177 thunk_node
= cgraph_node (statfn
);
8178 gcc_assert (callop_node
->same_comdat_group
== NULL
);
8179 gcc_assert (thunk_node
->same_comdat_group
== NULL
);
8180 callop_node
->same_comdat_group
= thunk_node
;
8181 thunk_node
->same_comdat_group
= callop_node
;
8183 body
= begin_function_body ();
8184 compound_stmt
= begin_compound_stmt (0);
8186 arg
= build1 (NOP_EXPR
, TREE_TYPE (DECL_ARGUMENTS (callop
)),
8188 argvec
= make_tree_vector ();
8189 VEC_quick_push (tree
, argvec
, arg
);
8190 for (arg
= DECL_ARGUMENTS (statfn
); arg
; arg
= DECL_CHAIN (arg
))
8191 VEC_safe_push (tree
, gc
, argvec
, arg
);
8192 call
= build_call_a (callop
, VEC_length (tree
, argvec
),
8193 VEC_address (tree
, argvec
));
8194 CALL_FROM_THUNK_P (call
) = 1;
8195 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (call
)))
8196 call
= build_cplus_new (TREE_TYPE (call
), call
);
8197 call
= convert_from_reference (call
);
8198 finish_return_stmt (call
);
8200 finish_compound_stmt (compound_stmt
);
8201 finish_function_body (body
);
8203 expand_or_defer_fn (finish_function (2));
8205 /* Generate the body of the conversion op. */
8207 start_preparsed_function (convfn
, NULL_TREE
,
8208 SF_PRE_PARSED
| SF_INCLASS_INLINE
);
8209 body
= begin_function_body ();
8210 compound_stmt
= begin_compound_stmt (0);
8212 finish_return_stmt (decay_conversion (statfn
));
8214 finish_compound_stmt (compound_stmt
);
8215 finish_function_body (body
);
8217 expand_or_defer_fn (finish_function (2));
8220 pop_function_context ();
8222 #include "gt-cp-semantics.h"