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-2019 Free Software Foundation, Inc.
7 Written by Mark Mitchell (mmitchell@usa.net) based on code found
8 formerly in parse.y and pt.c.
10 This file is part of GCC.
12 GCC is free software; you can redistribute it and/or modify it
13 under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 3, or (at your option)
17 GCC is distributed in the hope that it will be useful, but
18 WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 General Public License for more details.
22 You should have received a copy of the GNU General Public License
23 along with GCC; see the file COPYING3. If not see
24 <http://www.gnu.org/licenses/>. */
28 #include "coretypes.h"
32 #include "stringpool.h"
36 #include "stor-layout.h"
37 #include "c-family/c-objc.h"
38 #include "tree-inline.h"
40 #include "tree-iterator.h"
41 #include "omp-general.h"
43 #include "stringpool.h"
45 #include "gomp-constants.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
);
58 /* Used for OpenMP non-static data member privatization. */
60 static hash_map
<tree
, tree
> *omp_private_member_map
;
61 static vec
<tree
> omp_private_member_vec
;
62 static bool omp_private_member_ignore_next
;
65 /* Deferred Access Checking Overview
66 ---------------------------------
68 Most C++ expressions and declarations require access checking
69 to be performed during parsing. However, in several cases,
70 this has to be treated differently.
72 For member declarations, access checking has to be deferred
73 until more information about the declaration is known. For
85 When we are parsing the function return type `A::X', we don't
86 really know if this is allowed until we parse the function name.
88 Furthermore, some contexts require that access checking is
89 never performed at all. These include class heads, and template
92 Typical use of access checking functions is described here:
94 1. When we enter a context that requires certain access checking
95 mode, the function `push_deferring_access_checks' is called with
96 DEFERRING argument specifying the desired mode. Access checking
97 may be performed immediately (dk_no_deferred), deferred
98 (dk_deferred), or not performed (dk_no_check).
100 2. When a declaration such as a type, or a variable, is encountered,
101 the function `perform_or_defer_access_check' is called. It
102 maintains a vector of all deferred checks.
104 3. The global `current_class_type' or `current_function_decl' is then
105 setup by the parser. `enforce_access' relies on these information
108 4. Upon exiting the context mentioned in step 1,
109 `perform_deferred_access_checks' is called to check all declaration
110 stored in the vector. `pop_deferring_access_checks' is then
111 called to restore the previous access checking mode.
113 In case of parsing error, we simply call `pop_deferring_access_checks'
114 without `perform_deferred_access_checks'. */
116 struct GTY(()) deferred_access
{
117 /* A vector representing name-lookups for which we have deferred
118 checking access controls. We cannot check the accessibility of
119 names used in a decl-specifier-seq until we know what is being
120 declared because code like:
127 A::B* A::f() { return 0; }
129 is valid, even though `A::B' is not generally accessible. */
130 vec
<deferred_access_check
, va_gc
> * GTY(()) deferred_access_checks
;
132 /* The current mode of access checks. */
133 enum deferring_kind deferring_access_checks_kind
;
137 /* Data for deferred access checking. */
138 static GTY(()) vec
<deferred_access
, va_gc
> *deferred_access_stack
;
139 static GTY(()) unsigned deferred_access_no_check
;
141 /* Save the current deferred access states and start deferred
142 access checking iff DEFER_P is true. */
145 push_deferring_access_checks (deferring_kind deferring
)
147 /* For context like template instantiation, access checking
148 disabling applies to all nested context. */
149 if (deferred_access_no_check
|| deferring
== dk_no_check
)
150 deferred_access_no_check
++;
153 deferred_access e
= {NULL
, deferring
};
154 vec_safe_push (deferred_access_stack
, e
);
158 /* Save the current deferred access states and start deferred access
159 checking, continuing the set of deferred checks in CHECKS. */
162 reopen_deferring_access_checks (vec
<deferred_access_check
, va_gc
> * checks
)
164 push_deferring_access_checks (dk_deferred
);
165 if (!deferred_access_no_check
)
166 deferred_access_stack
->last().deferred_access_checks
= checks
;
169 /* Resume deferring access checks again after we stopped doing
173 resume_deferring_access_checks (void)
175 if (!deferred_access_no_check
)
176 deferred_access_stack
->last().deferring_access_checks_kind
= dk_deferred
;
179 /* Stop deferring access checks. */
182 stop_deferring_access_checks (void)
184 if (!deferred_access_no_check
)
185 deferred_access_stack
->last().deferring_access_checks_kind
= dk_no_deferred
;
188 /* Discard the current deferred access checks and restore the
192 pop_deferring_access_checks (void)
194 if (deferred_access_no_check
)
195 deferred_access_no_check
--;
197 deferred_access_stack
->pop ();
200 /* Returns a TREE_LIST representing the deferred checks.
201 The TREE_PURPOSE of each node is the type through which the
202 access occurred; the TREE_VALUE is the declaration named.
205 vec
<deferred_access_check
, va_gc
> *
206 get_deferred_access_checks (void)
208 if (deferred_access_no_check
)
211 return (deferred_access_stack
->last().deferred_access_checks
);
214 /* Take current deferred checks and combine with the
215 previous states if we also defer checks previously.
216 Otherwise perform checks now. */
219 pop_to_parent_deferring_access_checks (void)
221 if (deferred_access_no_check
)
222 deferred_access_no_check
--;
225 vec
<deferred_access_check
, va_gc
> *checks
;
226 deferred_access
*ptr
;
228 checks
= (deferred_access_stack
->last ().deferred_access_checks
);
230 deferred_access_stack
->pop ();
231 ptr
= &deferred_access_stack
->last ();
232 if (ptr
->deferring_access_checks_kind
== dk_no_deferred
)
235 perform_access_checks (checks
, tf_warning_or_error
);
239 /* Merge with parent. */
241 deferred_access_check
*chk
, *probe
;
243 FOR_EACH_VEC_SAFE_ELT (checks
, i
, chk
)
245 FOR_EACH_VEC_SAFE_ELT (ptr
->deferred_access_checks
, j
, probe
)
247 if (probe
->binfo
== chk
->binfo
&&
248 probe
->decl
== chk
->decl
&&
249 probe
->diag_decl
== chk
->diag_decl
)
252 /* Insert into parent's checks. */
253 vec_safe_push (ptr
->deferred_access_checks
, *chk
);
260 /* Perform the access checks in CHECKS. The TREE_PURPOSE of each node
261 is the BINFO indicating the qualifying scope used to access the
262 DECL node stored in the TREE_VALUE of the node. If CHECKS is empty
263 or we aren't in SFINAE context or all the checks succeed return TRUE,
267 perform_access_checks (vec
<deferred_access_check
, va_gc
> *checks
,
268 tsubst_flags_t complain
)
271 deferred_access_check
*chk
;
272 location_t loc
= input_location
;
278 FOR_EACH_VEC_SAFE_ELT (checks
, i
, chk
)
280 input_location
= chk
->loc
;
281 ok
&= enforce_access (chk
->binfo
, chk
->decl
, chk
->diag_decl
, complain
);
284 input_location
= loc
;
285 return (complain
& tf_error
) ? true : ok
;
288 /* Perform the deferred access checks.
290 After performing the checks, we still have to keep the list
291 `deferred_access_stack->deferred_access_checks' since we may want
292 to check access for them again later in a different context.
299 A::X A::a, x; // No error for `A::a', error for `x'
301 We have to perform deferred access of `A::X', first with `A::a',
302 next with `x'. Return value like perform_access_checks above. */
305 perform_deferred_access_checks (tsubst_flags_t complain
)
307 return perform_access_checks (get_deferred_access_checks (), complain
);
310 /* Defer checking the accessibility of DECL, when looked up in
311 BINFO. DIAG_DECL is the declaration to use to print diagnostics.
312 Return value like perform_access_checks above.
313 If non-NULL, report failures to AFI. */
316 perform_or_defer_access_check (tree binfo
, tree decl
, tree diag_decl
,
317 tsubst_flags_t complain
,
318 access_failure_info
*afi
)
321 deferred_access
*ptr
;
322 deferred_access_check
*chk
;
325 /* Exit if we are in a context that no access checking is performed.
327 if (deferred_access_no_check
)
330 gcc_assert (TREE_CODE (binfo
) == TREE_BINFO
);
332 ptr
= &deferred_access_stack
->last ();
334 /* If we are not supposed to defer access checks, just check now. */
335 if (ptr
->deferring_access_checks_kind
== dk_no_deferred
)
337 bool ok
= enforce_access (binfo
, decl
, diag_decl
, complain
, afi
);
338 return (complain
& tf_error
) ? true : ok
;
341 /* See if we are already going to perform this check. */
342 FOR_EACH_VEC_SAFE_ELT (ptr
->deferred_access_checks
, i
, chk
)
344 if (chk
->decl
== decl
&& chk
->binfo
== binfo
&&
345 chk
->diag_decl
== diag_decl
)
350 /* If not, record the check. */
351 deferred_access_check new_access
= {binfo
, decl
, diag_decl
, input_location
};
352 vec_safe_push (ptr
->deferred_access_checks
, new_access
);
357 /* Returns nonzero if the current statement is a full expression,
358 i.e. temporaries created during that statement should be destroyed
359 at the end of the statement. */
362 stmts_are_full_exprs_p (void)
364 return current_stmt_tree ()->stmts_are_full_exprs_p
;
367 /* T is a statement. Add it to the statement-tree. This is the C++
368 version. The C/ObjC frontends have a slightly different version of
374 enum tree_code code
= TREE_CODE (t
);
376 if (EXPR_P (t
) && code
!= LABEL_EXPR
)
378 if (!EXPR_HAS_LOCATION (t
))
379 SET_EXPR_LOCATION (t
, input_location
);
381 /* When we expand a statement-tree, we must know whether or not the
382 statements are full-expressions. We record that fact here. */
383 STMT_IS_FULL_EXPR_P (t
) = stmts_are_full_exprs_p ();
386 if (code
== LABEL_EXPR
|| code
== CASE_LABEL_EXPR
)
387 STATEMENT_LIST_HAS_LABEL (cur_stmt_list
) = 1;
389 /* Add T to the statement-tree. Non-side-effect statements need to be
390 recorded during statement expressions. */
391 gcc_checking_assert (!stmt_list_stack
->is_empty ());
392 append_to_statement_list_force (t
, &cur_stmt_list
);
397 /* Returns the stmt_tree to which statements are currently being added. */
400 current_stmt_tree (void)
403 ? &cfun
->language
->base
.x_stmt_tree
404 : &scope_chain
->x_stmt_tree
);
407 /* If statements are full expressions, wrap STMT in a CLEANUP_POINT_EXPR. */
410 maybe_cleanup_point_expr (tree expr
)
412 if (!processing_template_decl
&& stmts_are_full_exprs_p ())
413 expr
= fold_build_cleanup_point_expr (TREE_TYPE (expr
), expr
);
417 /* Like maybe_cleanup_point_expr except have the type of the new expression be
418 void so we don't need to create a temporary variable to hold the inner
419 expression. The reason why we do this is because the original type might be
420 an aggregate and we cannot create a temporary variable for that type. */
423 maybe_cleanup_point_expr_void (tree expr
)
425 if (!processing_template_decl
&& stmts_are_full_exprs_p ())
426 expr
= fold_build_cleanup_point_expr (void_type_node
, expr
);
432 /* Create a declaration statement for the declaration given by the DECL. */
435 add_decl_expr (tree decl
)
437 tree r
= build_stmt (DECL_SOURCE_LOCATION (decl
), DECL_EXPR
, decl
);
438 if (DECL_INITIAL (decl
)
439 || (DECL_SIZE (decl
) && TREE_SIDE_EFFECTS (DECL_SIZE (decl
))))
440 r
= maybe_cleanup_point_expr_void (r
);
444 /* Finish a scope. */
447 do_poplevel (tree stmt_list
)
451 if (stmts_are_full_exprs_p ())
452 block
= poplevel (kept_level_p (), 1, 0);
454 stmt_list
= pop_stmt_list (stmt_list
);
456 if (!processing_template_decl
)
458 stmt_list
= c_build_bind_expr (input_location
, block
, stmt_list
);
459 /* ??? See c_end_compound_stmt re statement expressions. */
465 /* Begin a new scope. */
468 do_pushlevel (scope_kind sk
)
470 tree ret
= push_stmt_list ();
471 if (stmts_are_full_exprs_p ())
472 begin_scope (sk
, NULL
);
476 /* Queue a cleanup. CLEANUP is an expression/statement to be executed
477 when the current scope is exited. EH_ONLY is true when this is not
478 meant to apply to normal control flow transfer. */
481 push_cleanup (tree decl
, tree cleanup
, bool eh_only
)
483 tree stmt
= build_stmt (input_location
, CLEANUP_STMT
, NULL
, cleanup
, decl
);
484 CLEANUP_EH_ONLY (stmt
) = eh_only
;
486 CLEANUP_BODY (stmt
) = push_stmt_list ();
489 /* Simple infinite loop tracking for -Wreturn-type. We keep a stack of all
490 the current loops, represented by 'NULL_TREE' if we've seen a possible
491 exit, and 'error_mark_node' if not. This is currently used only to
492 suppress the warning about a function with no return statements, and
493 therefore we don't bother noting returns as possible exits. We also
494 don't bother with gotos. */
497 begin_maybe_infinite_loop (tree cond
)
499 /* Only track this while parsing a function, not during instantiation. */
500 if (!cfun
|| (DECL_TEMPLATE_INSTANTIATION (current_function_decl
)
501 && !processing_template_decl
))
503 bool maybe_infinite
= true;
506 cond
= fold_non_dependent_expr (cond
);
507 maybe_infinite
= integer_nonzerop (cond
);
509 vec_safe_push (cp_function_chain
->infinite_loops
,
510 maybe_infinite
? error_mark_node
: NULL_TREE
);
514 /* A break is a possible exit for the current loop. */
517 break_maybe_infinite_loop (void)
521 cp_function_chain
->infinite_loops
->last() = NULL_TREE
;
524 /* If we reach the end of the loop without seeing a possible exit, we have
528 end_maybe_infinite_loop (tree cond
)
530 if (!cfun
|| (DECL_TEMPLATE_INSTANTIATION (current_function_decl
)
531 && !processing_template_decl
))
533 tree current
= cp_function_chain
->infinite_loops
->pop();
534 if (current
!= NULL_TREE
)
536 cond
= fold_non_dependent_expr (cond
);
537 if (integer_nonzerop (cond
))
538 current_function_infinite_loop
= 1;
543 /* Begin a conditional that might contain a declaration. When generating
544 normal code, we want the declaration to appear before the statement
545 containing the conditional. When generating template code, we want the
546 conditional to be rendered as the raw DECL_EXPR. */
549 begin_cond (tree
*cond_p
)
551 if (processing_template_decl
)
552 *cond_p
= push_stmt_list ();
555 /* Finish such a conditional. */
558 finish_cond (tree
*cond_p
, tree expr
)
560 if (processing_template_decl
)
562 tree cond
= pop_stmt_list (*cond_p
);
564 if (expr
== NULL_TREE
)
565 /* Empty condition in 'for'. */
566 gcc_assert (empty_expr_stmt_p (cond
));
567 else if (check_for_bare_parameter_packs (expr
))
568 expr
= error_mark_node
;
569 else if (!empty_expr_stmt_p (cond
))
570 expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (expr
), cond
, expr
);
575 /* If *COND_P specifies a conditional with a declaration, transform the
578 for (; A x = 42;) { }
580 while (true) { A x = 42; if (!x) break; }
581 for (;;) { A x = 42; if (!x) break; }
582 The statement list for BODY will be empty if the conditional did
583 not declare anything. */
586 simplify_loop_decl_cond (tree
*cond_p
, tree body
)
590 if (!TREE_SIDE_EFFECTS (body
))
594 *cond_p
= boolean_true_node
;
596 if_stmt
= begin_if_stmt ();
597 cond
= cp_build_unary_op (TRUTH_NOT_EXPR
, cond
, false, tf_warning_or_error
);
598 finish_if_stmt_cond (cond
, if_stmt
);
599 finish_break_stmt ();
600 finish_then_clause (if_stmt
);
601 finish_if_stmt (if_stmt
);
604 /* Finish a goto-statement. */
607 finish_goto_stmt (tree destination
)
609 if (identifier_p (destination
))
610 destination
= lookup_label (destination
);
612 /* We warn about unused labels with -Wunused. That means we have to
613 mark the used labels as used. */
614 if (TREE_CODE (destination
) == LABEL_DECL
)
615 TREE_USED (destination
) = 1;
618 destination
= mark_rvalue_use (destination
);
619 if (!processing_template_decl
)
621 destination
= cp_convert (ptr_type_node
, destination
,
622 tf_warning_or_error
);
623 if (error_operand_p (destination
))
626 = fold_build_cleanup_point_expr (TREE_TYPE (destination
),
631 check_goto (destination
);
633 add_stmt (build_predict_expr (PRED_GOTO
, NOT_TAKEN
));
634 return add_stmt (build_stmt (input_location
, GOTO_EXPR
, destination
));
637 /* COND is the condition-expression for an if, while, etc.,
638 statement. Convert it to a boolean value, if appropriate.
639 In addition, verify sequence points if -Wsequence-point is enabled. */
642 maybe_convert_cond (tree cond
)
644 /* Empty conditions remain empty. */
648 /* Wait until we instantiate templates before doing conversion. */
649 if (type_dependent_expression_p (cond
))
652 if (warn_sequence_point
&& !processing_template_decl
)
653 verify_sequence_points (cond
);
655 /* Do the conversion. */
656 cond
= convert_from_reference (cond
);
658 if (TREE_CODE (cond
) == MODIFY_EXPR
659 && !TREE_NO_WARNING (cond
)
661 && warning_at (cp_expr_loc_or_input_loc (cond
),
662 OPT_Wparentheses
, "suggest parentheses around "
663 "assignment used as truth value"))
664 TREE_NO_WARNING (cond
) = 1;
666 return condition_conversion (cond
);
669 /* Finish an expression-statement, whose EXPRESSION is as indicated. */
672 finish_expr_stmt (tree expr
)
675 location_t loc
= EXPR_LOCATION (expr
);
677 if (expr
!= NULL_TREE
)
679 /* If we ran into a problem, make sure we complained. */
680 gcc_assert (expr
!= error_mark_node
|| seen_error ());
682 if (!processing_template_decl
)
684 if (warn_sequence_point
)
685 verify_sequence_points (expr
);
686 expr
= convert_to_void (expr
, ICV_STATEMENT
, tf_warning_or_error
);
688 else if (!type_dependent_expression_p (expr
))
689 convert_to_void (build_non_dependent_expr (expr
), ICV_STATEMENT
,
690 tf_warning_or_error
);
692 if (check_for_bare_parameter_packs (expr
))
693 expr
= error_mark_node
;
695 /* Simplification of inner statement expressions, compound exprs,
696 etc can result in us already having an EXPR_STMT. */
697 if (TREE_CODE (expr
) != CLEANUP_POINT_EXPR
)
699 if (TREE_CODE (expr
) != EXPR_STMT
)
700 expr
= build_stmt (loc
, EXPR_STMT
, expr
);
701 expr
= maybe_cleanup_point_expr_void (expr
);
711 /* Begin an if-statement. Returns a newly created IF_STMT if
718 scope
= do_pushlevel (sk_cond
);
719 r
= build_stmt (input_location
, IF_STMT
, NULL_TREE
,
720 NULL_TREE
, NULL_TREE
, scope
);
721 current_binding_level
->this_entity
= r
;
722 begin_cond (&IF_COND (r
));
726 /* Returns true if FN, a CALL_EXPR, is a call to
727 std::is_constant_evaluated or __builtin_is_constant_evaluated. */
730 is_std_constant_evaluated_p (tree fn
)
732 /* std::is_constant_evaluated takes no arguments. */
733 if (call_expr_nargs (fn
) != 0)
736 tree fndecl
= cp_get_callee_fndecl_nofold (fn
);
737 if (fndecl_built_in_p (fndecl
, CP_BUILT_IN_IS_CONSTANT_EVALUATED
,
741 if (!decl_in_std_namespace_p (fndecl
))
744 tree name
= DECL_NAME (fndecl
);
745 return name
&& id_equal (name
, "is_constant_evaluated");
748 /* Process the COND of an if-statement, which may be given by
752 finish_if_stmt_cond (tree cond
, tree if_stmt
)
754 cond
= maybe_convert_cond (cond
);
755 if (IF_STMT_CONSTEXPR_P (if_stmt
)
756 && !type_dependent_expression_p (cond
)
757 && require_constant_expression (cond
)
758 && !instantiation_dependent_expression_p (cond
)
759 /* Wait until instantiation time, since only then COND has been
760 converted to bool. */
761 && TYPE_MAIN_VARIANT (TREE_TYPE (cond
)) == boolean_type_node
)
763 /* if constexpr (std::is_constant_evaluated()) is always true,
764 so give the user a clue. */
765 if (warn_tautological_compare
)
768 if (TREE_CODE (t
) == CLEANUP_POINT_EXPR
)
769 t
= TREE_OPERAND (t
, 0);
770 if (TREE_CODE (t
) == CALL_EXPR
771 && is_std_constant_evaluated_p (t
))
772 warning_at (EXPR_LOCATION (cond
), OPT_Wtautological_compare
,
773 "%qs always evaluates to true in %<if constexpr%>",
774 "std::is_constant_evaluated");
777 cond
= instantiate_non_dependent_expr (cond
);
778 cond
= cxx_constant_value (cond
, NULL_TREE
);
780 finish_cond (&IF_COND (if_stmt
), cond
);
782 THEN_CLAUSE (if_stmt
) = push_stmt_list ();
786 /* Finish the then-clause of an if-statement, which may be given by
790 finish_then_clause (tree if_stmt
)
792 THEN_CLAUSE (if_stmt
) = pop_stmt_list (THEN_CLAUSE (if_stmt
));
796 /* Begin the else-clause of an if-statement. */
799 begin_else_clause (tree if_stmt
)
801 ELSE_CLAUSE (if_stmt
) = push_stmt_list ();
804 /* Finish the else-clause of an if-statement, which may be given by
808 finish_else_clause (tree if_stmt
)
810 ELSE_CLAUSE (if_stmt
) = pop_stmt_list (ELSE_CLAUSE (if_stmt
));
813 /* Callback for cp_walk_tree to mark all {VAR,PARM}_DECLs in a tree as
817 maybe_mark_exp_read_r (tree
*tp
, int *, void *)
820 if (VAR_P (t
) || TREE_CODE (t
) == PARM_DECL
)
825 /* Finish an if-statement. */
828 finish_if_stmt (tree if_stmt
)
830 tree scope
= IF_SCOPE (if_stmt
);
831 IF_SCOPE (if_stmt
) = NULL
;
832 if (IF_STMT_CONSTEXPR_P (if_stmt
))
834 /* Prevent various -Wunused warnings. We might not instantiate
835 either of these branches, so we would not mark the variables
836 used in that branch as read. */
837 cp_walk_tree_without_duplicates (&THEN_CLAUSE (if_stmt
),
838 maybe_mark_exp_read_r
, NULL
);
839 cp_walk_tree_without_duplicates (&ELSE_CLAUSE (if_stmt
),
840 maybe_mark_exp_read_r
, NULL
);
842 add_stmt (do_poplevel (scope
));
845 /* Begin a while-statement. Returns a newly created WHILE_STMT if
849 begin_while_stmt (void)
852 r
= build_stmt (input_location
, WHILE_STMT
, NULL_TREE
, NULL_TREE
);
854 WHILE_BODY (r
) = do_pushlevel (sk_block
);
855 begin_cond (&WHILE_COND (r
));
859 /* Process the COND of a while-statement, which may be given by
863 finish_while_stmt_cond (tree cond
, tree while_stmt
, bool ivdep
,
864 unsigned short unroll
)
866 cond
= maybe_convert_cond (cond
);
867 finish_cond (&WHILE_COND (while_stmt
), cond
);
868 begin_maybe_infinite_loop (cond
);
869 if (ivdep
&& cond
!= error_mark_node
)
870 WHILE_COND (while_stmt
) = build3 (ANNOTATE_EXPR
,
871 TREE_TYPE (WHILE_COND (while_stmt
)),
872 WHILE_COND (while_stmt
),
873 build_int_cst (integer_type_node
,
874 annot_expr_ivdep_kind
),
876 if (unroll
&& cond
!= error_mark_node
)
877 WHILE_COND (while_stmt
) = build3 (ANNOTATE_EXPR
,
878 TREE_TYPE (WHILE_COND (while_stmt
)),
879 WHILE_COND (while_stmt
),
880 build_int_cst (integer_type_node
,
881 annot_expr_unroll_kind
),
882 build_int_cst (integer_type_node
,
884 simplify_loop_decl_cond (&WHILE_COND (while_stmt
), WHILE_BODY (while_stmt
));
887 /* Finish a while-statement, which may be given by WHILE_STMT. */
890 finish_while_stmt (tree while_stmt
)
892 end_maybe_infinite_loop (boolean_true_node
);
893 WHILE_BODY (while_stmt
) = do_poplevel (WHILE_BODY (while_stmt
));
896 /* Begin a do-statement. Returns a newly created DO_STMT if
902 tree r
= build_stmt (input_location
, DO_STMT
, NULL_TREE
, NULL_TREE
);
903 begin_maybe_infinite_loop (boolean_true_node
);
905 DO_BODY (r
) = push_stmt_list ();
909 /* Finish the body of a do-statement, which may be given by DO_STMT. */
912 finish_do_body (tree do_stmt
)
914 tree body
= DO_BODY (do_stmt
) = pop_stmt_list (DO_BODY (do_stmt
));
916 if (TREE_CODE (body
) == STATEMENT_LIST
&& STATEMENT_LIST_TAIL (body
))
917 body
= STATEMENT_LIST_TAIL (body
)->stmt
;
919 if (IS_EMPTY_STMT (body
))
920 warning (OPT_Wempty_body
,
921 "suggest explicit braces around empty body in %<do%> statement");
924 /* Finish a do-statement, which may be given by DO_STMT, and whose
925 COND is as indicated. */
928 finish_do_stmt (tree cond
, tree do_stmt
, bool ivdep
, unsigned short unroll
)
930 cond
= maybe_convert_cond (cond
);
931 end_maybe_infinite_loop (cond
);
932 if (ivdep
&& cond
!= error_mark_node
)
933 cond
= build3 (ANNOTATE_EXPR
, TREE_TYPE (cond
), cond
,
934 build_int_cst (integer_type_node
, annot_expr_ivdep_kind
),
936 if (unroll
&& cond
!= error_mark_node
)
937 cond
= build3 (ANNOTATE_EXPR
, TREE_TYPE (cond
), cond
,
938 build_int_cst (integer_type_node
, annot_expr_unroll_kind
),
939 build_int_cst (integer_type_node
, unroll
));
940 DO_COND (do_stmt
) = cond
;
943 /* Finish a return-statement. The EXPRESSION returned, if any, is as
947 finish_return_stmt (tree expr
)
952 expr
= check_return_expr (expr
, &no_warning
);
954 if (error_operand_p (expr
)
955 || (flag_openmp
&& !check_omp_return ()))
957 /* Suppress -Wreturn-type for this function. */
958 if (warn_return_type
)
959 TREE_NO_WARNING (current_function_decl
) = true;
960 return error_mark_node
;
963 if (!processing_template_decl
)
965 if (warn_sequence_point
)
966 verify_sequence_points (expr
);
968 if (DECL_DESTRUCTOR_P (current_function_decl
)
969 || (DECL_CONSTRUCTOR_P (current_function_decl
)
970 && targetm
.cxx
.cdtor_returns_this ()))
972 /* Similarly, all destructors must run destructors for
973 base-classes before returning. So, all returns in a
974 destructor get sent to the DTOR_LABEL; finish_function emits
975 code to return a value there. */
976 return finish_goto_stmt (cdtor_label
);
980 r
= build_stmt (input_location
, RETURN_EXPR
, expr
);
981 TREE_NO_WARNING (r
) |= no_warning
;
982 r
= maybe_cleanup_point_expr_void (r
);
988 /* Begin the scope of a for-statement or a range-for-statement.
989 Both the returned trees are to be used in a call to
990 begin_for_stmt or begin_range_for_stmt. */
993 begin_for_scope (tree
*init
)
995 tree scope
= do_pushlevel (sk_for
);
997 if (processing_template_decl
)
998 *init
= push_stmt_list ();
1005 /* Begin a for-statement. Returns a new FOR_STMT.
1006 SCOPE and INIT should be the return of begin_for_scope,
1007 or both NULL_TREE */
1010 begin_for_stmt (tree scope
, tree init
)
1014 r
= build_stmt (input_location
, FOR_STMT
, NULL_TREE
, NULL_TREE
,
1015 NULL_TREE
, NULL_TREE
, NULL_TREE
);
1017 if (scope
== NULL_TREE
)
1020 scope
= begin_for_scope (&init
);
1023 FOR_INIT_STMT (r
) = init
;
1024 FOR_SCOPE (r
) = scope
;
1029 /* Finish the init-statement of a for-statement, which may be
1030 given by FOR_STMT. */
1033 finish_init_stmt (tree for_stmt
)
1035 if (processing_template_decl
)
1036 FOR_INIT_STMT (for_stmt
) = pop_stmt_list (FOR_INIT_STMT (for_stmt
));
1037 add_stmt (for_stmt
);
1038 FOR_BODY (for_stmt
) = do_pushlevel (sk_block
);
1039 begin_cond (&FOR_COND (for_stmt
));
1042 /* Finish the COND of a for-statement, which may be given by
1046 finish_for_cond (tree cond
, tree for_stmt
, bool ivdep
, unsigned short unroll
)
1048 cond
= maybe_convert_cond (cond
);
1049 finish_cond (&FOR_COND (for_stmt
), cond
);
1050 begin_maybe_infinite_loop (cond
);
1051 if (ivdep
&& cond
!= error_mark_node
)
1052 FOR_COND (for_stmt
) = build3 (ANNOTATE_EXPR
,
1053 TREE_TYPE (FOR_COND (for_stmt
)),
1054 FOR_COND (for_stmt
),
1055 build_int_cst (integer_type_node
,
1056 annot_expr_ivdep_kind
),
1058 if (unroll
&& cond
!= error_mark_node
)
1059 FOR_COND (for_stmt
) = build3 (ANNOTATE_EXPR
,
1060 TREE_TYPE (FOR_COND (for_stmt
)),
1061 FOR_COND (for_stmt
),
1062 build_int_cst (integer_type_node
,
1063 annot_expr_unroll_kind
),
1064 build_int_cst (integer_type_node
,
1066 simplify_loop_decl_cond (&FOR_COND (for_stmt
), FOR_BODY (for_stmt
));
1069 /* Finish the increment-EXPRESSION in a for-statement, which may be
1070 given by FOR_STMT. */
1073 finish_for_expr (tree expr
, tree for_stmt
)
1077 /* If EXPR is an overloaded function, issue an error; there is no
1078 context available to use to perform overload resolution. */
1079 if (type_unknown_p (expr
))
1081 cxx_incomplete_type_error (expr
, TREE_TYPE (expr
));
1082 expr
= error_mark_node
;
1084 if (!processing_template_decl
)
1086 if (warn_sequence_point
)
1087 verify_sequence_points (expr
);
1088 expr
= convert_to_void (expr
, ICV_THIRD_IN_FOR
,
1089 tf_warning_or_error
);
1091 else if (!type_dependent_expression_p (expr
))
1092 convert_to_void (build_non_dependent_expr (expr
), ICV_THIRD_IN_FOR
,
1093 tf_warning_or_error
);
1094 expr
= maybe_cleanup_point_expr_void (expr
);
1095 if (check_for_bare_parameter_packs (expr
))
1096 expr
= error_mark_node
;
1097 FOR_EXPR (for_stmt
) = expr
;
1100 /* Finish the body of a for-statement, which may be given by
1101 FOR_STMT. The increment-EXPR for the loop must be
1103 It can also finish RANGE_FOR_STMT. */
1106 finish_for_stmt (tree for_stmt
)
1108 end_maybe_infinite_loop (boolean_true_node
);
1110 if (TREE_CODE (for_stmt
) == RANGE_FOR_STMT
)
1111 RANGE_FOR_BODY (for_stmt
) = do_poplevel (RANGE_FOR_BODY (for_stmt
));
1113 FOR_BODY (for_stmt
) = do_poplevel (FOR_BODY (for_stmt
));
1115 /* Pop the scope for the body of the loop. */
1116 tree
*scope_ptr
= (TREE_CODE (for_stmt
) == RANGE_FOR_STMT
1117 ? &RANGE_FOR_SCOPE (for_stmt
)
1118 : &FOR_SCOPE (for_stmt
));
1119 tree scope
= *scope_ptr
;
1122 /* During parsing of the body, range for uses "__for_{range,begin,end} "
1123 decl names to make those unaccessible by code in the body.
1124 Change it to ones with underscore instead of space, so that it can
1125 be inspected in the debugger. */
1126 tree range_for_decl
[3] = { NULL_TREE
, NULL_TREE
, NULL_TREE
};
1127 gcc_assert (CPTI_FOR_BEGIN__IDENTIFIER
== CPTI_FOR_RANGE__IDENTIFIER
+ 1
1128 && CPTI_FOR_END__IDENTIFIER
== CPTI_FOR_RANGE__IDENTIFIER
+ 2
1129 && CPTI_FOR_RANGE_IDENTIFIER
== CPTI_FOR_RANGE__IDENTIFIER
+ 3
1130 && CPTI_FOR_BEGIN_IDENTIFIER
== CPTI_FOR_BEGIN__IDENTIFIER
+ 3
1131 && CPTI_FOR_END_IDENTIFIER
== CPTI_FOR_END__IDENTIFIER
+ 3);
1132 for (int i
= 0; i
< 3; i
++)
1134 tree id
= cp_global_trees
[CPTI_FOR_RANGE__IDENTIFIER
+ i
];
1135 if (IDENTIFIER_BINDING (id
)
1136 && IDENTIFIER_BINDING (id
)->scope
== current_binding_level
)
1138 range_for_decl
[i
] = IDENTIFIER_BINDING (id
)->value
;
1139 gcc_assert (VAR_P (range_for_decl
[i
])
1140 && DECL_ARTIFICIAL (range_for_decl
[i
]));
1144 add_stmt (do_poplevel (scope
));
1146 for (int i
= 0; i
< 3; i
++)
1147 if (range_for_decl
[i
])
1148 DECL_NAME (range_for_decl
[i
])
1149 = cp_global_trees
[CPTI_FOR_RANGE_IDENTIFIER
+ i
];
1152 /* Begin a range-for-statement. Returns a new RANGE_FOR_STMT.
1153 SCOPE and INIT should be the return of begin_for_scope,
1155 To finish it call finish_for_stmt(). */
1158 begin_range_for_stmt (tree scope
, tree init
)
1160 begin_maybe_infinite_loop (boolean_false_node
);
1162 tree r
= build_stmt (input_location
, RANGE_FOR_STMT
, NULL_TREE
, NULL_TREE
,
1163 NULL_TREE
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
1165 if (scope
== NULL_TREE
)
1168 scope
= begin_for_scope (&init
);
1171 /* Since C++20, RANGE_FOR_STMTs can use the init tree, so save it. */
1172 RANGE_FOR_INIT_STMT (r
) = init
;
1173 RANGE_FOR_SCOPE (r
) = scope
;
1178 /* Finish the head of a range-based for statement, which may
1179 be given by RANGE_FOR_STMT. DECL must be the declaration
1180 and EXPR must be the loop expression. */
1183 finish_range_for_decl (tree range_for_stmt
, tree decl
, tree expr
)
1185 if (processing_template_decl
)
1186 RANGE_FOR_INIT_STMT (range_for_stmt
)
1187 = pop_stmt_list (RANGE_FOR_INIT_STMT (range_for_stmt
));
1188 RANGE_FOR_DECL (range_for_stmt
) = decl
;
1189 RANGE_FOR_EXPR (range_for_stmt
) = expr
;
1190 add_stmt (range_for_stmt
);
1191 RANGE_FOR_BODY (range_for_stmt
) = do_pushlevel (sk_block
);
1194 /* Finish a break-statement. */
1197 finish_break_stmt (void)
1199 /* In switch statements break is sometimes stylistically used after
1200 a return statement. This can lead to spurious warnings about
1201 control reaching the end of a non-void function when it is
1202 inlined. Note that we are calling block_may_fallthru with
1203 language specific tree nodes; this works because
1204 block_may_fallthru returns true when given something it does not
1206 if (!block_may_fallthru (cur_stmt_list
))
1209 return add_stmt (build_stmt (input_location
, BREAK_STMT
));
1212 /* Finish a continue-statement. */
1215 finish_continue_stmt (void)
1217 return add_stmt (build_stmt (input_location
, CONTINUE_STMT
));
1220 /* Begin a switch-statement. Returns a new SWITCH_STMT if
1224 begin_switch_stmt (void)
1228 scope
= do_pushlevel (sk_cond
);
1229 r
= build_stmt (input_location
, SWITCH_STMT
, NULL_TREE
, NULL_TREE
, NULL_TREE
, scope
);
1231 begin_cond (&SWITCH_STMT_COND (r
));
1236 /* Finish the cond of a switch-statement. */
1239 finish_switch_cond (tree cond
, tree switch_stmt
)
1241 tree orig_type
= NULL
;
1243 if (!processing_template_decl
)
1245 /* Convert the condition to an integer or enumeration type. */
1246 tree orig_cond
= cond
;
1247 cond
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
, cond
, true);
1248 if (cond
== NULL_TREE
)
1250 error_at (cp_expr_loc_or_input_loc (orig_cond
),
1251 "switch quantity not an integer");
1252 cond
= error_mark_node
;
1254 /* We want unlowered type here to handle enum bit-fields. */
1255 orig_type
= unlowered_expr_type (cond
);
1256 if (TREE_CODE (orig_type
) != ENUMERAL_TYPE
)
1257 orig_type
= TREE_TYPE (cond
);
1258 if (cond
!= error_mark_node
)
1262 Integral promotions are performed. */
1263 cond
= perform_integral_promotions (cond
);
1264 cond
= maybe_cleanup_point_expr (cond
);
1267 if (check_for_bare_parameter_packs (cond
))
1268 cond
= error_mark_node
;
1269 else if (!processing_template_decl
&& warn_sequence_point
)
1270 verify_sequence_points (cond
);
1272 finish_cond (&SWITCH_STMT_COND (switch_stmt
), cond
);
1273 SWITCH_STMT_TYPE (switch_stmt
) = orig_type
;
1274 add_stmt (switch_stmt
);
1275 push_switch (switch_stmt
);
1276 SWITCH_STMT_BODY (switch_stmt
) = push_stmt_list ();
1279 /* Finish the body of a switch-statement, which may be given by
1280 SWITCH_STMT. The COND to switch on is indicated. */
1283 finish_switch_stmt (tree switch_stmt
)
1287 SWITCH_STMT_BODY (switch_stmt
) =
1288 pop_stmt_list (SWITCH_STMT_BODY (switch_stmt
));
1291 scope
= SWITCH_STMT_SCOPE (switch_stmt
);
1292 SWITCH_STMT_SCOPE (switch_stmt
) = NULL
;
1293 add_stmt (do_poplevel (scope
));
1296 /* Begin a try-block. Returns a newly-created TRY_BLOCK if
1300 begin_try_block (void)
1302 tree r
= build_stmt (input_location
, TRY_BLOCK
, NULL_TREE
, NULL_TREE
);
1304 TRY_STMTS (r
) = push_stmt_list ();
1308 /* Likewise, for a function-try-block. The block returned in
1309 *COMPOUND_STMT is an artificial outer scope, containing the
1310 function-try-block. */
1313 begin_function_try_block (tree
*compound_stmt
)
1316 /* This outer scope does not exist in the C++ standard, but we need
1317 a place to put __FUNCTION__ and similar variables. */
1318 *compound_stmt
= begin_compound_stmt (0);
1319 r
= begin_try_block ();
1320 FN_TRY_BLOCK_P (r
) = 1;
1324 /* Finish a try-block, which may be given by TRY_BLOCK. */
1327 finish_try_block (tree try_block
)
1329 TRY_STMTS (try_block
) = pop_stmt_list (TRY_STMTS (try_block
));
1330 TRY_HANDLERS (try_block
) = push_stmt_list ();
1333 /* Finish the body of a cleanup try-block, which may be given by
1337 finish_cleanup_try_block (tree try_block
)
1339 TRY_STMTS (try_block
) = pop_stmt_list (TRY_STMTS (try_block
));
1342 /* Finish an implicitly generated try-block, with a cleanup is given
1346 finish_cleanup (tree cleanup
, tree try_block
)
1348 TRY_HANDLERS (try_block
) = cleanup
;
1349 CLEANUP_P (try_block
) = 1;
1352 /* Likewise, for a function-try-block. */
1355 finish_function_try_block (tree try_block
)
1357 finish_try_block (try_block
);
1358 /* FIXME : something queer about CTOR_INITIALIZER somehow following
1359 the try block, but moving it inside. */
1360 in_function_try_handler
= 1;
1363 /* Finish a handler-sequence for a try-block, which may be given by
1367 finish_handler_sequence (tree try_block
)
1369 TRY_HANDLERS (try_block
) = pop_stmt_list (TRY_HANDLERS (try_block
));
1370 check_handlers (TRY_HANDLERS (try_block
));
1373 /* Finish the handler-seq for a function-try-block, given by
1374 TRY_BLOCK. COMPOUND_STMT is the outer block created by
1375 begin_function_try_block. */
1378 finish_function_handler_sequence (tree try_block
, tree compound_stmt
)
1380 in_function_try_handler
= 0;
1381 finish_handler_sequence (try_block
);
1382 finish_compound_stmt (compound_stmt
);
1385 /* Begin a handler. Returns a HANDLER if appropriate. */
1388 begin_handler (void)
1392 r
= build_stmt (input_location
, HANDLER
, NULL_TREE
, NULL_TREE
);
1395 /* Create a binding level for the eh_info and the exception object
1397 HANDLER_BODY (r
) = do_pushlevel (sk_catch
);
1402 /* Finish the handler-parameters for a handler, which may be given by
1403 HANDLER. DECL is the declaration for the catch parameter, or NULL
1404 if this is a `catch (...)' clause. */
1407 finish_handler_parms (tree decl
, tree handler
)
1409 tree type
= NULL_TREE
;
1410 if (processing_template_decl
)
1414 decl
= pushdecl (decl
);
1415 decl
= push_template_decl (decl
);
1416 HANDLER_PARMS (handler
) = decl
;
1417 type
= TREE_TYPE (decl
);
1422 type
= expand_start_catch_block (decl
);
1423 if (warn_catch_value
1424 && type
!= NULL_TREE
1425 && type
!= error_mark_node
1426 && !TYPE_REF_P (TREE_TYPE (decl
)))
1428 tree orig_type
= TREE_TYPE (decl
);
1429 if (CLASS_TYPE_P (orig_type
))
1431 if (TYPE_POLYMORPHIC_P (orig_type
))
1432 warning (OPT_Wcatch_value_
,
1433 "catching polymorphic type %q#T by value", orig_type
);
1434 else if (warn_catch_value
> 1)
1435 warning (OPT_Wcatch_value_
,
1436 "catching type %q#T by value", orig_type
);
1438 else if (warn_catch_value
> 2)
1439 warning (OPT_Wcatch_value_
,
1440 "catching non-reference type %q#T", orig_type
);
1443 HANDLER_TYPE (handler
) = type
;
1446 /* Finish a handler, which may be given by HANDLER. The BLOCKs are
1447 the return value from the matching call to finish_handler_parms. */
1450 finish_handler (tree handler
)
1452 if (!processing_template_decl
)
1453 expand_end_catch_block ();
1454 HANDLER_BODY (handler
) = do_poplevel (HANDLER_BODY (handler
));
1457 /* Begin a compound statement. FLAGS contains some bits that control the
1458 behavior and context. If BCS_NO_SCOPE is set, the compound statement
1459 does not define a scope. If BCS_FN_BODY is set, this is the outermost
1460 block of a function. If BCS_TRY_BLOCK is set, this is the block
1461 created on behalf of a TRY statement. Returns a token to be passed to
1462 finish_compound_stmt. */
1465 begin_compound_stmt (unsigned int flags
)
1469 if (flags
& BCS_NO_SCOPE
)
1471 r
= push_stmt_list ();
1472 STATEMENT_LIST_NO_SCOPE (r
) = 1;
1474 /* Normally, we try hard to keep the BLOCK for a statement-expression.
1475 But, if it's a statement-expression with a scopeless block, there's
1476 nothing to keep, and we don't want to accidentally keep a block
1477 *inside* the scopeless block. */
1478 keep_next_level (false);
1482 scope_kind sk
= sk_block
;
1483 if (flags
& BCS_TRY_BLOCK
)
1485 else if (flags
& BCS_TRANSACTION
)
1486 sk
= sk_transaction
;
1487 r
= do_pushlevel (sk
);
1490 /* When processing a template, we need to remember where the braces were,
1491 so that we can set up identical scopes when instantiating the template
1492 later. BIND_EXPR is a handy candidate for this.
1493 Note that do_poplevel won't create a BIND_EXPR itself here (and thus
1494 result in nested BIND_EXPRs), since we don't build BLOCK nodes when
1495 processing templates. */
1496 if (processing_template_decl
)
1498 r
= build3 (BIND_EXPR
, NULL
, NULL
, r
, NULL
);
1499 BIND_EXPR_TRY_BLOCK (r
) = (flags
& BCS_TRY_BLOCK
) != 0;
1500 BIND_EXPR_BODY_BLOCK (r
) = (flags
& BCS_FN_BODY
) != 0;
1501 TREE_SIDE_EFFECTS (r
) = 1;
1507 /* Finish a compound-statement, which is given by STMT. */
1510 finish_compound_stmt (tree stmt
)
1512 if (TREE_CODE (stmt
) == BIND_EXPR
)
1514 tree body
= do_poplevel (BIND_EXPR_BODY (stmt
));
1515 /* If the STATEMENT_LIST is empty and this BIND_EXPR isn't special,
1516 discard the BIND_EXPR so it can be merged with the containing
1518 if (TREE_CODE (body
) == STATEMENT_LIST
1519 && STATEMENT_LIST_HEAD (body
) == NULL
1520 && !BIND_EXPR_BODY_BLOCK (stmt
)
1521 && !BIND_EXPR_TRY_BLOCK (stmt
))
1524 BIND_EXPR_BODY (stmt
) = body
;
1526 else if (STATEMENT_LIST_NO_SCOPE (stmt
))
1527 stmt
= pop_stmt_list (stmt
);
1530 /* Destroy any ObjC "super" receivers that may have been
1532 objc_clear_super_receiver ();
1534 stmt
= do_poplevel (stmt
);
1537 /* ??? See c_end_compound_stmt wrt statement expressions. */
1541 /* Finish an asm-statement, whose components are a STRING, some
1542 OUTPUT_OPERANDS, some INPUT_OPERANDS, some CLOBBERS and some
1543 LABELS. Also note whether the asm-statement should be
1544 considered volatile, and whether it is asm inline. */
1547 finish_asm_stmt (location_t loc
, int volatile_p
, tree string
,
1548 tree output_operands
, tree input_operands
, tree clobbers
,
1549 tree labels
, bool inline_p
)
1553 int ninputs
= list_length (input_operands
);
1554 int noutputs
= list_length (output_operands
);
1556 if (!processing_template_decl
)
1558 const char *constraint
;
1559 const char **oconstraints
;
1560 bool allows_mem
, allows_reg
, is_inout
;
1564 oconstraints
= XALLOCAVEC (const char *, noutputs
);
1566 string
= resolve_asm_operand_names (string
, output_operands
,
1567 input_operands
, labels
);
1569 for (i
= 0, t
= output_operands
; t
; t
= TREE_CHAIN (t
), ++i
)
1571 operand
= TREE_VALUE (t
);
1573 /* ??? Really, this should not be here. Users should be using a
1574 proper lvalue, dammit. But there's a long history of using
1575 casts in the output operands. In cases like longlong.h, this
1576 becomes a primitive form of typechecking -- if the cast can be
1577 removed, then the output operand had a type of the proper width;
1578 otherwise we'll get an error. Gross, but ... */
1579 STRIP_NOPS (operand
);
1581 operand
= mark_lvalue_use (operand
);
1583 if (!lvalue_or_else (operand
, lv_asm
, tf_warning_or_error
))
1584 operand
= error_mark_node
;
1586 if (operand
!= error_mark_node
1587 && (TREE_READONLY (operand
)
1588 || CP_TYPE_CONST_P (TREE_TYPE (operand
))
1589 /* Functions are not modifiable, even though they are
1591 || FUNC_OR_METHOD_TYPE_P (TREE_TYPE (operand
))
1592 /* If it's an aggregate and any field is const, then it is
1593 effectively const. */
1594 || (CLASS_TYPE_P (TREE_TYPE (operand
))
1595 && C_TYPE_FIELDS_READONLY (TREE_TYPE (operand
)))))
1596 cxx_readonly_error (loc
, operand
, lv_asm
);
1598 tree
*op
= &operand
;
1599 while (TREE_CODE (*op
) == COMPOUND_EXPR
)
1600 op
= &TREE_OPERAND (*op
, 1);
1601 switch (TREE_CODE (*op
))
1603 case PREINCREMENT_EXPR
:
1604 case PREDECREMENT_EXPR
:
1606 *op
= genericize_compound_lvalue (*op
);
1607 op
= &TREE_OPERAND (*op
, 1);
1613 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
1614 oconstraints
[i
] = constraint
;
1616 if (parse_output_constraint (&constraint
, i
, ninputs
, noutputs
,
1617 &allows_mem
, &allows_reg
, &is_inout
))
1619 /* If the operand is going to end up in memory,
1620 mark it addressable. */
1621 if (!allows_reg
&& !cxx_mark_addressable (*op
))
1622 operand
= error_mark_node
;
1625 operand
= error_mark_node
;
1627 TREE_VALUE (t
) = operand
;
1630 for (i
= 0, t
= input_operands
; t
; ++i
, t
= TREE_CHAIN (t
))
1632 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
1633 bool constraint_parsed
1634 = parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, 0,
1635 oconstraints
, &allows_mem
, &allows_reg
);
1636 /* If the operand is going to end up in memory, don't call
1637 decay_conversion. */
1638 if (constraint_parsed
&& !allows_reg
&& allows_mem
)
1639 operand
= mark_lvalue_use (TREE_VALUE (t
));
1641 operand
= decay_conversion (TREE_VALUE (t
), tf_warning_or_error
);
1643 /* If the type of the operand hasn't been determined (e.g.,
1644 because it involves an overloaded function), then issue
1645 an error message. There's no context available to
1646 resolve the overloading. */
1647 if (TREE_TYPE (operand
) == unknown_type_node
)
1650 "type of %<asm%> operand %qE could not be determined",
1652 operand
= error_mark_node
;
1655 if (constraint_parsed
)
1657 /* If the operand is going to end up in memory,
1658 mark it addressable. */
1659 if (!allows_reg
&& allows_mem
)
1661 /* Strip the nops as we allow this case. FIXME, this really
1662 should be rejected or made deprecated. */
1663 STRIP_NOPS (operand
);
1665 tree
*op
= &operand
;
1666 while (TREE_CODE (*op
) == COMPOUND_EXPR
)
1667 op
= &TREE_OPERAND (*op
, 1);
1668 switch (TREE_CODE (*op
))
1670 case PREINCREMENT_EXPR
:
1671 case PREDECREMENT_EXPR
:
1673 *op
= genericize_compound_lvalue (*op
);
1674 op
= &TREE_OPERAND (*op
, 1);
1680 if (!cxx_mark_addressable (*op
))
1681 operand
= error_mark_node
;
1683 else if (!allows_reg
&& !allows_mem
)
1685 /* If constraint allows neither register nor memory,
1686 try harder to get a constant. */
1687 tree constop
= maybe_constant_value (operand
);
1688 if (TREE_CONSTANT (constop
))
1693 operand
= error_mark_node
;
1695 TREE_VALUE (t
) = operand
;
1699 r
= build_stmt (loc
, ASM_EXPR
, string
,
1700 output_operands
, input_operands
,
1702 ASM_VOLATILE_P (r
) = volatile_p
|| noutputs
== 0;
1703 ASM_INLINE_P (r
) = inline_p
;
1704 r
= maybe_cleanup_point_expr_void (r
);
1705 return add_stmt (r
);
1708 /* Finish a label with the indicated NAME. Returns the new label. */
1711 finish_label_stmt (tree name
)
1713 tree decl
= define_label (input_location
, name
);
1715 if (decl
== error_mark_node
)
1716 return error_mark_node
;
1718 add_stmt (build_stmt (input_location
, LABEL_EXPR
, decl
));
1723 /* Finish a series of declarations for local labels. G++ allows users
1724 to declare "local" labels, i.e., labels with scope. This extension
1725 is useful when writing code involving statement-expressions. */
1728 finish_label_decl (tree name
)
1730 if (!at_function_scope_p ())
1732 error ("%<__label__%> declarations are only allowed in function scopes");
1736 add_decl_expr (declare_local_label (name
));
1739 /* When DECL goes out of scope, make sure that CLEANUP is executed. */
1742 finish_decl_cleanup (tree decl
, tree cleanup
)
1744 push_cleanup (decl
, cleanup
, false);
1747 /* If the current scope exits with an exception, run CLEANUP. */
1750 finish_eh_cleanup (tree cleanup
)
1752 push_cleanup (NULL
, cleanup
, true);
1755 /* The MEM_INITS is a list of mem-initializers, in reverse of the
1756 order they were written by the user. Each node is as for
1757 emit_mem_initializers. */
1760 finish_mem_initializers (tree mem_inits
)
1762 /* Reorder the MEM_INITS so that they are in the order they appeared
1763 in the source program. */
1764 mem_inits
= nreverse (mem_inits
);
1766 if (processing_template_decl
)
1770 for (mem
= mem_inits
; mem
; mem
= TREE_CHAIN (mem
))
1772 /* If the TREE_PURPOSE is a TYPE_PACK_EXPANSION, skip the
1773 check for bare parameter packs in the TREE_VALUE, because
1774 any parameter packs in the TREE_VALUE have already been
1775 bound as part of the TREE_PURPOSE. See
1776 make_pack_expansion for more information. */
1777 if (TREE_CODE (TREE_PURPOSE (mem
)) != TYPE_PACK_EXPANSION
1778 && check_for_bare_parameter_packs (TREE_VALUE (mem
)))
1779 TREE_VALUE (mem
) = error_mark_node
;
1782 add_stmt (build_min_nt_loc (UNKNOWN_LOCATION
,
1783 CTOR_INITIALIZER
, mem_inits
));
1786 emit_mem_initializers (mem_inits
);
1789 /* Obfuscate EXPR if it looks like an id-expression or member access so
1790 that the call to finish_decltype in do_auto_deduction will give the
1791 right result. If EVEN_UNEVAL, do this even in unevaluated context. */
1794 force_paren_expr (tree expr
, bool even_uneval
)
1796 /* This is only needed for decltype(auto) in C++14. */
1797 if (cxx_dialect
< cxx14
)
1800 /* If we're in unevaluated context, we can't be deducing a
1801 return/initializer type, so we don't need to mess with this. */
1802 if (cp_unevaluated_operand
&& !even_uneval
)
1805 if (!DECL_P (tree_strip_any_location_wrapper (expr
))
1806 && TREE_CODE (expr
) != COMPONENT_REF
1807 && TREE_CODE (expr
) != SCOPE_REF
)
1810 location_t loc
= cp_expr_location (expr
);
1812 if (TREE_CODE (expr
) == COMPONENT_REF
1813 || TREE_CODE (expr
) == SCOPE_REF
)
1814 REF_PARENTHESIZED_P (expr
) = true;
1815 else if (processing_template_decl
)
1816 expr
= build1_loc (loc
, PAREN_EXPR
, TREE_TYPE (expr
), expr
);
1819 expr
= build1_loc (loc
, VIEW_CONVERT_EXPR
, TREE_TYPE (expr
), expr
);
1820 REF_PARENTHESIZED_P (expr
) = true;
1826 /* If T is an id-expression obfuscated by force_paren_expr, undo the
1827 obfuscation and return the underlying id-expression. Otherwise
1831 maybe_undo_parenthesized_ref (tree t
)
1833 if (cxx_dialect
< cxx14
)
1836 if (INDIRECT_REF_P (t
) && REF_PARENTHESIZED_P (t
))
1838 t
= TREE_OPERAND (t
, 0);
1839 while (TREE_CODE (t
) == NON_LVALUE_EXPR
1840 || TREE_CODE (t
) == NOP_EXPR
)
1841 t
= TREE_OPERAND (t
, 0);
1843 gcc_assert (TREE_CODE (t
) == ADDR_EXPR
1844 || TREE_CODE (t
) == STATIC_CAST_EXPR
);
1845 t
= TREE_OPERAND (t
, 0);
1847 else if (TREE_CODE (t
) == PAREN_EXPR
)
1848 t
= TREE_OPERAND (t
, 0);
1849 else if (TREE_CODE (t
) == VIEW_CONVERT_EXPR
1850 && REF_PARENTHESIZED_P (t
))
1851 t
= TREE_OPERAND (t
, 0);
1856 /* Finish a parenthesized expression EXPR. */
1859 finish_parenthesized_expr (cp_expr expr
)
1862 /* This inhibits warnings in c_common_truthvalue_conversion. */
1863 TREE_NO_WARNING (expr
) = 1;
1865 if (TREE_CODE (expr
) == OFFSET_REF
1866 || TREE_CODE (expr
) == SCOPE_REF
)
1867 /* [expr.unary.op]/3 The qualified id of a pointer-to-member must not be
1868 enclosed in parentheses. */
1869 PTRMEM_OK_P (expr
) = 0;
1871 tree stripped_expr
= tree_strip_any_location_wrapper (expr
);
1872 if (TREE_CODE (stripped_expr
) == STRING_CST
)
1873 PAREN_STRING_LITERAL_P (stripped_expr
) = 1;
1875 expr
= cp_expr (force_paren_expr (expr
), expr
.get_location ());
1880 /* Finish a reference to a non-static data member (DECL) that is not
1881 preceded by `.' or `->'. */
1884 finish_non_static_data_member (tree decl
, tree object
, tree qualifying_scope
)
1886 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
);
1887 bool try_omp_private
= !object
&& omp_private_member_map
;
1892 tree scope
= qualifying_scope
;
1893 if (scope
== NULL_TREE
)
1895 scope
= context_for_name_lookup (decl
);
1896 if (!TYPE_P (scope
))
1898 /* Can happen during error recovery (c++/85014). */
1899 gcc_assert (seen_error ());
1900 return error_mark_node
;
1903 object
= maybe_dummy_object (scope
, NULL
);
1906 object
= maybe_resolve_dummy (object
, true);
1907 if (object
== error_mark_node
)
1908 return error_mark_node
;
1910 /* DR 613/850: Can use non-static data members without an associated
1911 object in sizeof/decltype/alignof. */
1912 if (is_dummy_object (object
) && cp_unevaluated_operand
== 0
1913 && (!processing_template_decl
|| !current_class_ref
))
1915 if (current_function_decl
1916 && DECL_STATIC_FUNCTION_P (current_function_decl
))
1917 error ("invalid use of member %qD in static member function", decl
);
1919 error ("invalid use of non-static data member %qD", decl
);
1920 inform (DECL_SOURCE_LOCATION (decl
), "declared here");
1922 return error_mark_node
;
1925 if (current_class_ptr
)
1926 TREE_USED (current_class_ptr
) = 1;
1927 if (processing_template_decl
)
1929 tree type
= TREE_TYPE (decl
);
1931 if (TYPE_REF_P (type
))
1932 /* Quals on the object don't matter. */;
1933 else if (PACK_EXPANSION_P (type
))
1934 /* Don't bother trying to represent this. */
1938 /* Set the cv qualifiers. */
1939 int quals
= cp_type_quals (TREE_TYPE (object
));
1941 if (DECL_MUTABLE_P (decl
))
1942 quals
&= ~TYPE_QUAL_CONST
;
1944 quals
|= cp_type_quals (TREE_TYPE (decl
));
1945 type
= cp_build_qualified_type (type
, quals
);
1948 if (qualifying_scope
)
1949 /* Wrap this in a SCOPE_REF for now. */
1950 ret
= build_qualified_name (type
, qualifying_scope
, decl
,
1951 /*template_p=*/false);
1953 ret
= (convert_from_reference
1954 (build_min (COMPONENT_REF
, type
, object
, decl
, NULL_TREE
)));
1956 /* If PROCESSING_TEMPLATE_DECL is nonzero here, then
1957 QUALIFYING_SCOPE is also non-null. */
1960 tree access_type
= TREE_TYPE (object
);
1962 perform_or_defer_access_check (TYPE_BINFO (access_type
), decl
,
1963 decl
, tf_warning_or_error
);
1965 /* If the data member was named `C::M', convert `*this' to `C'
1967 if (qualifying_scope
)
1969 tree binfo
= NULL_TREE
;
1970 object
= build_scoped_ref (object
, qualifying_scope
,
1974 ret
= build_class_member_access_expr (object
, decl
,
1975 /*access_path=*/NULL_TREE
,
1976 /*preserve_reference=*/false,
1977 tf_warning_or_error
);
1979 if (try_omp_private
)
1981 tree
*v
= omp_private_member_map
->get (decl
);
1983 ret
= convert_from_reference (*v
);
1988 /* If we are currently parsing a template and we encountered a typedef
1989 TYPEDEF_DECL that is being accessed though CONTEXT, this function
1990 adds the typedef to a list tied to the current template.
1991 At template instantiation time, that list is walked and access check
1992 performed for each typedef.
1993 LOCATION is the location of the usage point of TYPEDEF_DECL. */
1996 add_typedef_to_current_template_for_access_check (tree typedef_decl
,
1998 location_t location
)
2000 tree template_info
= NULL
;
2001 tree cs
= current_scope ();
2003 if (!is_typedef_decl (typedef_decl
)
2005 || !CLASS_TYPE_P (context
)
2009 if (CLASS_TYPE_P (cs
) || TREE_CODE (cs
) == FUNCTION_DECL
)
2010 template_info
= get_template_info (cs
);
2013 && TI_TEMPLATE (template_info
)
2014 && !currently_open_class (context
))
2015 append_type_to_template_for_access_check (cs
, typedef_decl
,
2019 /* DECL was the declaration to which a qualified-id resolved. Issue
2020 an error message if it is not accessible. If OBJECT_TYPE is
2021 non-NULL, we have just seen `x->' or `x.' and OBJECT_TYPE is the
2022 type of `*x', or `x', respectively. If the DECL was named as
2023 `A::B' then NESTED_NAME_SPECIFIER is `A'. */
2026 check_accessibility_of_qualified_id (tree decl
,
2028 tree nested_name_specifier
)
2031 tree qualifying_type
= NULL_TREE
;
2033 /* If we are parsing a template declaration and if decl is a typedef,
2034 add it to a list tied to the template.
2035 At template instantiation time, that list will be walked and
2036 access check performed. */
2037 add_typedef_to_current_template_for_access_check (decl
,
2038 nested_name_specifier
2039 ? nested_name_specifier
2040 : DECL_CONTEXT (decl
),
2043 /* If we're not checking, return immediately. */
2044 if (deferred_access_no_check
)
2047 /* Determine the SCOPE of DECL. */
2048 scope
= context_for_name_lookup (decl
);
2049 /* If the SCOPE is not a type, then DECL is not a member. */
2050 if (!TYPE_P (scope
))
2052 /* Compute the scope through which DECL is being accessed. */
2054 /* OBJECT_TYPE might not be a class type; consider:
2056 class A { typedef int I; };
2060 In this case, we will have "A::I" as the DECL, but "I" as the
2062 && CLASS_TYPE_P (object_type
)
2063 && DERIVED_FROM_P (scope
, object_type
))
2064 /* If we are processing a `->' or `.' expression, use the type of the
2066 qualifying_type
= object_type
;
2067 else if (nested_name_specifier
)
2069 /* If the reference is to a non-static member of the
2070 current class, treat it as if it were referenced through
2073 if (DECL_NONSTATIC_MEMBER_P (decl
)
2074 && current_class_ptr
2075 && DERIVED_FROM_P (scope
, ct
= current_nonlambda_class_type ()))
2076 qualifying_type
= ct
;
2077 /* Otherwise, use the type indicated by the
2078 nested-name-specifier. */
2080 qualifying_type
= nested_name_specifier
;
2083 /* Otherwise, the name must be from the current class or one of
2085 qualifying_type
= currently_open_derived_class (scope
);
2088 /* It is possible for qualifying type to be a TEMPLATE_TYPE_PARM
2089 or similar in a default argument value. */
2090 && CLASS_TYPE_P (qualifying_type
)
2091 && !dependent_type_p (qualifying_type
))
2092 perform_or_defer_access_check (TYPE_BINFO (qualifying_type
), decl
,
2093 decl
, tf_warning_or_error
);
2096 /* EXPR is the result of a qualified-id. The QUALIFYING_CLASS was the
2097 class named to the left of the "::" operator. DONE is true if this
2098 expression is a complete postfix-expression; it is false if this
2099 expression is followed by '->', '[', '(', etc. ADDRESS_P is true
2100 iff this expression is the operand of '&'. TEMPLATE_P is true iff
2101 the qualified-id was of the form "A::template B". TEMPLATE_ARG_P
2102 is true iff this qualified name appears as a template argument. */
2105 finish_qualified_id_expr (tree qualifying_class
,
2110 bool template_arg_p
,
2111 tsubst_flags_t complain
)
2113 gcc_assert (TYPE_P (qualifying_class
));
2115 if (error_operand_p (expr
))
2116 return error_mark_node
;
2118 if ((DECL_P (expr
) || BASELINK_P (expr
))
2119 && !mark_used (expr
, complain
))
2120 return error_mark_node
;
2124 if (TREE_CODE (expr
) == UNBOUND_CLASS_TEMPLATE
)
2126 /* cp_parser_lookup_name thought we were looking for a type,
2127 but we're actually looking for a declaration. */
2128 qualifying_class
= TYPE_CONTEXT (expr
);
2129 expr
= TYPE_IDENTIFIER (expr
);
2132 check_template_keyword (expr
);
2135 /* If EXPR occurs as the operand of '&', use special handling that
2136 permits a pointer-to-member. */
2137 if (address_p
&& done
)
2139 if (TREE_CODE (expr
) == SCOPE_REF
)
2140 expr
= TREE_OPERAND (expr
, 1);
2141 expr
= build_offset_ref (qualifying_class
, expr
,
2142 /*address_p=*/true, complain
);
2146 /* No need to check access within an enum. */
2147 if (TREE_CODE (qualifying_class
) == ENUMERAL_TYPE
2148 && TREE_CODE (expr
) != IDENTIFIER_NODE
)
2151 /* Within the scope of a class, turn references to non-static
2152 members into expression of the form "this->...". */
2154 /* But, within a template argument, we do not want make the
2155 transformation, as there is no "this" pointer. */
2157 else if (TREE_CODE (expr
) == FIELD_DECL
)
2159 push_deferring_access_checks (dk_no_check
);
2160 expr
= finish_non_static_data_member (expr
, NULL_TREE
,
2162 pop_deferring_access_checks ();
2164 else if (BASELINK_P (expr
))
2166 /* See if any of the functions are non-static members. */
2167 /* If so, the expression may be relative to 'this'. */
2168 if ((type_dependent_expression_p (expr
)
2169 || !shared_member_p (expr
))
2170 && current_class_ptr
2171 && DERIVED_FROM_P (qualifying_class
,
2172 current_nonlambda_class_type ()))
2173 expr
= (build_class_member_access_expr
2174 (maybe_dummy_object (qualifying_class
, NULL
),
2176 BASELINK_ACCESS_BINFO (expr
),
2177 /*preserve_reference=*/false,
2180 /* The expression is a qualified name whose address is not
2182 expr
= build_offset_ref (qualifying_class
, expr
, /*address_p=*/false,
2185 else if (!template_p
2186 && TREE_CODE (expr
) == TEMPLATE_DECL
2187 && !DECL_FUNCTION_TEMPLATE_P (expr
))
2189 if (complain
& tf_error
)
2190 error ("%qE missing template arguments", expr
);
2191 return error_mark_node
;
2195 /* In a template, return a SCOPE_REF for most qualified-ids
2196 so that we can check access at instantiation time. But if
2197 we're looking at a member of the current instantiation, we
2198 know we have access and building up the SCOPE_REF confuses
2199 non-type template argument handling. */
2200 if (processing_template_decl
2201 && (!currently_open_class (qualifying_class
)
2202 || TREE_CODE (expr
) == IDENTIFIER_NODE
2203 || TREE_CODE (expr
) == TEMPLATE_ID_EXPR
2204 || TREE_CODE (expr
) == BIT_NOT_EXPR
))
2205 expr
= build_qualified_name (TREE_TYPE (expr
),
2206 qualifying_class
, expr
,
2208 else if (tree wrap
= maybe_get_tls_wrapper_call (expr
))
2211 expr
= convert_from_reference (expr
);
2217 /* Begin a statement-expression. The value returned must be passed to
2218 finish_stmt_expr. */
2221 begin_stmt_expr (void)
2223 return push_stmt_list ();
2226 /* Process the final expression of a statement expression. EXPR can be
2227 NULL, if the final expression is empty. Return a STATEMENT_LIST
2228 containing all the statements in the statement-expression, or
2229 ERROR_MARK_NODE if there was an error. */
2232 finish_stmt_expr_expr (tree expr
, tree stmt_expr
)
2234 if (error_operand_p (expr
))
2236 /* The type of the statement-expression is the type of the last
2238 TREE_TYPE (stmt_expr
) = error_mark_node
;
2239 return error_mark_node
;
2242 /* If the last statement does not have "void" type, then the value
2243 of the last statement is the value of the entire expression. */
2246 tree type
= TREE_TYPE (expr
);
2248 if (type
&& type_unknown_p (type
))
2250 error ("a statement expression is an insufficient context"
2251 " for overload resolution");
2252 TREE_TYPE (stmt_expr
) = error_mark_node
;
2253 return error_mark_node
;
2255 else if (processing_template_decl
)
2257 expr
= build_stmt (input_location
, EXPR_STMT
, expr
);
2258 expr
= add_stmt (expr
);
2259 /* Mark the last statement so that we can recognize it as such at
2260 template-instantiation time. */
2261 EXPR_STMT_STMT_EXPR_RESULT (expr
) = 1;
2263 else if (VOID_TYPE_P (type
))
2265 /* Just treat this like an ordinary statement. */
2266 expr
= finish_expr_stmt (expr
);
2270 /* It actually has a value we need to deal with. First, force it
2271 to be an rvalue so that we won't need to build up a copy
2272 constructor call later when we try to assign it to something. */
2273 expr
= force_rvalue (expr
, tf_warning_or_error
);
2274 if (error_operand_p (expr
))
2275 return error_mark_node
;
2277 /* Update for array-to-pointer decay. */
2278 type
= TREE_TYPE (expr
);
2280 /* Wrap it in a CLEANUP_POINT_EXPR and add it to the list like a
2281 normal statement, but don't convert to void or actually add
2283 if (TREE_CODE (expr
) != CLEANUP_POINT_EXPR
)
2284 expr
= maybe_cleanup_point_expr (expr
);
2288 /* The type of the statement-expression is the type of the last
2290 TREE_TYPE (stmt_expr
) = type
;
2296 /* Finish a statement-expression. EXPR should be the value returned
2297 by the previous begin_stmt_expr. Returns an expression
2298 representing the statement-expression. */
2301 finish_stmt_expr (tree stmt_expr
, bool has_no_scope
)
2306 if (error_operand_p (stmt_expr
))
2308 pop_stmt_list (stmt_expr
);
2309 return error_mark_node
;
2312 gcc_assert (TREE_CODE (stmt_expr
) == STATEMENT_LIST
);
2314 type
= TREE_TYPE (stmt_expr
);
2315 result
= pop_stmt_list (stmt_expr
);
2316 TREE_TYPE (result
) = type
;
2318 if (processing_template_decl
)
2320 result
= build_min (STMT_EXPR
, type
, result
);
2321 TREE_SIDE_EFFECTS (result
) = 1;
2322 STMT_EXPR_NO_SCOPE (result
) = has_no_scope
;
2324 else if (CLASS_TYPE_P (type
))
2326 /* Wrap the statement-expression in a TARGET_EXPR so that the
2327 temporary object created by the final expression is destroyed at
2328 the end of the full-expression containing the
2329 statement-expression. */
2330 result
= force_target_expr (type
, result
, tf_warning_or_error
);
2336 /* Returns the expression which provides the value of STMT_EXPR. */
2339 stmt_expr_value_expr (tree stmt_expr
)
2341 tree t
= STMT_EXPR_STMT (stmt_expr
);
2343 if (TREE_CODE (t
) == BIND_EXPR
)
2344 t
= BIND_EXPR_BODY (t
);
2346 if (TREE_CODE (t
) == STATEMENT_LIST
&& STATEMENT_LIST_TAIL (t
))
2347 t
= STATEMENT_LIST_TAIL (t
)->stmt
;
2349 if (TREE_CODE (t
) == EXPR_STMT
)
2350 t
= EXPR_STMT_EXPR (t
);
2355 /* Return TRUE iff EXPR_STMT is an empty list of
2356 expression statements. */
2359 empty_expr_stmt_p (tree expr_stmt
)
2361 tree body
= NULL_TREE
;
2363 if (expr_stmt
== void_node
)
2368 if (TREE_CODE (expr_stmt
) == EXPR_STMT
)
2369 body
= EXPR_STMT_EXPR (expr_stmt
);
2370 else if (TREE_CODE (expr_stmt
) == STATEMENT_LIST
)
2376 if (TREE_CODE (body
) == STATEMENT_LIST
)
2377 return tsi_end_p (tsi_start (body
));
2379 return empty_expr_stmt_p (body
);
2384 /* Perform Koenig lookup. FN_EXPR is the postfix-expression representing
2385 the function (or functions) to call; ARGS are the arguments to the
2386 call. Returns the functions to be considered by overload resolution. */
2389 perform_koenig_lookup (cp_expr fn_expr
, vec
<tree
, va_gc
> *args
,
2390 tsubst_flags_t complain
)
2392 tree identifier
= NULL_TREE
;
2393 tree functions
= NULL_TREE
;
2394 tree tmpl_args
= NULL_TREE
;
2395 bool template_id
= false;
2396 location_t loc
= fn_expr
.get_location ();
2397 tree fn
= fn_expr
.get_value ();
2399 STRIP_ANY_LOCATION_WRAPPER (fn
);
2401 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
2403 /* Use a separate flag to handle null args. */
2405 tmpl_args
= TREE_OPERAND (fn
, 1);
2406 fn
= TREE_OPERAND (fn
, 0);
2409 /* Find the name of the overloaded function. */
2410 if (identifier_p (fn
))
2415 identifier
= OVL_NAME (functions
);
2418 /* A call to a namespace-scope function using an unqualified name.
2420 Do Koenig lookup -- unless any of the arguments are
2422 if (!any_type_dependent_arguments_p (args
)
2423 && !any_dependent_template_arguments_p (tmpl_args
))
2425 fn
= lookup_arg_dependent (identifier
, functions
, args
);
2428 /* The unqualified name could not be resolved. */
2429 if (complain
& tf_error
)
2430 fn
= unqualified_fn_lookup_error (cp_expr (identifier
, loc
));
2436 if (fn
&& template_id
&& fn
!= error_mark_node
)
2437 fn
= build2 (TEMPLATE_ID_EXPR
, unknown_type_node
, fn
, tmpl_args
);
2439 return cp_expr (fn
, loc
);
2442 /* Generate an expression for `FN (ARGS)'. This may change the
2445 If DISALLOW_VIRTUAL is true, the call to FN will be not generated
2446 as a virtual call, even if FN is virtual. (This flag is set when
2447 encountering an expression where the function name is explicitly
2448 qualified. For example a call to `X::f' never generates a virtual
2451 Returns code for the call. */
2454 finish_call_expr (tree fn
, vec
<tree
, va_gc
> **args
, bool disallow_virtual
,
2455 bool koenig_p
, tsubst_flags_t complain
)
2459 vec
<tree
, va_gc
> *orig_args
= *args
;
2461 if (fn
== error_mark_node
)
2462 return error_mark_node
;
2464 gcc_assert (!TYPE_P (fn
));
2466 /* If FN may be a FUNCTION_DECL obfuscated by force_paren_expr, undo
2467 it so that we can tell this is a call to a known function. */
2468 fn
= maybe_undo_parenthesized_ref (fn
);
2470 STRIP_ANY_LOCATION_WRAPPER (fn
);
2474 if (processing_template_decl
)
2476 /* If FN is a local extern declaration or set thereof, look them up
2477 again at instantiation time. */
2478 if (is_overloaded_fn (fn
))
2480 tree ifn
= get_first_fn (fn
);
2481 if (TREE_CODE (ifn
) == FUNCTION_DECL
2482 && DECL_LOCAL_FUNCTION_P (ifn
))
2483 orig_fn
= DECL_NAME (ifn
);
2486 /* If the call expression is dependent, build a CALL_EXPR node
2487 with no type; type_dependent_expression_p recognizes
2488 expressions with no type as being dependent. */
2489 if (type_dependent_expression_p (fn
)
2490 || any_type_dependent_arguments_p (*args
))
2492 result
= build_min_nt_call_vec (orig_fn
, *args
);
2493 SET_EXPR_LOCATION (result
, cp_expr_loc_or_input_loc (fn
));
2494 KOENIG_LOOKUP_P (result
) = koenig_p
;
2495 if (is_overloaded_fn (fn
))
2500 bool abnormal
= true;
2501 for (lkp_iterator
iter (fn
); abnormal
&& iter
; ++iter
)
2503 tree fndecl
= *iter
;
2504 if (TREE_CODE (fndecl
) != FUNCTION_DECL
2505 || !TREE_THIS_VOLATILE (fndecl
))
2508 /* FIXME: Stop warning about falling off end of non-void
2509 function. But this is wrong. Even if we only see
2510 no-return fns at this point, we could select a
2511 future-defined return fn during instantiation. Or
2514 current_function_returns_abnormally
= 1;
2518 orig_args
= make_tree_vector_copy (*args
);
2519 if (!BASELINK_P (fn
)
2520 && TREE_CODE (fn
) != PSEUDO_DTOR_EXPR
2521 && TREE_TYPE (fn
) != unknown_type_node
)
2522 fn
= build_non_dependent_expr (fn
);
2523 make_args_non_dependent (*args
);
2526 if (TREE_CODE (fn
) == COMPONENT_REF
)
2528 tree member
= TREE_OPERAND (fn
, 1);
2529 if (BASELINK_P (member
))
2531 tree object
= TREE_OPERAND (fn
, 0);
2532 return build_new_method_call (object
, member
,
2535 ? LOOKUP_NORMAL
| LOOKUP_NONVIRTUAL
2542 /* Per 13.3.1.1, '(&f)(...)' is the same as '(f)(...)'. */
2543 if (TREE_CODE (fn
) == ADDR_EXPR
2544 && TREE_CODE (TREE_OPERAND (fn
, 0)) == OVERLOAD
)
2545 fn
= TREE_OPERAND (fn
, 0);
2547 if (is_overloaded_fn (fn
))
2548 fn
= baselink_for_fns (fn
);
2551 if (BASELINK_P (fn
))
2555 /* A call to a member function. From [over.call.func]:
2557 If the keyword this is in scope and refers to the class of
2558 that member function, or a derived class thereof, then the
2559 function call is transformed into a qualified function call
2560 using (*this) as the postfix-expression to the left of the
2561 . operator.... [Otherwise] a contrived object of type T
2562 becomes the implied object argument.
2566 struct A { void f(); };
2567 struct B : public A {};
2568 struct C : public A { void g() { B::f(); }};
2570 "the class of that member function" refers to `A'. But 11.2
2571 [class.access.base] says that we need to convert 'this' to B* as
2572 part of the access, so we pass 'B' to maybe_dummy_object. */
2574 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (get_first_fn (fn
)))
2576 /* A constructor call always uses a dummy object. (This constructor
2577 call which has the form A::A () is actually invalid and we are
2578 going to reject it later in build_new_method_call.) */
2579 object
= build_dummy_object (BINFO_TYPE (BASELINK_ACCESS_BINFO (fn
)));
2582 object
= maybe_dummy_object (BINFO_TYPE (BASELINK_ACCESS_BINFO (fn
)),
2585 result
= build_new_method_call (object
, fn
, args
, NULL_TREE
,
2587 ? LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
2592 else if (concept_check_p (fn
))
2594 /* FN is actually a template-id referring to a concept definition. */
2595 tree id
= unpack_concept_check (fn
);
2596 tree tmpl
= TREE_OPERAND (id
, 0);
2597 tree args
= TREE_OPERAND (id
, 1);
2599 if (!function_concept_p (tmpl
))
2601 error_at (EXPR_LOC_OR_LOC (fn
, input_location
),
2602 "cannot call a concept as a function");
2603 return error_mark_node
;
2606 /* Ensure the result is wrapped as a call expression. */
2607 result
= build_concept_check (tmpl
, args
, tf_warning_or_error
);
2609 else if (is_overloaded_fn (fn
))
2611 /* If the function is an overloaded builtin, resolve it. */
2612 if (TREE_CODE (fn
) == FUNCTION_DECL
2613 && (DECL_BUILT_IN_CLASS (fn
) == BUILT_IN_NORMAL
2614 || DECL_BUILT_IN_CLASS (fn
) == BUILT_IN_MD
))
2615 result
= resolve_overloaded_builtin (input_location
, fn
, *args
);
2619 if (warn_sizeof_pointer_memaccess
2620 && (complain
& tf_warning
)
2621 && !vec_safe_is_empty (*args
)
2622 && !processing_template_decl
)
2624 location_t sizeof_arg_loc
[3];
2627 for (i
= 0; i
< 3; i
++)
2631 sizeof_arg_loc
[i
] = UNKNOWN_LOCATION
;
2632 sizeof_arg
[i
] = NULL_TREE
;
2633 if (i
>= (*args
)->length ())
2636 if (TREE_CODE (t
) != SIZEOF_EXPR
)
2638 if (SIZEOF_EXPR_TYPE_P (t
))
2639 sizeof_arg
[i
] = TREE_TYPE (TREE_OPERAND (t
, 0));
2641 sizeof_arg
[i
] = TREE_OPERAND (t
, 0);
2642 sizeof_arg_loc
[i
] = EXPR_LOCATION (t
);
2644 sizeof_pointer_memaccess_warning
2645 (sizeof_arg_loc
, fn
, *args
,
2646 sizeof_arg
, same_type_ignoring_top_level_qualifiers_p
);
2649 if ((complain
& tf_warning
)
2650 && TREE_CODE (fn
) == FUNCTION_DECL
2651 && fndecl_built_in_p (fn
, BUILT_IN_MEMSET
)
2652 && vec_safe_length (*args
) == 3
2653 && !any_type_dependent_arguments_p (*args
))
2655 tree arg0
= (*orig_args
)[0];
2656 tree arg1
= (*orig_args
)[1];
2657 tree arg2
= (*orig_args
)[2];
2658 int literal_mask
= ((literal_integer_zerop (arg1
) << 1)
2659 | (literal_integer_zerop (arg2
) << 2));
2660 arg2
= instantiate_non_dependent_expr (arg2
);
2661 warn_for_memset (input_location
, arg0
, arg2
, literal_mask
);
2664 /* A call to a namespace-scope function. */
2665 result
= build_new_function_call (fn
, args
, complain
);
2668 else if (TREE_CODE (fn
) == PSEUDO_DTOR_EXPR
)
2670 if (!vec_safe_is_empty (*args
))
2671 error ("arguments to destructor are not allowed");
2672 /* Mark the pseudo-destructor call as having side-effects so
2673 that we do not issue warnings about its use. */
2674 result
= build1 (NOP_EXPR
,
2676 TREE_OPERAND (fn
, 0));
2677 TREE_SIDE_EFFECTS (result
) = 1;
2679 else if (CLASS_TYPE_P (TREE_TYPE (fn
)))
2680 /* If the "function" is really an object of class type, it might
2681 have an overloaded `operator ()'. */
2682 result
= build_op_call (fn
, args
, complain
);
2685 /* A call where the function is unknown. */
2686 result
= cp_build_function_call_vec (fn
, args
, complain
);
2688 if (processing_template_decl
&& result
!= error_mark_node
)
2690 if (INDIRECT_REF_P (result
))
2691 result
= TREE_OPERAND (result
, 0);
2692 result
= build_call_vec (TREE_TYPE (result
), orig_fn
, orig_args
);
2693 SET_EXPR_LOCATION (result
, input_location
);
2694 KOENIG_LOOKUP_P (result
) = koenig_p
;
2695 release_tree_vector (orig_args
);
2696 result
= convert_from_reference (result
);
2702 /* Finish a call to a postfix increment or decrement or EXPR. (Which
2703 is indicated by CODE, which should be POSTINCREMENT_EXPR or
2704 POSTDECREMENT_EXPR.) */
2707 finish_increment_expr (cp_expr expr
, enum tree_code code
)
2709 /* input_location holds the location of the trailing operator token.
2710 Build a location of the form:
2713 with the caret at the operator token, ranging from the start
2714 of EXPR to the end of the operator token. */
2715 location_t combined_loc
= make_location (input_location
,
2717 get_finish (input_location
));
2718 cp_expr result
= build_x_unary_op (combined_loc
, code
, expr
,
2719 tf_warning_or_error
);
2720 /* TODO: build_x_unary_op doesn't honor the location, so set it here. */
2721 result
.set_location (combined_loc
);
2725 /* Finish a use of `this'. Returns an expression for `this'. */
2728 finish_this_expr (void)
2730 tree result
= NULL_TREE
;
2732 if (current_class_ptr
)
2734 tree type
= TREE_TYPE (current_class_ref
);
2736 /* In a lambda expression, 'this' refers to the captured 'this'. */
2737 if (LAMBDA_TYPE_P (type
))
2738 result
= lambda_expr_this_capture (CLASSTYPE_LAMBDA_EXPR (type
), true);
2740 result
= current_class_ptr
;
2744 /* The keyword 'this' is a prvalue expression. */
2745 return rvalue (result
);
2747 tree fn
= current_nonlambda_function ();
2748 if (fn
&& DECL_STATIC_FUNCTION_P (fn
))
2749 error ("%<this%> is unavailable for static member functions");
2751 error ("invalid use of %<this%> in non-member function");
2753 error ("invalid use of %<this%> at top level");
2754 return error_mark_node
;
2757 /* Finish a pseudo-destructor expression. If SCOPE is NULL, the
2758 expression was of the form `OBJECT.~DESTRUCTOR' where DESTRUCTOR is
2759 the TYPE for the type given. If SCOPE is non-NULL, the expression
2760 was of the form `OBJECT.SCOPE::~DESTRUCTOR'. */
2763 finish_pseudo_destructor_expr (tree object
, tree scope
, tree destructor
,
2766 if (object
== error_mark_node
|| destructor
== error_mark_node
)
2767 return error_mark_node
;
2769 gcc_assert (TYPE_P (destructor
));
2771 if (!processing_template_decl
)
2773 if (scope
== error_mark_node
)
2775 error_at (loc
, "invalid qualifying scope in pseudo-destructor name");
2776 return error_mark_node
;
2778 if (is_auto (destructor
))
2779 destructor
= TREE_TYPE (object
);
2780 if (scope
&& TYPE_P (scope
) && !check_dtor_name (scope
, destructor
))
2783 "qualified type %qT does not match destructor name ~%qT",
2785 return error_mark_node
;
2789 /* [expr.pseudo] says both:
2791 The type designated by the pseudo-destructor-name shall be
2792 the same as the object type.
2796 The cv-unqualified versions of the object type and of the
2797 type designated by the pseudo-destructor-name shall be the
2800 We implement the more generous second sentence, since that is
2801 what most other compilers do. */
2802 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (object
),
2805 error_at (loc
, "%qE is not of type %qT", object
, destructor
);
2806 return error_mark_node
;
2810 return build3_loc (loc
, PSEUDO_DTOR_EXPR
, void_type_node
, object
,
2814 /* Finish an expression of the form CODE EXPR. */
2817 finish_unary_op_expr (location_t op_loc
, enum tree_code code
, cp_expr expr
,
2818 tsubst_flags_t complain
)
2820 /* Build a location of the form:
2823 with the caret at the operator token, ranging from the start
2824 of the operator token to the end of EXPR. */
2825 location_t combined_loc
= make_location (op_loc
,
2826 op_loc
, expr
.get_finish ());
2827 cp_expr result
= build_x_unary_op (combined_loc
, code
, expr
, complain
);
2828 /* TODO: build_x_unary_op doesn't always honor the location. */
2829 result
.set_location (combined_loc
);
2831 if (result
== error_mark_node
)
2834 if (!(complain
& tf_warning
))
2837 tree result_ovl
= result
;
2838 tree expr_ovl
= expr
;
2840 if (!processing_template_decl
)
2841 expr_ovl
= cp_fully_fold (expr_ovl
);
2843 if (!CONSTANT_CLASS_P (expr_ovl
)
2844 || TREE_OVERFLOW_P (expr_ovl
))
2847 if (!processing_template_decl
)
2848 result_ovl
= cp_fully_fold (result_ovl
);
2850 if (CONSTANT_CLASS_P (result_ovl
) && TREE_OVERFLOW_P (result_ovl
))
2851 overflow_warning (combined_loc
, result_ovl
);
2856 /* Finish a compound-literal expression or C++11 functional cast with aggregate
2857 initializer. TYPE is the type to which the CONSTRUCTOR in COMPOUND_LITERAL
2861 finish_compound_literal (tree type
, tree compound_literal
,
2862 tsubst_flags_t complain
,
2865 if (type
== error_mark_node
)
2866 return error_mark_node
;
2868 if (TYPE_REF_P (type
))
2871 = finish_compound_literal (TREE_TYPE (type
), compound_literal
,
2872 complain
, fcl_context
);
2873 /* The prvalue is then used to direct-initialize the reference. */
2874 tree r
= (perform_implicit_conversion_flags
2875 (type
, compound_literal
, complain
, LOOKUP_NORMAL
));
2876 return convert_from_reference (r
);
2879 if (!TYPE_OBJ_P (type
))
2881 if (complain
& tf_error
)
2882 error ("compound literal of non-object type %qT", type
);
2883 return error_mark_node
;
2886 if (tree anode
= type_uses_auto (type
))
2887 if (CLASS_PLACEHOLDER_TEMPLATE (anode
))
2889 type
= do_auto_deduction (type
, compound_literal
, anode
, complain
,
2891 if (type
== error_mark_node
)
2892 return error_mark_node
;
2895 /* Used to hold a copy of the compound literal in a template. */
2896 tree orig_cl
= NULL_TREE
;
2898 if (processing_template_decl
)
2900 const bool dependent_p
2901 = (instantiation_dependent_expression_p (compound_literal
)
2902 || dependent_type_p (type
));
2904 /* We're about to return, no need to copy. */
2905 orig_cl
= compound_literal
;
2907 /* We're going to need a copy. */
2908 orig_cl
= unshare_constructor (compound_literal
);
2909 TREE_TYPE (orig_cl
) = type
;
2910 /* Mark the expression as a compound literal. */
2911 TREE_HAS_CONSTRUCTOR (orig_cl
) = 1;
2912 /* And as instantiation-dependent. */
2913 CONSTRUCTOR_IS_DEPENDENT (orig_cl
) = dependent_p
;
2914 if (fcl_context
== fcl_c99
)
2915 CONSTRUCTOR_C99_COMPOUND_LITERAL (orig_cl
) = 1;
2916 /* If the compound literal is dependent, we're done for now. */
2919 /* Otherwise, do go on to e.g. check narrowing. */
2922 type
= complete_type (type
);
2924 if (TYPE_NON_AGGREGATE_CLASS (type
))
2926 /* Trying to deal with a CONSTRUCTOR instead of a TREE_LIST
2927 everywhere that deals with function arguments would be a pain, so
2928 just wrap it in a TREE_LIST. The parser set a flag so we know
2929 that it came from T{} rather than T({}). */
2930 CONSTRUCTOR_IS_DIRECT_INIT (compound_literal
) = 1;
2931 compound_literal
= build_tree_list (NULL_TREE
, compound_literal
);
2932 return build_functional_cast (type
, compound_literal
, complain
);
2935 if (TREE_CODE (type
) == ARRAY_TYPE
2936 && check_array_initializer (NULL_TREE
, type
, compound_literal
))
2937 return error_mark_node
;
2938 compound_literal
= reshape_init (type
, compound_literal
, complain
);
2939 if (SCALAR_TYPE_P (type
)
2940 && !BRACE_ENCLOSED_INITIALIZER_P (compound_literal
))
2942 tree t
= instantiate_non_dependent_expr_sfinae (compound_literal
,
2944 if (!check_narrowing (type
, t
, complain
))
2945 return error_mark_node
;
2947 if (TREE_CODE (type
) == ARRAY_TYPE
2948 && TYPE_DOMAIN (type
) == NULL_TREE
)
2950 cp_complete_array_type_or_error (&type
, compound_literal
,
2952 if (type
== error_mark_node
)
2953 return error_mark_node
;
2955 compound_literal
= digest_init_flags (type
, compound_literal
,
2956 LOOKUP_NORMAL
| LOOKUP_NO_NARROWING
,
2958 if (compound_literal
== error_mark_node
)
2959 return error_mark_node
;
2961 /* If we're in a template, return the original compound literal. */
2964 if (!VECTOR_TYPE_P (type
))
2965 return get_target_expr_sfinae (orig_cl
, complain
);
2970 if (TREE_CODE (compound_literal
) == CONSTRUCTOR
)
2972 TREE_HAS_CONSTRUCTOR (compound_literal
) = true;
2973 if (fcl_context
== fcl_c99
)
2974 CONSTRUCTOR_C99_COMPOUND_LITERAL (compound_literal
) = 1;
2977 /* Put static/constant array temporaries in static variables. */
2978 /* FIXME all C99 compound literals should be variables rather than C++
2979 temporaries, unless they are used as an aggregate initializer. */
2980 if ((!at_function_scope_p () || CP_TYPE_CONST_P (type
))
2981 && fcl_context
== fcl_c99
2982 && TREE_CODE (type
) == ARRAY_TYPE
2983 && !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
2984 && initializer_constant_valid_p (compound_literal
, type
))
2986 tree decl
= create_temporary_var (type
);
2987 DECL_INITIAL (decl
) = compound_literal
;
2988 TREE_STATIC (decl
) = 1;
2989 if (literal_type_p (type
) && CP_TYPE_CONST_NON_VOLATILE_P (type
))
2991 /* 5.19 says that a constant expression can include an
2992 lvalue-rvalue conversion applied to "a glvalue of literal type
2993 that refers to a non-volatile temporary object initialized
2994 with a constant expression". Rather than try to communicate
2995 that this VAR_DECL is a temporary, just mark it constexpr. */
2996 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
2997 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = true;
2998 TREE_CONSTANT (decl
) = true;
3000 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
3001 decl
= pushdecl_top_level (decl
);
3002 DECL_NAME (decl
) = make_anon_name ();
3003 SET_DECL_ASSEMBLER_NAME (decl
, DECL_NAME (decl
));
3004 /* Make sure the destructor is callable. */
3005 tree clean
= cxx_maybe_build_cleanup (decl
, complain
);
3006 if (clean
== error_mark_node
)
3007 return error_mark_node
;
3011 /* Represent other compound literals with TARGET_EXPR so we produce
3012 an lvalue, but can elide copies. */
3013 if (!VECTOR_TYPE_P (type
))
3014 compound_literal
= get_target_expr_sfinae (compound_literal
, complain
);
3016 return compound_literal
;
3019 /* Return the declaration for the function-name variable indicated by
3023 finish_fname (tree id
)
3027 decl
= fname_decl (input_location
, C_RID_CODE (id
), id
);
3028 if (processing_template_decl
&& current_function_decl
3029 && decl
!= error_mark_node
)
3030 decl
= DECL_NAME (decl
);
3034 /* Finish a translation unit. */
3037 finish_translation_unit (void)
3039 /* In case there were missing closebraces,
3040 get us back to the global binding level. */
3042 while (current_namespace
!= global_namespace
)
3045 /* Do file scope __FUNCTION__ et al. */
3046 finish_fname_decls ();
3048 if (scope_chain
->omp_declare_target_attribute
)
3051 error ("%<#pragma omp declare target%> without corresponding "
3052 "%<#pragma omp end declare target%>");
3053 scope_chain
->omp_declare_target_attribute
= 0;
3057 /* Finish a template type parameter, specified as AGGR IDENTIFIER.
3058 Returns the parameter. */
3061 finish_template_type_parm (tree aggr
, tree identifier
)
3063 if (aggr
!= class_type_node
)
3065 permerror (input_location
, "template type parameters must use the keyword %<class%> or %<typename%>");
3066 aggr
= class_type_node
;
3069 return build_tree_list (aggr
, identifier
);
3072 /* Finish a template template parameter, specified as AGGR IDENTIFIER.
3073 Returns the parameter. */
3076 finish_template_template_parm (tree aggr
, tree identifier
)
3078 tree decl
= build_decl (input_location
,
3079 TYPE_DECL
, identifier
, NULL_TREE
);
3081 tree tmpl
= build_lang_decl (TEMPLATE_DECL
, identifier
, NULL_TREE
);
3082 DECL_TEMPLATE_PARMS (tmpl
) = current_template_parms
;
3083 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
3084 DECL_ARTIFICIAL (decl
) = 1;
3086 /* Associate the constraints with the underlying declaration,
3087 not the template. */
3088 tree reqs
= TEMPLATE_PARMS_CONSTRAINTS (current_template_parms
);
3089 tree constr
= build_constraints (reqs
, NULL_TREE
);
3090 set_constraints (decl
, constr
);
3092 end_template_decl ();
3094 gcc_assert (DECL_TEMPLATE_PARMS (tmpl
));
3096 check_default_tmpl_args (decl
, DECL_TEMPLATE_PARMS (tmpl
),
3097 /*is_primary=*/true, /*is_partial=*/false,
3100 return finish_template_type_parm (aggr
, tmpl
);
3103 /* ARGUMENT is the default-argument value for a template template
3104 parameter. If ARGUMENT is invalid, issue error messages and return
3105 the ERROR_MARK_NODE. Otherwise, ARGUMENT itself is returned. */
3108 check_template_template_default_arg (tree argument
)
3110 if (TREE_CODE (argument
) != TEMPLATE_DECL
3111 && TREE_CODE (argument
) != TEMPLATE_TEMPLATE_PARM
3112 && TREE_CODE (argument
) != UNBOUND_CLASS_TEMPLATE
)
3114 if (TREE_CODE (argument
) == TYPE_DECL
)
3115 error ("invalid use of type %qT as a default value for a template "
3116 "template-parameter", TREE_TYPE (argument
));
3118 error ("invalid default argument for a template template parameter");
3119 return error_mark_node
;
3125 /* Begin a class definition, as indicated by T. */
3128 begin_class_definition (tree t
)
3130 if (error_operand_p (t
) || error_operand_p (TYPE_MAIN_DECL (t
)))
3131 return error_mark_node
;
3133 if (processing_template_parmlist
&& !LAMBDA_TYPE_P (t
))
3135 error ("definition of %q#T inside template parameter list", t
);
3136 return error_mark_node
;
3139 /* According to the C++ ABI, decimal classes defined in ISO/IEC TR 24733
3140 are passed the same as decimal scalar types. */
3141 if (TREE_CODE (t
) == RECORD_TYPE
3142 && !processing_template_decl
)
3144 tree ns
= TYPE_CONTEXT (t
);
3145 if (ns
&& TREE_CODE (ns
) == NAMESPACE_DECL
3146 && DECL_CONTEXT (ns
) == std_node
3148 && id_equal (DECL_NAME (ns
), "decimal"))
3150 const char *n
= TYPE_NAME_STRING (t
);
3151 if ((strcmp (n
, "decimal32") == 0)
3152 || (strcmp (n
, "decimal64") == 0)
3153 || (strcmp (n
, "decimal128") == 0))
3154 TYPE_TRANSPARENT_AGGR (t
) = 1;
3158 /* A non-implicit typename comes from code like:
3160 template <typename T> struct A {
3161 template <typename U> struct A<T>::B ...
3163 This is erroneous. */
3164 else if (TREE_CODE (t
) == TYPENAME_TYPE
)
3166 error ("invalid definition of qualified type %qT", t
);
3167 t
= error_mark_node
;
3170 if (t
== error_mark_node
|| ! MAYBE_CLASS_TYPE_P (t
))
3172 t
= make_class_type (RECORD_TYPE
);
3173 pushtag (make_anon_name (), t
, /*tag_scope=*/ts_current
);
3176 if (TYPE_BEING_DEFINED (t
))
3178 t
= make_class_type (TREE_CODE (t
));
3179 pushtag (TYPE_IDENTIFIER (t
), t
, /*tag_scope=*/ts_current
);
3181 maybe_process_partial_specialization (t
);
3183 TYPE_BEING_DEFINED (t
) = 1;
3184 class_binding_level
->defining_class_p
= 1;
3186 if (flag_pack_struct
)
3189 TYPE_PACKED (t
) = 1;
3190 /* Even though the type is being defined for the first time
3191 here, there might have been a forward declaration, so there
3192 might be cv-qualified variants of T. */
3193 for (v
= TYPE_NEXT_VARIANT (t
); v
; v
= TYPE_NEXT_VARIANT (v
))
3194 TYPE_PACKED (v
) = 1;
3196 /* Reset the interface data, at the earliest possible
3197 moment, as it might have been set via a class foo;
3199 if (! TYPE_UNNAMED_P (t
))
3201 struct c_fileinfo
*finfo
= \
3202 get_fileinfo (LOCATION_FILE (input_location
));
3203 CLASSTYPE_INTERFACE_ONLY (t
) = finfo
->interface_only
;
3204 SET_CLASSTYPE_INTERFACE_UNKNOWN_X
3205 (t
, finfo
->interface_unknown
);
3207 reset_specialization();
3209 /* Make a declaration for this class in its own scope. */
3210 build_self_reference ();
3215 /* Finish the member declaration given by DECL. */
3218 finish_member_declaration (tree decl
)
3220 if (decl
== error_mark_node
|| decl
== NULL_TREE
)
3223 if (decl
== void_type_node
)
3224 /* The COMPONENT was a friend, not a member, and so there's
3225 nothing for us to do. */
3228 /* We should see only one DECL at a time. */
3229 gcc_assert (DECL_CHAIN (decl
) == NULL_TREE
);
3231 /* Don't add decls after definition. */
3232 gcc_assert (TYPE_BEING_DEFINED (current_class_type
)
3233 /* We can add lambda types when late parsing default
3235 || LAMBDA_TYPE_P (TREE_TYPE (decl
)));
3237 /* Set up access control for DECL. */
3239 = (current_access_specifier
== access_private_node
);
3240 TREE_PROTECTED (decl
)
3241 = (current_access_specifier
== access_protected_node
);
3242 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
3244 TREE_PRIVATE (DECL_TEMPLATE_RESULT (decl
)) = TREE_PRIVATE (decl
);
3245 TREE_PROTECTED (DECL_TEMPLATE_RESULT (decl
)) = TREE_PROTECTED (decl
);
3248 /* Mark the DECL as a member of the current class, unless it's
3249 a member of an enumeration. */
3250 if (TREE_CODE (decl
) != CONST_DECL
)
3251 DECL_CONTEXT (decl
) = current_class_type
;
3253 if (TREE_CODE (decl
) == USING_DECL
)
3254 /* For now, ignore class-scope USING_DECLS, so that debugging
3255 backends do not see them. */
3256 DECL_IGNORED_P (decl
) = 1;
3258 /* Check for bare parameter packs in the non-static data member
3260 if (TREE_CODE (decl
) == FIELD_DECL
)
3262 if (check_for_bare_parameter_packs (TREE_TYPE (decl
)))
3263 TREE_TYPE (decl
) = error_mark_node
;
3264 if (check_for_bare_parameter_packs (DECL_ATTRIBUTES (decl
)))
3265 DECL_ATTRIBUTES (decl
) = NULL_TREE
;
3270 A C language linkage is ignored for the names of class members
3271 and the member function type of class member functions. */
3272 if (DECL_LANG_SPECIFIC (decl
))
3273 SET_DECL_LANGUAGE (decl
, lang_cplusplus
);
3277 /* Functions and non-functions are added differently. */
3278 if (DECL_DECLARES_FUNCTION_P (decl
))
3279 add
= add_method (current_class_type
, decl
, false);
3280 /* Enter the DECL into the scope of the class, if the class
3281 isn't a closure (whose fields are supposed to be unnamed). */
3282 else if (CLASSTYPE_LAMBDA_EXPR (current_class_type
)
3283 || pushdecl_class_level (decl
))
3288 /* All TYPE_DECLs go at the end of TYPE_FIELDS. Ordinary fields
3289 go at the beginning. The reason is that
3290 legacy_nonfn_member_lookup searches the list in order, and we
3291 want a field name to override a type name so that the "struct
3292 stat hack" will work. In particular:
3294 struct S { enum E { }; static const int E = 5; int ary[S::E]; } s;
3298 if (TREE_CODE (decl
) == TYPE_DECL
)
3299 TYPE_FIELDS (current_class_type
)
3300 = chainon (TYPE_FIELDS (current_class_type
), decl
);
3303 DECL_CHAIN (decl
) = TYPE_FIELDS (current_class_type
);
3304 TYPE_FIELDS (current_class_type
) = decl
;
3307 maybe_add_class_template_decl_list (current_class_type
, decl
,
3312 /* Finish processing a complete template declaration. The PARMS are
3313 the template parameters. */
3316 finish_template_decl (tree parms
)
3319 end_template_decl ();
3321 end_specialization ();
3324 // Returns the template type of the class scope being entered. If we're
3325 // entering a constrained class scope. TYPE is the class template
3326 // scope being entered and we may need to match the intended type with
3327 // a constrained specialization. For example:
3329 // template<Object T>
3330 // struct S { void f(); }; #1
3332 // template<Object T>
3333 // void S<T>::f() { } #2
3335 // We check, in #2, that S<T> refers precisely to the type declared by
3336 // #1 (i.e., that the constraints match). Note that the following should
3337 // be an error since there is no specialization of S<T> that is
3338 // unconstrained, but this is not diagnosed here.
3340 // template<typename T>
3341 // void S<T>::f() { }
3343 // We cannot diagnose this problem here since this function also matches
3344 // qualified template names that are not part of a definition. For example:
3346 // template<Integral T, Floating_point U>
3347 // typename pair<T, U>::first_type void f(T, U);
3349 // Here, it is unlikely that there is a partial specialization of
3350 // pair constrained for for Integral and Floating_point arguments.
3352 // The general rule is: if a constrained specialization with matching
3353 // constraints is found return that type. Also note that if TYPE is not a
3354 // class-type (e.g. a typename type), then no fixup is needed.
3357 fixup_template_type (tree type
)
3359 // Find the template parameter list at the a depth appropriate to
3360 // the scope we're trying to enter.
3361 tree parms
= current_template_parms
;
3362 int depth
= template_class_depth (type
);
3363 for (int n
= processing_template_decl
; n
> depth
&& parms
; --n
)
3364 parms
= TREE_CHAIN (parms
);
3367 tree cur_reqs
= TEMPLATE_PARMS_CONSTRAINTS (parms
);
3368 tree cur_constr
= build_constraints (cur_reqs
, NULL_TREE
);
3370 // Search for a specialization whose type and constraints match.
3371 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
3372 tree specs
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
3375 tree spec_constr
= get_constraints (TREE_VALUE (specs
));
3377 // If the type and constraints match a specialization, then we
3378 // are entering that type.
3379 if (same_type_p (type
, TREE_TYPE (specs
))
3380 && equivalent_constraints (cur_constr
, spec_constr
))
3381 return TREE_TYPE (specs
);
3382 specs
= TREE_CHAIN (specs
);
3385 // If no specialization matches, then must return the type
3386 // previously found.
3390 /* Finish processing a template-id (which names a type) of the form
3391 NAME < ARGS >. Return the TYPE_DECL for the type named by the
3392 template-id. If ENTERING_SCOPE is nonzero we are about to enter
3393 the scope of template-id indicated. */
3396 finish_template_type (tree name
, tree args
, int entering_scope
)
3400 type
= lookup_template_class (name
, args
,
3401 NULL_TREE
, NULL_TREE
, entering_scope
,
3402 tf_warning_or_error
| tf_user
);
3404 /* If we might be entering the scope of a partial specialization,
3405 find the one with the right constraints. */
3408 && CLASS_TYPE_P (type
)
3409 && CLASSTYPE_TEMPLATE_INFO (type
)
3410 && dependent_type_p (type
)
3411 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
3412 type
= fixup_template_type (type
);
3414 if (type
== error_mark_node
)
3416 else if (CLASS_TYPE_P (type
) && !alias_type_or_template_p (type
))
3417 return TYPE_STUB_DECL (type
);
3419 return TYPE_NAME (type
);
3422 /* Finish processing a BASE_CLASS with the indicated ACCESS_SPECIFIER.
3423 Return a TREE_LIST containing the ACCESS_SPECIFIER and the
3424 BASE_CLASS, or NULL_TREE if an error occurred. The
3425 ACCESS_SPECIFIER is one of
3426 access_{default,public,protected_private}_node. For a virtual base
3427 we set TREE_TYPE. */
3430 finish_base_specifier (tree base
, tree access
, bool virtual_p
)
3434 if (base
== error_mark_node
)
3436 error ("invalid base-class specification");
3439 else if (! MAYBE_CLASS_TYPE_P (base
))
3441 error ("%qT is not a class type", base
);
3446 if (cp_type_quals (base
) != 0)
3448 /* DR 484: Can a base-specifier name a cv-qualified
3450 base
= TYPE_MAIN_VARIANT (base
);
3452 result
= build_tree_list (access
, base
);
3454 TREE_TYPE (result
) = integer_type_node
;
3460 /* If FNS is a member function, a set of member functions, or a
3461 template-id referring to one or more member functions, return a
3462 BASELINK for FNS, incorporating the current access context.
3463 Otherwise, return FNS unchanged. */
3466 baselink_for_fns (tree fns
)
3471 if (BASELINK_P (fns
)
3472 || error_operand_p (fns
))
3475 scope
= ovl_scope (fns
);
3476 if (!CLASS_TYPE_P (scope
))
3479 cl
= currently_open_derived_class (scope
);
3482 cl
= TYPE_BINFO (cl
);
3483 return build_baselink (cl
, cl
, fns
, /*optype=*/NULL_TREE
);
3486 /* Returns true iff DECL is a variable from a function outside
3490 outer_var_p (tree decl
)
3492 return ((VAR_P (decl
) || TREE_CODE (decl
) == PARM_DECL
)
3493 && DECL_FUNCTION_SCOPE_P (decl
)
3494 /* Don't get confused by temporaries. */
3496 && (DECL_CONTEXT (decl
) != current_function_decl
3497 || parsing_nsdmi ()));
3500 /* As above, but also checks that DECL is automatic. */
3503 outer_automatic_var_p (tree decl
)
3505 return (outer_var_p (decl
)
3506 && !TREE_STATIC (decl
));
3509 /* DECL satisfies outer_automatic_var_p. Possibly complain about it or
3510 rewrite it for lambda capture.
3512 If ODR_USE is true, we're being called from mark_use, and we complain about
3513 use of constant variables. If ODR_USE is false, we're being called for the
3514 id-expression, and we do lambda capture. */
3517 process_outer_var_ref (tree decl
, tsubst_flags_t complain
, bool odr_use
)
3519 if (cp_unevaluated_operand
)
3520 /* It's not a use (3.2) if we're in an unevaluated context. */
3522 if (decl
== error_mark_node
)
3525 tree context
= DECL_CONTEXT (decl
);
3526 tree containing_function
= current_function_decl
;
3527 tree lambda_stack
= NULL_TREE
;
3528 tree lambda_expr
= NULL_TREE
;
3529 tree initializer
= convert_from_reference (decl
);
3531 /* Mark it as used now even if the use is ill-formed. */
3532 if (!mark_used (decl
, complain
))
3533 return error_mark_node
;
3535 if (parsing_nsdmi ())
3536 containing_function
= NULL_TREE
;
3538 if (containing_function
&& LAMBDA_FUNCTION_P (containing_function
))
3540 /* Check whether we've already built a proxy. */
3542 while (is_normal_capture_proxy (var
))
3543 var
= DECL_CAPTURED_VARIABLE (var
);
3544 tree d
= retrieve_local_specialization (var
);
3546 if (d
&& d
!= decl
&& is_capture_proxy (d
))
3548 if (DECL_CONTEXT (d
) == containing_function
)
3549 /* We already have an inner proxy. */
3552 /* We need to capture an outer proxy. */
3553 return process_outer_var_ref (d
, complain
, odr_use
);
3557 /* If we are in a lambda function, we can move out until we hit
3559 2. a non-lambda function, or
3560 3. a non-default capturing lambda function. */
3561 while (context
!= containing_function
3562 /* containing_function can be null with invalid generic lambdas. */
3563 && containing_function
3564 && LAMBDA_FUNCTION_P (containing_function
))
3566 tree closure
= DECL_CONTEXT (containing_function
);
3567 lambda_expr
= CLASSTYPE_LAMBDA_EXPR (closure
);
3569 if (TYPE_CLASS_SCOPE_P (closure
))
3570 /* A lambda in an NSDMI (c++/64496). */
3573 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr
) == CPLD_NONE
)
3576 lambda_stack
= tree_cons (NULL_TREE
, lambda_expr
, lambda_stack
);
3578 containing_function
= decl_function_context (containing_function
);
3581 /* In a lambda within a template, wait until instantiation time to implicitly
3582 capture a parameter pack. We want to wait because we don't know if we're
3583 capturing the whole pack or a single element, and it's OK to wait because
3584 find_parameter_packs_r walks into the lambda body. */
3585 if (context
== containing_function
3586 && DECL_PACK_P (decl
))
3589 if (lambda_expr
&& VAR_P (decl
) && DECL_ANON_UNION_VAR_P (decl
))
3591 if (complain
& tf_error
)
3592 error ("cannot capture member %qD of anonymous union", decl
);
3593 return error_mark_node
;
3595 /* Do lambda capture when processing the id-expression, not when
3596 odr-using a variable. */
3597 if (!odr_use
&& context
== containing_function
)
3598 decl
= add_default_capture (lambda_stack
,
3599 /*id=*/DECL_NAME (decl
), initializer
);
3600 /* Only an odr-use of an outer automatic variable causes an
3601 error, and a constant variable can decay to a prvalue
3602 constant without odr-use. So don't complain yet. */
3603 else if (!odr_use
&& decl_constant_var_p (decl
))
3605 else if (lambda_expr
)
3607 if (complain
& tf_error
)
3609 error ("%qD is not captured", decl
);
3610 tree closure
= LAMBDA_EXPR_CLOSURE (lambda_expr
);
3611 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr
) == CPLD_NONE
)
3612 inform (location_of (closure
),
3613 "the lambda has no capture-default");
3614 else if (TYPE_CLASS_SCOPE_P (closure
))
3615 inform (UNKNOWN_LOCATION
, "lambda in local class %q+T cannot "
3616 "capture variables from the enclosing context",
3617 TYPE_CONTEXT (closure
));
3618 inform (DECL_SOURCE_LOCATION (decl
), "%q#D declared here", decl
);
3620 return error_mark_node
;
3624 if (complain
& tf_error
)
3627 ? G_("use of local variable with automatic storage from "
3628 "containing function")
3629 : G_("use of parameter from containing function"));
3630 inform (DECL_SOURCE_LOCATION (decl
), "%q#D declared here", decl
);
3632 return error_mark_node
;
3637 /* ID_EXPRESSION is a representation of parsed, but unprocessed,
3638 id-expression. (See cp_parser_id_expression for details.) SCOPE,
3639 if non-NULL, is the type or namespace used to explicitly qualify
3640 ID_EXPRESSION. DECL is the entity to which that name has been
3643 *CONSTANT_EXPRESSION_P is true if we are presently parsing a
3644 constant-expression. In that case, *NON_CONSTANT_EXPRESSION_P will
3645 be set to true if this expression isn't permitted in a
3646 constant-expression, but it is otherwise not set by this function.
3647 *ALLOW_NON_CONSTANT_EXPRESSION_P is true if we are parsing a
3648 constant-expression, but a non-constant expression is also
3651 DONE is true if this expression is a complete postfix-expression;
3652 it is false if this expression is followed by '->', '[', '(', etc.
3653 ADDRESS_P is true iff this expression is the operand of '&'.
3654 TEMPLATE_P is true iff the qualified-id was of the form
3655 "A::template B". TEMPLATE_ARG_P is true iff this qualified name
3656 appears as a template argument.
3658 If an error occurs, and it is the kind of error that might cause
3659 the parser to abort a tentative parse, *ERROR_MSG is filled in. It
3660 is the caller's responsibility to issue the message. *ERROR_MSG
3661 will be a string with static storage duration, so the caller need
3664 Return an expression for the entity, after issuing appropriate
3665 diagnostics. This function is also responsible for transforming a
3666 reference to a non-static member into a COMPONENT_REF that makes
3667 the use of "this" explicit.
3669 Upon return, *IDK will be filled in appropriately. */
3671 finish_id_expression_1 (tree id_expression
,
3675 bool integral_constant_expression_p
,
3676 bool allow_non_integral_constant_expression_p
,
3677 bool *non_integral_constant_expression_p
,
3681 bool template_arg_p
,
3682 const char **error_msg
,
3683 location_t location
)
3685 decl
= strip_using_decl (decl
);
3687 /* Initialize the output parameters. */
3688 *idk
= CP_ID_KIND_NONE
;
3691 if (id_expression
== error_mark_node
)
3692 return error_mark_node
;
3693 /* If we have a template-id, then no further lookup is
3694 required. If the template-id was for a template-class, we
3695 will sometimes have a TYPE_DECL at this point. */
3696 else if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
3697 || TREE_CODE (decl
) == TYPE_DECL
)
3699 /* Look up the name. */
3702 if (decl
== error_mark_node
)
3704 /* Name lookup failed. */
3707 || (!dependent_type_p (scope
)
3708 && !(identifier_p (id_expression
)
3709 && IDENTIFIER_CONV_OP_P (id_expression
)
3710 && dependent_type_p (TREE_TYPE (id_expression
))))))
3712 /* If the qualifying type is non-dependent (and the name
3713 does not name a conversion operator to a dependent
3714 type), issue an error. */
3715 qualified_name_lookup_error (scope
, id_expression
, decl
, location
);
3716 return error_mark_node
;
3720 /* It may be resolved via Koenig lookup. */
3721 *idk
= CP_ID_KIND_UNQUALIFIED
;
3722 return id_expression
;
3725 decl
= id_expression
;
3728 /* Remember that the name was used in the definition of
3729 the current class so that we can check later to see if
3730 the meaning would have been different after the class
3731 was entirely defined. */
3732 if (!scope
&& decl
!= error_mark_node
&& identifier_p (id_expression
))
3733 maybe_note_name_used_in_class (id_expression
, decl
);
3735 /* A use in unevaluated operand might not be instantiated appropriately
3736 if tsubst_copy builds a dummy parm, or if we never instantiate a
3737 generic lambda, so mark it now. */
3738 if (processing_template_decl
&& cp_unevaluated_operand
)
3739 mark_type_use (decl
);
3741 /* Disallow uses of local variables from containing functions, except
3742 within lambda-expressions. */
3743 if (outer_automatic_var_p (decl
))
3745 decl
= process_outer_var_ref (decl
, tf_warning_or_error
);
3746 if (decl
== error_mark_node
)
3747 return error_mark_node
;
3750 /* Also disallow uses of function parameters outside the function
3751 body, except inside an unevaluated context (i.e. decltype). */
3752 if (TREE_CODE (decl
) == PARM_DECL
3753 && DECL_CONTEXT (decl
) == NULL_TREE
3754 && !cp_unevaluated_operand
)
3756 *error_msg
= G_("use of parameter outside function body");
3757 return error_mark_node
;
3761 /* If we didn't find anything, or what we found was a type,
3762 then this wasn't really an id-expression. */
3763 if (TREE_CODE (decl
) == TEMPLATE_DECL
3764 && !DECL_FUNCTION_TEMPLATE_P (decl
))
3766 *error_msg
= G_("missing template arguments");
3767 return error_mark_node
;
3769 else if (TREE_CODE (decl
) == TYPE_DECL
3770 || TREE_CODE (decl
) == NAMESPACE_DECL
)
3772 *error_msg
= G_("expected primary-expression");
3773 return error_mark_node
;
3776 /* If the name resolved to a template parameter, there is no
3777 need to look it up again later. */
3778 if ((TREE_CODE (decl
) == CONST_DECL
&& DECL_TEMPLATE_PARM_P (decl
))
3779 || TREE_CODE (decl
) == TEMPLATE_PARM_INDEX
)
3783 *idk
= CP_ID_KIND_NONE
;
3784 if (TREE_CODE (decl
) == TEMPLATE_PARM_INDEX
)
3785 decl
= TEMPLATE_PARM_DECL (decl
);
3786 r
= DECL_INITIAL (decl
);
3787 if (CLASS_TYPE_P (TREE_TYPE (r
)) && !CP_TYPE_CONST_P (TREE_TYPE (r
)))
3789 /* If the entity is a template parameter object for a template
3790 parameter of type T, the type of the expression is const T. */
3791 tree ctype
= TREE_TYPE (r
);
3792 ctype
= cp_build_qualified_type (ctype
, (cp_type_quals (ctype
)
3793 | TYPE_QUAL_CONST
));
3794 r
= build1 (VIEW_CONVERT_EXPR
, ctype
, r
);
3796 r
= convert_from_reference (r
);
3797 if (integral_constant_expression_p
3798 && !dependent_type_p (TREE_TYPE (decl
))
3799 && !(INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (r
))))
3801 if (!allow_non_integral_constant_expression_p
)
3802 error ("template parameter %qD of type %qT is not allowed in "
3803 "an integral constant expression because it is not of "
3804 "integral or enumeration type", decl
, TREE_TYPE (decl
));
3805 *non_integral_constant_expression_p
= true;
3811 bool dependent_p
= type_dependent_expression_p (decl
);
3813 /* If the declaration was explicitly qualified indicate
3814 that. The semantics of `A::f(3)' are different than
3815 `f(3)' if `f' is virtual. */
3817 ? CP_ID_KIND_QUALIFIED
3818 : (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
3819 ? CP_ID_KIND_TEMPLATE_ID
3821 ? CP_ID_KIND_UNQUALIFIED_DEPENDENT
3822 : CP_ID_KIND_UNQUALIFIED
)));
3826 && any_dependent_type_attributes_p (DECL_ATTRIBUTES (decl
)))
3827 /* Dependent type attributes on the decl mean that the TREE_TYPE is
3828 wrong, so just return the identifier. */
3829 return id_expression
;
3831 if (DECL_CLASS_TEMPLATE_P (decl
))
3833 error ("use of class template %qT as expression", decl
);
3834 return error_mark_node
;
3837 if (TREE_CODE (decl
) == TREE_LIST
)
3839 /* Ambiguous reference to base members. */
3840 error ("request for member %qD is ambiguous in "
3841 "multiple inheritance lattice", id_expression
);
3842 print_candidates (decl
);
3843 return error_mark_node
;
3846 /* Mark variable-like entities as used. Functions are similarly
3847 marked either below or after overload resolution. */
3849 || TREE_CODE (decl
) == PARM_DECL
3850 || TREE_CODE (decl
) == CONST_DECL
3851 || TREE_CODE (decl
) == RESULT_DECL
)
3852 && !mark_used (decl
))
3853 return error_mark_node
;
3855 /* Only certain kinds of names are allowed in constant
3856 expression. Template parameters have already
3857 been handled above. */
3858 if (! error_operand_p (decl
)
3860 && integral_constant_expression_p
3861 && !decl_constant_var_p (decl
)
3862 && TREE_CODE (decl
) != CONST_DECL
3863 && !builtin_valid_in_constant_expr_p (decl
)
3864 && !concept_check_p (decl
))
3866 if (!allow_non_integral_constant_expression_p
)
3868 error ("%qD cannot appear in a constant-expression", decl
);
3869 return error_mark_node
;
3871 *non_integral_constant_expression_p
= true;
3874 if (tree wrap
= maybe_get_tls_wrapper_call (decl
))
3875 /* Replace an evaluated use of the thread_local variable with
3876 a call to its wrapper. */
3878 else if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
3880 && variable_template_p (TREE_OPERAND (decl
, 0))
3881 && !concept_check_p (decl
))
3883 decl
= finish_template_variable (decl
);
3885 decl
= convert_from_reference (decl
);
3887 else if (concept_check_p (decl
))
3889 /* Nothing more to do. All of the analysis for concept checks
3890 is done by build_conept_id, called from the parser. */
3894 if (TREE_CODE (decl
) == SCOPE_REF
)
3896 gcc_assert (same_type_p (scope
, TREE_OPERAND (decl
, 0)));
3897 decl
= TREE_OPERAND (decl
, 1);
3900 decl
= (adjust_result_of_qualified_name_lookup
3901 (decl
, scope
, current_nonlambda_class_type()));
3903 if (TREE_CODE (decl
) == FUNCTION_DECL
)
3906 cp_warn_deprecated_use_scopes (scope
);
3909 decl
= finish_qualified_id_expr (scope
,
3915 tf_warning_or_error
);
3917 decl
= convert_from_reference (decl
);
3919 else if (TREE_CODE (decl
) == FIELD_DECL
)
3921 /* Since SCOPE is NULL here, this is an unqualified name.
3922 Access checking has been performed during name lookup
3923 already. Turn off checking to avoid duplicate errors. */
3924 push_deferring_access_checks (dk_no_check
);
3925 decl
= finish_non_static_data_member (decl
, NULL_TREE
,
3926 /*qualifying_scope=*/NULL_TREE
);
3927 pop_deferring_access_checks ();
3929 else if (is_overloaded_fn (decl
))
3931 /* We only need to look at the first function,
3932 because all the fns share the attribute we're
3933 concerned with (all member fns or all non-members). */
3934 tree first_fn
= get_first_fn (decl
);
3935 first_fn
= STRIP_TEMPLATE (first_fn
);
3937 /* [basic.def.odr]: "A function whose name appears as a
3938 potentially-evaluated expression is odr-used if it is the unique
3941 But only mark it if it's a complete postfix-expression; in a call,
3942 ADL might select a different function, and we'll call mark_used in
3945 && !really_overloaded_fn (decl
)
3946 && !mark_used (first_fn
))
3947 return error_mark_node
;
3950 && (TREE_CODE (first_fn
) == USING_DECL
3951 || (TREE_CODE (first_fn
) == FUNCTION_DECL
3952 && DECL_FUNCTION_MEMBER_P (first_fn
)
3953 && !shared_member_p (decl
))))
3955 /* A set of member functions. */
3956 decl
= maybe_dummy_object (DECL_CONTEXT (first_fn
), 0);
3957 return finish_class_member_access_expr (decl
, id_expression
,
3958 /*template_p=*/false,
3959 tf_warning_or_error
);
3962 decl
= baselink_for_fns (decl
);
3966 if (DECL_P (decl
) && DECL_NONLOCAL (decl
)
3967 && DECL_CLASS_SCOPE_P (decl
))
3969 tree context
= context_for_name_lookup (decl
);
3970 if (context
!= current_class_type
)
3972 tree path
= currently_open_derived_class (context
);
3973 perform_or_defer_access_check (TYPE_BINFO (path
),
3975 tf_warning_or_error
);
3979 decl
= convert_from_reference (decl
);
3983 return cp_expr (decl
, location
);
3986 /* As per finish_id_expression_1, but adding a wrapper node
3987 around the result if needed to express LOCATION. */
3990 finish_id_expression (tree id_expression
,
3994 bool integral_constant_expression_p
,
3995 bool allow_non_integral_constant_expression_p
,
3996 bool *non_integral_constant_expression_p
,
4000 bool template_arg_p
,
4001 const char **error_msg
,
4002 location_t location
)
4005 = finish_id_expression_1 (id_expression
, decl
, scope
, idk
,
4006 integral_constant_expression_p
,
4007 allow_non_integral_constant_expression_p
,
4008 non_integral_constant_expression_p
,
4009 template_p
, done
, address_p
, template_arg_p
,
4010 error_msg
, location
);
4011 return result
.maybe_add_location_wrapper ();
4014 /* Implement the __typeof keyword: Return the type of EXPR, suitable for
4015 use as a type-specifier. */
4018 finish_typeof (tree expr
)
4022 if (type_dependent_expression_p (expr
))
4024 type
= cxx_make_type (TYPEOF_TYPE
);
4025 TYPEOF_TYPE_EXPR (type
) = expr
;
4026 SET_TYPE_STRUCTURAL_EQUALITY (type
);
4031 expr
= mark_type_use (expr
);
4033 type
= unlowered_expr_type (expr
);
4035 if (!type
|| type
== unknown_type_node
)
4037 error ("type of %qE is unknown", expr
);
4038 return error_mark_node
;
4044 /* Implement the __underlying_type keyword: Return the underlying
4045 type of TYPE, suitable for use as a type-specifier. */
4048 finish_underlying_type (tree type
)
4050 tree underlying_type
;
4052 if (processing_template_decl
)
4054 underlying_type
= cxx_make_type (UNDERLYING_TYPE
);
4055 UNDERLYING_TYPE_TYPE (underlying_type
) = type
;
4056 SET_TYPE_STRUCTURAL_EQUALITY (underlying_type
);
4058 return underlying_type
;
4061 if (!complete_type_or_else (type
, NULL_TREE
))
4062 return error_mark_node
;
4064 if (TREE_CODE (type
) != ENUMERAL_TYPE
)
4066 error ("%qT is not an enumeration type", type
);
4067 return error_mark_node
;
4070 underlying_type
= ENUM_UNDERLYING_TYPE (type
);
4072 /* Fixup necessary in this case because ENUM_UNDERLYING_TYPE
4073 includes TYPE_MIN_VALUE and TYPE_MAX_VALUE information.
4074 See finish_enum_value_list for details. */
4075 if (!ENUM_FIXED_UNDERLYING_TYPE_P (type
))
4077 = c_common_type_for_mode (TYPE_MODE (underlying_type
),
4078 TYPE_UNSIGNED (underlying_type
));
4080 return underlying_type
;
4083 /* Implement the __direct_bases keyword: Return the direct base classes
4087 calculate_direct_bases (tree type
, tsubst_flags_t complain
)
4089 if (!complete_type_or_maybe_complain (type
, NULL_TREE
, complain
)
4090 || !NON_UNION_CLASS_TYPE_P (type
))
4091 return make_tree_vec (0);
4093 releasing_vec vector
;
4094 vec
<tree
, va_gc
> *base_binfos
= BINFO_BASE_BINFOS (TYPE_BINFO (type
));
4098 /* Virtual bases are initialized first */
4099 for (i
= 0; base_binfos
->iterate (i
, &binfo
); i
++)
4100 if (BINFO_VIRTUAL_P (binfo
))
4101 vec_safe_push (vector
, binfo
);
4103 /* Now non-virtuals */
4104 for (i
= 0; base_binfos
->iterate (i
, &binfo
); i
++)
4105 if (!BINFO_VIRTUAL_P (binfo
))
4106 vec_safe_push (vector
, binfo
);
4108 tree bases_vec
= make_tree_vec (vector
->length ());
4110 for (i
= 0; i
< vector
->length (); ++i
)
4111 TREE_VEC_ELT (bases_vec
, i
) = BINFO_TYPE ((*vector
)[i
]);
4116 /* Implement the __bases keyword: Return the base classes
4119 /* Find morally non-virtual base classes by walking binfo hierarchy */
4120 /* Virtual base classes are handled separately in finish_bases */
4123 dfs_calculate_bases_pre (tree binfo
, void * /*data_*/)
4125 /* Don't walk bases of virtual bases */
4126 return BINFO_VIRTUAL_P (binfo
) ? dfs_skip_bases
: NULL_TREE
;
4130 dfs_calculate_bases_post (tree binfo
, void *data_
)
4132 vec
<tree
, va_gc
> **data
= ((vec
<tree
, va_gc
> **) data_
);
4133 if (!BINFO_VIRTUAL_P (binfo
))
4134 vec_safe_push (*data
, BINFO_TYPE (binfo
));
4138 /* Calculates the morally non-virtual base classes of a class */
4139 static vec
<tree
, va_gc
> *
4140 calculate_bases_helper (tree type
)
4142 vec
<tree
, va_gc
> *vector
= make_tree_vector ();
4144 /* Now add non-virtual base classes in order of construction */
4145 if (TYPE_BINFO (type
))
4146 dfs_walk_all (TYPE_BINFO (type
),
4147 dfs_calculate_bases_pre
, dfs_calculate_bases_post
, &vector
);
4152 calculate_bases (tree type
, tsubst_flags_t complain
)
4154 if (!complete_type_or_maybe_complain (type
, NULL_TREE
, complain
)
4155 || !NON_UNION_CLASS_TYPE_P (type
))
4156 return make_tree_vec (0);
4158 releasing_vec vector
;
4159 tree bases_vec
= NULL_TREE
;
4161 vec
<tree
, va_gc
> *vbases
;
4164 /* First go through virtual base classes */
4165 for (vbases
= CLASSTYPE_VBASECLASSES (type
), i
= 0;
4166 vec_safe_iterate (vbases
, i
, &binfo
); i
++)
4168 releasing_vec vbase_bases
4169 = calculate_bases_helper (BINFO_TYPE (binfo
));
4170 vec_safe_splice (vector
, vbase_bases
);
4173 /* Now for the non-virtual bases */
4174 releasing_vec nonvbases
= calculate_bases_helper (type
);
4175 vec_safe_splice (vector
, nonvbases
);
4177 /* Note that during error recovery vector->length can even be zero. */
4178 if (vector
->length () > 1)
4180 /* Last element is entire class, so don't copy */
4181 bases_vec
= make_tree_vec (vector
->length () - 1);
4183 for (i
= 0; i
< vector
->length () - 1; ++i
)
4184 TREE_VEC_ELT (bases_vec
, i
) = (*vector
)[i
];
4187 bases_vec
= make_tree_vec (0);
4193 finish_bases (tree type
, bool direct
)
4195 tree bases
= NULL_TREE
;
4197 if (!processing_template_decl
)
4199 /* Parameter packs can only be used in templates */
4200 error ("parameter pack %<__bases%> only valid in template declaration");
4201 return error_mark_node
;
4204 bases
= cxx_make_type (BASES
);
4205 BASES_TYPE (bases
) = type
;
4206 BASES_DIRECT (bases
) = direct
;
4207 SET_TYPE_STRUCTURAL_EQUALITY (bases
);
4212 /* Perform C++-specific checks for __builtin_offsetof before calling
4216 finish_offsetof (tree object_ptr
, tree expr
, location_t loc
)
4218 /* If we're processing a template, we can't finish the semantics yet.
4219 Otherwise we can fold the entire expression now. */
4220 if (processing_template_decl
)
4222 expr
= build2 (OFFSETOF_EXPR
, size_type_node
, expr
, object_ptr
);
4223 SET_EXPR_LOCATION (expr
, loc
);
4227 if (expr
== error_mark_node
)
4228 return error_mark_node
;
4230 if (TREE_CODE (expr
) == PSEUDO_DTOR_EXPR
)
4232 error ("cannot apply %<offsetof%> to destructor %<~%T%>",
4233 TREE_OPERAND (expr
, 2));
4234 return error_mark_node
;
4236 if (FUNC_OR_METHOD_TYPE_P (TREE_TYPE (expr
))
4237 || TREE_TYPE (expr
) == unknown_type_node
)
4239 while (TREE_CODE (expr
) == COMPONENT_REF
4240 || TREE_CODE (expr
) == COMPOUND_EXPR
)
4241 expr
= TREE_OPERAND (expr
, 1);
4245 error ("cannot apply %<offsetof%> to member function %qD", expr
);
4246 inform (DECL_SOURCE_LOCATION (expr
), "declared here");
4249 error ("cannot apply %<offsetof%> to member function");
4250 return error_mark_node
;
4252 if (TREE_CODE (expr
) == CONST_DECL
)
4254 error ("cannot apply %<offsetof%> to an enumerator %qD", expr
);
4255 return error_mark_node
;
4257 if (REFERENCE_REF_P (expr
))
4258 expr
= TREE_OPERAND (expr
, 0);
4259 if (!complete_type_or_else (TREE_TYPE (TREE_TYPE (object_ptr
)), object_ptr
))
4260 return error_mark_node
;
4261 if (warn_invalid_offsetof
4262 && CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (object_ptr
)))
4263 && CLASSTYPE_NON_STD_LAYOUT (TREE_TYPE (TREE_TYPE (object_ptr
)))
4264 && cp_unevaluated_operand
== 0)
4265 warning_at (loc
, OPT_Winvalid_offsetof
, "%<offsetof%> within "
4266 "non-standard-layout type %qT is conditionally-supported",
4267 TREE_TYPE (TREE_TYPE (object_ptr
)));
4268 return fold_offsetof (expr
);
4271 /* Replace the AGGR_INIT_EXPR at *TP with an equivalent CALL_EXPR. This
4272 function is broken out from the above for the benefit of the tree-ssa
4276 simplify_aggr_init_expr (tree
*tp
)
4278 tree aggr_init_expr
= *tp
;
4280 /* Form an appropriate CALL_EXPR. */
4281 tree fn
= AGGR_INIT_EXPR_FN (aggr_init_expr
);
4282 tree slot
= AGGR_INIT_EXPR_SLOT (aggr_init_expr
);
4283 tree type
= TREE_TYPE (slot
);
4286 enum style_t
{ ctor
, arg
, pcc
} style
;
4288 if (AGGR_INIT_VIA_CTOR_P (aggr_init_expr
))
4290 #ifdef PCC_STATIC_STRUCT_RETURN
4296 gcc_assert (TREE_ADDRESSABLE (type
));
4300 call_expr
= build_call_array_loc (input_location
,
4301 TREE_TYPE (TREE_TYPE (TREE_TYPE (fn
))),
4303 aggr_init_expr_nargs (aggr_init_expr
),
4304 AGGR_INIT_EXPR_ARGP (aggr_init_expr
));
4305 TREE_NOTHROW (call_expr
) = TREE_NOTHROW (aggr_init_expr
);
4306 CALL_FROM_THUNK_P (call_expr
) = AGGR_INIT_FROM_THUNK_P (aggr_init_expr
);
4307 CALL_EXPR_OPERATOR_SYNTAX (call_expr
)
4308 = CALL_EXPR_OPERATOR_SYNTAX (aggr_init_expr
);
4309 CALL_EXPR_ORDERED_ARGS (call_expr
) = CALL_EXPR_ORDERED_ARGS (aggr_init_expr
);
4310 CALL_EXPR_REVERSE_ARGS (call_expr
) = CALL_EXPR_REVERSE_ARGS (aggr_init_expr
);
4314 /* Replace the first argument to the ctor with the address of the
4316 cxx_mark_addressable (slot
);
4317 CALL_EXPR_ARG (call_expr
, 0) =
4318 build1 (ADDR_EXPR
, build_pointer_type (type
), slot
);
4320 else if (style
== arg
)
4322 /* Just mark it addressable here, and leave the rest to
4323 expand_call{,_inline}. */
4324 cxx_mark_addressable (slot
);
4325 CALL_EXPR_RETURN_SLOT_OPT (call_expr
) = true;
4326 call_expr
= build2 (INIT_EXPR
, TREE_TYPE (call_expr
), slot
, call_expr
);
4328 else if (style
== pcc
)
4330 /* If we're using the non-reentrant PCC calling convention, then we
4331 need to copy the returned value out of the static buffer into the
4333 push_deferring_access_checks (dk_no_check
);
4334 call_expr
= build_aggr_init (slot
, call_expr
,
4335 DIRECT_BIND
| LOOKUP_ONLYCONVERTING
,
4336 tf_warning_or_error
);
4337 pop_deferring_access_checks ();
4338 call_expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (slot
), call_expr
, slot
);
4341 if (AGGR_INIT_ZERO_FIRST (aggr_init_expr
))
4343 tree init
= build_zero_init (type
, NULL_TREE
,
4344 /*static_storage_p=*/false);
4345 init
= build2 (INIT_EXPR
, void_type_node
, slot
, init
);
4346 call_expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (call_expr
),
4353 /* Emit all thunks to FN that should be emitted when FN is emitted. */
4356 emit_associated_thunks (tree fn
)
4358 /* When we use vcall offsets, we emit thunks with the virtual
4359 functions to which they thunk. The whole point of vcall offsets
4360 is so that you can know statically the entire set of thunks that
4361 will ever be needed for a given virtual function, thereby
4362 enabling you to output all the thunks with the function itself. */
4363 if (DECL_VIRTUAL_P (fn
)
4364 /* Do not emit thunks for extern template instantiations. */
4365 && ! DECL_REALLY_EXTERN (fn
))
4369 for (thunk
= DECL_THUNKS (fn
); thunk
; thunk
= DECL_CHAIN (thunk
))
4371 if (!THUNK_ALIAS (thunk
))
4373 use_thunk (thunk
, /*emit_p=*/1);
4374 if (DECL_RESULT_THUNK_P (thunk
))
4378 for (probe
= DECL_THUNKS (thunk
);
4379 probe
; probe
= DECL_CHAIN (probe
))
4380 use_thunk (probe
, /*emit_p=*/1);
4384 gcc_assert (!DECL_THUNKS (thunk
));
4389 /* Generate RTL for FN. */
4392 expand_or_defer_fn_1 (tree fn
)
4394 /* When the parser calls us after finishing the body of a template
4395 function, we don't really want to expand the body. */
4396 if (processing_template_decl
)
4398 /* Normally, collection only occurs in rest_of_compilation. So,
4399 if we don't collect here, we never collect junk generated
4400 during the processing of templates until we hit a
4401 non-template function. It's not safe to do this inside a
4402 nested class, though, as the parser may have local state that
4403 is not a GC root. */
4404 if (!function_depth
)
4409 gcc_assert (DECL_SAVED_TREE (fn
));
4411 /* We make a decision about linkage for these functions at the end
4412 of the compilation. Until that point, we do not want the back
4413 end to output them -- but we do want it to see the bodies of
4414 these functions so that it can inline them as appropriate. */
4415 if (DECL_DECLARED_INLINE_P (fn
) || DECL_IMPLICIT_INSTANTIATION (fn
))
4417 if (DECL_INTERFACE_KNOWN (fn
))
4418 /* We've already made a decision as to how this function will
4421 || DECL_IMMEDIATE_FUNCTION_P (fn
)
4422 || DECL_OMP_DECLARE_REDUCTION_P (fn
))
4423 tentative_decl_linkage (fn
);
4425 import_export_decl (fn
);
4427 /* If the user wants us to keep all inline functions, then mark
4428 this function as needed so that finish_file will make sure to
4429 output it later. Similarly, all dllexport'd functions must
4430 be emitted; there may be callers in other DLLs. */
4431 if (DECL_DECLARED_INLINE_P (fn
)
4432 && !DECL_REALLY_EXTERN (fn
)
4433 && !DECL_IMMEDIATE_FUNCTION_P (fn
)
4434 && !DECL_OMP_DECLARE_REDUCTION_P (fn
)
4435 && (flag_keep_inline_functions
4436 || (flag_keep_inline_dllexport
4437 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (fn
)))))
4440 DECL_EXTERNAL (fn
) = 0;
4444 /* If this is a constructor or destructor body, we have to clone
4446 if (maybe_clone_body (fn
))
4448 /* We don't want to process FN again, so pretend we've written
4449 it out, even though we haven't. */
4450 TREE_ASM_WRITTEN (fn
) = 1;
4451 /* If this is a constexpr function, keep DECL_SAVED_TREE. */
4452 if (!DECL_DECLARED_CONSTEXPR_P (fn
))
4453 DECL_SAVED_TREE (fn
) = NULL_TREE
;
4457 /* There's no reason to do any of the work here if we're only doing
4458 semantic analysis; this code just generates RTL. */
4459 if (flag_syntax_only
)
4461 /* Pretend that this function has been written out so that we don't try
4462 to expand it again. */
4463 TREE_ASM_WRITTEN (fn
) = 1;
4467 if (DECL_OMP_DECLARE_REDUCTION_P (fn
))
4474 expand_or_defer_fn (tree fn
)
4476 if (expand_or_defer_fn_1 (fn
))
4480 /* Expand or defer, at the whim of the compilation unit manager. */
4481 cgraph_node::finalize_function (fn
, function_depth
> 1);
4482 emit_associated_thunks (fn
);
4491 nrv_data () : visited (37) {}
4495 hash_table
<nofree_ptr_hash
<tree_node
> > visited
;
4498 /* Helper function for walk_tree, used by finalize_nrv below. */
4501 finalize_nrv_r (tree
* tp
, int* walk_subtrees
, void* data
)
4503 class nrv_data
*dp
= (class nrv_data
*)data
;
4506 /* No need to walk into types. There wouldn't be any need to walk into
4507 non-statements, except that we have to consider STMT_EXPRs. */
4510 /* Change all returns to just refer to the RESULT_DECL; this is a nop,
4511 but differs from using NULL_TREE in that it indicates that we care
4512 about the value of the RESULT_DECL. */
4513 else if (TREE_CODE (*tp
) == RETURN_EXPR
)
4514 TREE_OPERAND (*tp
, 0) = dp
->result
;
4515 /* Change all cleanups for the NRV to only run when an exception is
4517 else if (TREE_CODE (*tp
) == CLEANUP_STMT
4518 && CLEANUP_DECL (*tp
) == dp
->var
)
4519 CLEANUP_EH_ONLY (*tp
) = 1;
4520 /* Replace the DECL_EXPR for the NRV with an initialization of the
4521 RESULT_DECL, if needed. */
4522 else if (TREE_CODE (*tp
) == DECL_EXPR
4523 && DECL_EXPR_DECL (*tp
) == dp
->var
)
4526 if (DECL_INITIAL (dp
->var
)
4527 && DECL_INITIAL (dp
->var
) != error_mark_node
)
4528 init
= build2 (INIT_EXPR
, void_type_node
, dp
->result
,
4529 DECL_INITIAL (dp
->var
));
4531 init
= build_empty_stmt (EXPR_LOCATION (*tp
));
4532 DECL_INITIAL (dp
->var
) = NULL_TREE
;
4533 SET_EXPR_LOCATION (init
, EXPR_LOCATION (*tp
));
4536 /* And replace all uses of the NRV with the RESULT_DECL. */
4537 else if (*tp
== dp
->var
)
4540 /* Avoid walking into the same tree more than once. Unfortunately, we
4541 can't just use walk_tree_without duplicates because it would only call
4542 us for the first occurrence of dp->var in the function body. */
4543 slot
= dp
->visited
.find_slot (*tp
, INSERT
);
4549 /* Keep iterating. */
4553 /* Called from finish_function to implement the named return value
4554 optimization by overriding all the RETURN_EXPRs and pertinent
4555 CLEANUP_STMTs and replacing all occurrences of VAR with RESULT, the
4556 RESULT_DECL for the function. */
4559 finalize_nrv (tree
*tp
, tree var
, tree result
)
4561 class nrv_data data
;
4563 /* Copy name from VAR to RESULT. */
4564 DECL_NAME (result
) = DECL_NAME (var
);
4565 /* Don't forget that we take its address. */
4566 TREE_ADDRESSABLE (result
) = TREE_ADDRESSABLE (var
);
4567 /* Finally set DECL_VALUE_EXPR to avoid assigning
4568 a stack slot at -O0 for the original var and debug info
4569 uses RESULT location for VAR. */
4570 SET_DECL_VALUE_EXPR (var
, result
);
4571 DECL_HAS_VALUE_EXPR_P (var
) = 1;
4574 data
.result
= result
;
4575 cp_walk_tree (tp
, finalize_nrv_r
, &data
, 0);
4578 /* Create CP_OMP_CLAUSE_INFO for clause C. Returns true if it is invalid. */
4581 cxx_omp_create_clause_info (tree c
, tree type
, bool need_default_ctor
,
4582 bool need_copy_ctor
, bool need_copy_assignment
,
4585 int save_errorcount
= errorcount
;
4588 /* Always allocate 3 elements for simplicity. These are the
4589 function decls for the ctor, dtor, and assignment op.
4590 This layout is known to the three lang hooks,
4591 cxx_omp_clause_default_init, cxx_omp_clause_copy_init,
4592 and cxx_omp_clause_assign_op. */
4593 info
= make_tree_vec (3);
4594 CP_OMP_CLAUSE_INFO (c
) = info
;
4596 if (need_default_ctor
|| need_copy_ctor
)
4598 if (need_default_ctor
)
4599 t
= get_default_ctor (type
);
4601 t
= get_copy_ctor (type
, tf_warning_or_error
);
4603 if (t
&& !trivial_fn_p (t
))
4604 TREE_VEC_ELT (info
, 0) = t
;
4607 if (need_dtor
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
4608 TREE_VEC_ELT (info
, 1) = get_dtor (type
, tf_warning_or_error
);
4610 if (need_copy_assignment
)
4612 t
= get_copy_assign (type
);
4614 if (t
&& !trivial_fn_p (t
))
4615 TREE_VEC_ELT (info
, 2) = t
;
4618 return errorcount
!= save_errorcount
;
4621 /* If DECL is DECL_OMP_PRIVATIZED_MEMBER, return corresponding
4622 FIELD_DECL, otherwise return DECL itself. */
4625 omp_clause_decl_field (tree decl
)
4628 && DECL_HAS_VALUE_EXPR_P (decl
)
4629 && DECL_ARTIFICIAL (decl
)
4630 && DECL_LANG_SPECIFIC (decl
)
4631 && DECL_OMP_PRIVATIZED_MEMBER (decl
))
4633 tree f
= DECL_VALUE_EXPR (decl
);
4634 if (INDIRECT_REF_P (f
))
4635 f
= TREE_OPERAND (f
, 0);
4636 if (TREE_CODE (f
) == COMPONENT_REF
)
4638 f
= TREE_OPERAND (f
, 1);
4639 gcc_assert (TREE_CODE (f
) == FIELD_DECL
);
4646 /* Adjust DECL if needed for printing using %qE. */
4649 omp_clause_printable_decl (tree decl
)
4651 tree t
= omp_clause_decl_field (decl
);
4657 /* For a FIELD_DECL F and corresponding DECL_OMP_PRIVATIZED_MEMBER
4658 VAR_DECL T that doesn't need a DECL_EXPR added, record it for
4662 omp_note_field_privatization (tree f
, tree t
)
4664 if (!omp_private_member_map
)
4665 omp_private_member_map
= new hash_map
<tree
, tree
>;
4666 tree
&v
= omp_private_member_map
->get_or_insert (f
);
4670 omp_private_member_vec
.safe_push (f
);
4671 /* Signal that we don't want to create DECL_EXPR for this dummy var. */
4672 omp_private_member_vec
.safe_push (integer_zero_node
);
4676 /* Privatize FIELD_DECL T, return corresponding DECL_OMP_PRIVATIZED_MEMBER
4680 omp_privatize_field (tree t
, bool shared
)
4682 tree m
= finish_non_static_data_member (t
, NULL_TREE
, NULL_TREE
);
4683 if (m
== error_mark_node
)
4684 return error_mark_node
;
4685 if (!omp_private_member_map
&& !shared
)
4686 omp_private_member_map
= new hash_map
<tree
, tree
>;
4687 if (TYPE_REF_P (TREE_TYPE (t
)))
4689 gcc_assert (INDIRECT_REF_P (m
));
4690 m
= TREE_OPERAND (m
, 0);
4692 tree vb
= NULL_TREE
;
4693 tree
&v
= shared
? vb
: omp_private_member_map
->get_or_insert (t
);
4696 v
= create_temporary_var (TREE_TYPE (m
));
4697 retrofit_lang_decl (v
);
4698 DECL_OMP_PRIVATIZED_MEMBER (v
) = 1;
4699 SET_DECL_VALUE_EXPR (v
, m
);
4700 DECL_HAS_VALUE_EXPR_P (v
) = 1;
4702 omp_private_member_vec
.safe_push (t
);
4707 /* Helper function for handle_omp_array_sections. Called recursively
4708 to handle multiple array-section-subscripts. C is the clause,
4709 T current expression (initially OMP_CLAUSE_DECL), which is either
4710 a TREE_LIST for array-section-subscript (TREE_PURPOSE is low-bound
4711 expression if specified, TREE_VALUE length expression if specified,
4712 TREE_CHAIN is what it has been specified after, or some decl.
4713 TYPES vector is populated with array section types, MAYBE_ZERO_LEN
4714 set to true if any of the array-section-subscript could have length
4715 of zero (explicit or implicit), FIRST_NON_ONE is the index of the
4716 first array-section-subscript which is known not to have length
4718 map(a[:b][2:1][:c][:2][:d][e:f][2:5])
4719 FIRST_NON_ONE will be 3, array-section-subscript [:b], [2:1] and [:c]
4720 all are or may have length of 1, array-section-subscript [:2] is the
4721 first one known not to have length 1. For array-section-subscript
4722 <= FIRST_NON_ONE we diagnose non-contiguous arrays if low bound isn't
4723 0 or length isn't the array domain max + 1, for > FIRST_NON_ONE we
4724 can if MAYBE_ZERO_LEN is false. MAYBE_ZERO_LEN will be true in the above
4725 case though, as some lengths could be zero. */
4728 handle_omp_array_sections_1 (tree c
, tree t
, vec
<tree
> &types
,
4729 bool &maybe_zero_len
, unsigned int &first_non_one
,
4730 enum c_omp_region_type ort
)
4732 tree ret
, low_bound
, length
, type
;
4733 if (TREE_CODE (t
) != TREE_LIST
)
4735 if (error_operand_p (t
))
4736 return error_mark_node
;
4737 if (REFERENCE_REF_P (t
)
4738 && TREE_CODE (TREE_OPERAND (t
, 0)) == COMPONENT_REF
)
4739 t
= TREE_OPERAND (t
, 0);
4741 if (TREE_CODE (t
) == COMPONENT_REF
4743 && (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_MAP
4744 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_TO
4745 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FROM
)
4746 && !type_dependent_expression_p (t
))
4748 if (TREE_CODE (TREE_OPERAND (t
, 1)) == FIELD_DECL
4749 && DECL_BIT_FIELD (TREE_OPERAND (t
, 1)))
4751 error_at (OMP_CLAUSE_LOCATION (c
),
4752 "bit-field %qE in %qs clause",
4753 t
, omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
4754 return error_mark_node
;
4756 while (TREE_CODE (t
) == COMPONENT_REF
)
4758 if (TREE_TYPE (TREE_OPERAND (t
, 0))
4759 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0))) == UNION_TYPE
)
4761 error_at (OMP_CLAUSE_LOCATION (c
),
4762 "%qE is a member of a union", t
);
4763 return error_mark_node
;
4765 t
= TREE_OPERAND (t
, 0);
4767 if (REFERENCE_REF_P (t
))
4768 t
= TREE_OPERAND (t
, 0);
4770 if (!VAR_P (t
) && TREE_CODE (t
) != PARM_DECL
)
4772 if (processing_template_decl
&& TREE_CODE (t
) != OVERLOAD
)
4775 error_at (OMP_CLAUSE_LOCATION (c
),
4776 "%qD is not a variable in %qs clause", t
,
4777 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
4779 error_at (OMP_CLAUSE_LOCATION (c
),
4780 "%qE is not a variable in %qs clause", t
,
4781 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
4782 return error_mark_node
;
4784 else if (ort
== C_ORT_OMP
4785 && TREE_CODE (t
) == PARM_DECL
4786 && DECL_ARTIFICIAL (t
)
4787 && DECL_NAME (t
) == this_identifier
)
4789 error_at (OMP_CLAUSE_LOCATION (c
),
4790 "%<this%> allowed in OpenMP only in %<declare simd%>"
4792 return error_mark_node
;
4794 else if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_DEPEND
4795 && VAR_P (t
) && CP_DECL_THREAD_LOCAL_P (t
))
4797 error_at (OMP_CLAUSE_LOCATION (c
),
4798 "%qD is threadprivate variable in %qs clause", t
,
4799 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
4800 return error_mark_node
;
4802 if (type_dependent_expression_p (ret
))
4804 ret
= convert_from_reference (ret
);
4808 if (ort
== C_ORT_OMP
4809 && (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
4810 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_IN_REDUCTION
4811 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_TASK_REDUCTION
)
4812 && TREE_CODE (TREE_CHAIN (t
)) == FIELD_DECL
)
4813 TREE_CHAIN (t
) = omp_privatize_field (TREE_CHAIN (t
), false);
4814 ret
= handle_omp_array_sections_1 (c
, TREE_CHAIN (t
), types
,
4815 maybe_zero_len
, first_non_one
, ort
);
4816 if (ret
== error_mark_node
|| ret
== NULL_TREE
)
4819 type
= TREE_TYPE (ret
);
4820 low_bound
= TREE_PURPOSE (t
);
4821 length
= TREE_VALUE (t
);
4822 if ((low_bound
&& type_dependent_expression_p (low_bound
))
4823 || (length
&& type_dependent_expression_p (length
)))
4826 if (low_bound
== error_mark_node
|| length
== error_mark_node
)
4827 return error_mark_node
;
4829 if (low_bound
&& !INTEGRAL_TYPE_P (TREE_TYPE (low_bound
)))
4831 error_at (OMP_CLAUSE_LOCATION (c
),
4832 "low bound %qE of array section does not have integral type",
4834 return error_mark_node
;
4836 if (length
&& !INTEGRAL_TYPE_P (TREE_TYPE (length
)))
4838 error_at (OMP_CLAUSE_LOCATION (c
),
4839 "length %qE of array section does not have integral type",
4841 return error_mark_node
;
4844 low_bound
= mark_rvalue_use (low_bound
);
4846 length
= mark_rvalue_use (length
);
4847 /* We need to reduce to real constant-values for checks below. */
4849 length
= fold_simple (length
);
4851 low_bound
= fold_simple (low_bound
);
4853 && TREE_CODE (low_bound
) == INTEGER_CST
4854 && TYPE_PRECISION (TREE_TYPE (low_bound
))
4855 > TYPE_PRECISION (sizetype
))
4856 low_bound
= fold_convert (sizetype
, low_bound
);
4858 && TREE_CODE (length
) == INTEGER_CST
4859 && TYPE_PRECISION (TREE_TYPE (length
))
4860 > TYPE_PRECISION (sizetype
))
4861 length
= fold_convert (sizetype
, length
);
4862 if (low_bound
== NULL_TREE
)
4863 low_bound
= integer_zero_node
;
4865 if (length
!= NULL_TREE
)
4867 if (!integer_nonzerop (length
))
4869 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_DEPEND
4870 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
4871 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_IN_REDUCTION
4872 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_TASK_REDUCTION
)
4874 if (integer_zerop (length
))
4876 error_at (OMP_CLAUSE_LOCATION (c
),
4877 "zero length array section in %qs clause",
4878 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
4879 return error_mark_node
;
4883 maybe_zero_len
= true;
4885 if (first_non_one
== types
.length ()
4886 && (TREE_CODE (length
) != INTEGER_CST
|| integer_onep (length
)))
4889 if (TREE_CODE (type
) == ARRAY_TYPE
)
4891 if (length
== NULL_TREE
4892 && (TYPE_DOMAIN (type
) == NULL_TREE
4893 || TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) == NULL_TREE
))
4895 error_at (OMP_CLAUSE_LOCATION (c
),
4896 "for unknown bound array type length expression must "
4898 return error_mark_node
;
4900 if (TREE_CODE (low_bound
) == INTEGER_CST
4901 && tree_int_cst_sgn (low_bound
) == -1)
4903 error_at (OMP_CLAUSE_LOCATION (c
),
4904 "negative low bound in array section in %qs clause",
4905 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
4906 return error_mark_node
;
4908 if (length
!= NULL_TREE
4909 && TREE_CODE (length
) == INTEGER_CST
4910 && tree_int_cst_sgn (length
) == -1)
4912 error_at (OMP_CLAUSE_LOCATION (c
),
4913 "negative length in array section in %qs clause",
4914 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
4915 return error_mark_node
;
4917 if (TYPE_DOMAIN (type
)
4918 && TYPE_MAX_VALUE (TYPE_DOMAIN (type
))
4919 && TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)))
4923 = fold_convert (sizetype
, TYPE_MAX_VALUE (TYPE_DOMAIN (type
)));
4924 size
= size_binop (PLUS_EXPR
, size
, size_one_node
);
4925 if (TREE_CODE (low_bound
) == INTEGER_CST
)
4927 if (tree_int_cst_lt (size
, low_bound
))
4929 error_at (OMP_CLAUSE_LOCATION (c
),
4930 "low bound %qE above array section size "
4931 "in %qs clause", low_bound
,
4932 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
4933 return error_mark_node
;
4935 if (tree_int_cst_equal (size
, low_bound
))
4937 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_DEPEND
4938 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
4939 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_IN_REDUCTION
4940 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_TASK_REDUCTION
)
4942 error_at (OMP_CLAUSE_LOCATION (c
),
4943 "zero length array section in %qs clause",
4944 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
4945 return error_mark_node
;
4947 maybe_zero_len
= true;
4949 else if (length
== NULL_TREE
4950 && first_non_one
== types
.length ()
4951 && tree_int_cst_equal
4952 (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)),
4956 else if (length
== NULL_TREE
)
4958 if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_DEPEND
4959 && OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_REDUCTION
4960 && OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_IN_REDUCTION
4961 && OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_TASK_REDUCTION
)
4962 maybe_zero_len
= true;
4963 if (first_non_one
== types
.length ())
4966 if (length
&& TREE_CODE (length
) == INTEGER_CST
)
4968 if (tree_int_cst_lt (size
, length
))
4970 error_at (OMP_CLAUSE_LOCATION (c
),
4971 "length %qE above array section size "
4972 "in %qs clause", length
,
4973 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
4974 return error_mark_node
;
4976 if (TREE_CODE (low_bound
) == INTEGER_CST
)
4979 = size_binop (PLUS_EXPR
,
4980 fold_convert (sizetype
, low_bound
),
4981 fold_convert (sizetype
, length
));
4982 if (TREE_CODE (lbpluslen
) == INTEGER_CST
4983 && tree_int_cst_lt (size
, lbpluslen
))
4985 error_at (OMP_CLAUSE_LOCATION (c
),
4986 "high bound %qE above array section size "
4987 "in %qs clause", lbpluslen
,
4988 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
4989 return error_mark_node
;
4994 else if (length
== NULL_TREE
)
4996 if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_DEPEND
4997 && OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_REDUCTION
4998 && OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_IN_REDUCTION
4999 && OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_TASK_REDUCTION
)
5000 maybe_zero_len
= true;
5001 if (first_non_one
== types
.length ())
5005 /* For [lb:] we will need to evaluate lb more than once. */
5006 if (length
== NULL_TREE
&& OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_DEPEND
)
5008 tree lb
= cp_save_expr (low_bound
);
5009 if (lb
!= low_bound
)
5011 TREE_PURPOSE (t
) = lb
;
5016 else if (TYPE_PTR_P (type
))
5018 if (length
== NULL_TREE
)
5020 error_at (OMP_CLAUSE_LOCATION (c
),
5021 "for pointer type length expression must be specified");
5022 return error_mark_node
;
5024 if (length
!= NULL_TREE
5025 && TREE_CODE (length
) == INTEGER_CST
5026 && tree_int_cst_sgn (length
) == -1)
5028 error_at (OMP_CLAUSE_LOCATION (c
),
5029 "negative length in array section in %qs clause",
5030 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
5031 return error_mark_node
;
5033 /* If there is a pointer type anywhere but in the very first
5034 array-section-subscript, the array section can't be contiguous. */
5035 if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_DEPEND
5036 && TREE_CODE (TREE_CHAIN (t
)) == TREE_LIST
)
5038 error_at (OMP_CLAUSE_LOCATION (c
),
5039 "array section is not contiguous in %qs clause",
5040 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
5041 return error_mark_node
;
5046 error_at (OMP_CLAUSE_LOCATION (c
),
5047 "%qE does not have pointer or array type", ret
);
5048 return error_mark_node
;
5050 if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_DEPEND
)
5051 types
.safe_push (TREE_TYPE (ret
));
5052 /* We will need to evaluate lb more than once. */
5053 tree lb
= cp_save_expr (low_bound
);
5054 if (lb
!= low_bound
)
5056 TREE_PURPOSE (t
) = lb
;
5059 /* Temporarily disable -fstrong-eval-order for array reductions.
5060 The SAVE_EXPR and COMPOUND_EXPR added if low_bound has side-effects
5061 is something the middle-end can't cope with and more importantly,
5062 it needs to be the actual base variable that is privatized, not some
5063 temporary assigned previous value of it. That, together with OpenMP
5064 saying how many times the side-effects are evaluated is unspecified,
5065 makes int *a, *b; ... reduction(+:a[a = b, 3:10]) really unspecified. */
5066 warning_sentinel
s (flag_strong_eval_order
,
5067 OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
5068 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_IN_REDUCTION
5069 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_TASK_REDUCTION
);
5070 ret
= grok_array_decl (OMP_CLAUSE_LOCATION (c
), ret
, low_bound
, false);
5074 /* Handle array sections for clause C. */
5077 handle_omp_array_sections (tree c
, enum c_omp_region_type ort
)
5079 bool maybe_zero_len
= false;
5080 unsigned int first_non_one
= 0;
5081 auto_vec
<tree
, 10> types
;
5082 tree
*tp
= &OMP_CLAUSE_DECL (c
);
5083 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_DEPEND
5084 && TREE_CODE (*tp
) == TREE_LIST
5085 && TREE_PURPOSE (*tp
)
5086 && TREE_CODE (TREE_PURPOSE (*tp
)) == TREE_VEC
)
5087 tp
= &TREE_VALUE (*tp
);
5088 tree first
= handle_omp_array_sections_1 (c
, *tp
, types
,
5089 maybe_zero_len
, first_non_one
,
5091 if (first
== error_mark_node
)
5093 if (first
== NULL_TREE
)
5095 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_DEPEND
)
5098 tree tem
= NULL_TREE
;
5099 if (processing_template_decl
)
5101 /* Need to evaluate side effects in the length expressions
5103 while (TREE_CODE (t
) == TREE_LIST
)
5105 if (TREE_VALUE (t
) && TREE_SIDE_EFFECTS (TREE_VALUE (t
)))
5107 if (tem
== NULL_TREE
)
5108 tem
= TREE_VALUE (t
);
5110 tem
= build2 (COMPOUND_EXPR
, TREE_TYPE (tem
),
5111 TREE_VALUE (t
), tem
);
5116 first
= build2 (COMPOUND_EXPR
, TREE_TYPE (first
), tem
, first
);
5121 unsigned int num
= types
.length (), i
;
5122 tree t
, side_effects
= NULL_TREE
, size
= NULL_TREE
;
5123 tree condition
= NULL_TREE
;
5125 if (int_size_in_bytes (TREE_TYPE (first
)) <= 0)
5126 maybe_zero_len
= true;
5127 if (processing_template_decl
&& maybe_zero_len
)
5130 for (i
= num
, t
= OMP_CLAUSE_DECL (c
); i
> 0;
5133 tree low_bound
= TREE_PURPOSE (t
);
5134 tree length
= TREE_VALUE (t
);
5138 && TREE_CODE (low_bound
) == INTEGER_CST
5139 && TYPE_PRECISION (TREE_TYPE (low_bound
))
5140 > TYPE_PRECISION (sizetype
))
5141 low_bound
= fold_convert (sizetype
, low_bound
);
5143 && TREE_CODE (length
) == INTEGER_CST
5144 && TYPE_PRECISION (TREE_TYPE (length
))
5145 > TYPE_PRECISION (sizetype
))
5146 length
= fold_convert (sizetype
, length
);
5147 if (low_bound
== NULL_TREE
)
5148 low_bound
= integer_zero_node
;
5149 if (!maybe_zero_len
&& i
> first_non_one
)
5151 if (integer_nonzerop (low_bound
))
5152 goto do_warn_noncontiguous
;
5153 if (length
!= NULL_TREE
5154 && TREE_CODE (length
) == INTEGER_CST
5155 && TYPE_DOMAIN (types
[i
])
5156 && TYPE_MAX_VALUE (TYPE_DOMAIN (types
[i
]))
5157 && TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (types
[i
])))
5161 size
= size_binop (PLUS_EXPR
,
5162 TYPE_MAX_VALUE (TYPE_DOMAIN (types
[i
])),
5164 if (!tree_int_cst_equal (length
, size
))
5166 do_warn_noncontiguous
:
5167 error_at (OMP_CLAUSE_LOCATION (c
),
5168 "array section is not contiguous in %qs "
5170 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
5174 if (!processing_template_decl
5175 && length
!= NULL_TREE
5176 && TREE_SIDE_EFFECTS (length
))
5178 if (side_effects
== NULL_TREE
)
5179 side_effects
= length
;
5181 side_effects
= build2 (COMPOUND_EXPR
,
5182 TREE_TYPE (side_effects
),
5183 length
, side_effects
);
5186 else if (processing_template_decl
)
5192 if (i
> first_non_one
5193 && ((length
&& integer_nonzerop (length
))
5194 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
5195 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_IN_REDUCTION
5196 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_TASK_REDUCTION
))
5199 l
= fold_convert (sizetype
, length
);
5202 l
= size_binop (PLUS_EXPR
,
5203 TYPE_MAX_VALUE (TYPE_DOMAIN (types
[i
])),
5205 l
= size_binop (MINUS_EXPR
, l
,
5206 fold_convert (sizetype
, low_bound
));
5208 if (i
> first_non_one
)
5210 l
= fold_build2 (NE_EXPR
, boolean_type_node
, l
,
5212 if (condition
== NULL_TREE
)
5215 condition
= fold_build2 (BIT_AND_EXPR
, boolean_type_node
,
5218 else if (size
== NULL_TREE
)
5220 size
= size_in_bytes (TREE_TYPE (types
[i
]));
5221 tree eltype
= TREE_TYPE (types
[num
- 1]);
5222 while (TREE_CODE (eltype
) == ARRAY_TYPE
)
5223 eltype
= TREE_TYPE (eltype
);
5224 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
5225 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_IN_REDUCTION
5226 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_TASK_REDUCTION
)
5227 size
= size_binop (EXACT_DIV_EXPR
, size
,
5228 size_in_bytes (eltype
));
5229 size
= size_binop (MULT_EXPR
, size
, l
);
5231 size
= fold_build3 (COND_EXPR
, sizetype
, condition
,
5232 size
, size_zero_node
);
5235 size
= size_binop (MULT_EXPR
, size
, l
);
5238 if (!processing_template_decl
)
5241 size
= build2 (COMPOUND_EXPR
, sizetype
, side_effects
, size
);
5242 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
5243 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_IN_REDUCTION
5244 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_TASK_REDUCTION
)
5246 size
= size_binop (MINUS_EXPR
, size
, size_one_node
);
5247 size
= save_expr (size
);
5248 tree index_type
= build_index_type (size
);
5249 tree eltype
= TREE_TYPE (first
);
5250 while (TREE_CODE (eltype
) == ARRAY_TYPE
)
5251 eltype
= TREE_TYPE (eltype
);
5252 tree type
= build_array_type (eltype
, index_type
);
5253 tree ptype
= build_pointer_type (eltype
);
5254 if (TYPE_REF_P (TREE_TYPE (t
))
5255 && INDIRECT_TYPE_P (TREE_TYPE (TREE_TYPE (t
))))
5256 t
= convert_from_reference (t
);
5257 else if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
5258 t
= build_fold_addr_expr (t
);
5259 tree t2
= build_fold_addr_expr (first
);
5260 t2
= fold_convert_loc (OMP_CLAUSE_LOCATION (c
),
5261 ptrdiff_type_node
, t2
);
5262 t2
= fold_build2_loc (OMP_CLAUSE_LOCATION (c
), MINUS_EXPR
,
5263 ptrdiff_type_node
, t2
,
5264 fold_convert_loc (OMP_CLAUSE_LOCATION (c
),
5265 ptrdiff_type_node
, t
));
5266 if (tree_fits_shwi_p (t2
))
5267 t
= build2 (MEM_REF
, type
, t
,
5268 build_int_cst (ptype
, tree_to_shwi (t2
)));
5271 t2
= fold_convert_loc (OMP_CLAUSE_LOCATION (c
),
5273 t
= build2_loc (OMP_CLAUSE_LOCATION (c
), POINTER_PLUS_EXPR
,
5274 TREE_TYPE (t
), t
, t2
);
5275 t
= build2 (MEM_REF
, type
, t
, build_int_cst (ptype
, 0));
5277 OMP_CLAUSE_DECL (c
) = t
;
5280 OMP_CLAUSE_DECL (c
) = first
;
5281 OMP_CLAUSE_SIZE (c
) = size
;
5282 if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_MAP
5283 || (TREE_CODE (t
) == COMPONENT_REF
5284 && TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
))
5286 if (ort
== C_ORT_OMP
|| ort
== C_ORT_ACC
)
5287 switch (OMP_CLAUSE_MAP_KIND (c
))
5289 case GOMP_MAP_ALLOC
:
5292 case GOMP_MAP_TOFROM
:
5293 case GOMP_MAP_ALWAYS_TO
:
5294 case GOMP_MAP_ALWAYS_FROM
:
5295 case GOMP_MAP_ALWAYS_TOFROM
:
5296 case GOMP_MAP_RELEASE
:
5297 case GOMP_MAP_DELETE
:
5298 case GOMP_MAP_FORCE_TO
:
5299 case GOMP_MAP_FORCE_FROM
:
5300 case GOMP_MAP_FORCE_TOFROM
:
5301 case GOMP_MAP_FORCE_PRESENT
:
5302 OMP_CLAUSE_MAP_MAYBE_ZERO_LENGTH_ARRAY_SECTION (c
) = 1;
5307 tree c2
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
5309 if ((ort
& C_ORT_OMP_DECLARE_SIMD
) != C_ORT_OMP
&& ort
!= C_ORT_ACC
)
5310 OMP_CLAUSE_SET_MAP_KIND (c2
, GOMP_MAP_POINTER
);
5311 else if (TREE_CODE (t
) == COMPONENT_REF
)
5312 OMP_CLAUSE_SET_MAP_KIND (c2
, GOMP_MAP_ALWAYS_POINTER
);
5313 else if (REFERENCE_REF_P (t
)
5314 && TREE_CODE (TREE_OPERAND (t
, 0)) == COMPONENT_REF
)
5316 t
= TREE_OPERAND (t
, 0);
5317 OMP_CLAUSE_SET_MAP_KIND (c2
, GOMP_MAP_ALWAYS_POINTER
);
5320 OMP_CLAUSE_SET_MAP_KIND (c2
, GOMP_MAP_FIRSTPRIVATE_POINTER
);
5321 if (OMP_CLAUSE_MAP_KIND (c2
) != GOMP_MAP_FIRSTPRIVATE_POINTER
5322 && !cxx_mark_addressable (t
))
5324 OMP_CLAUSE_DECL (c2
) = t
;
5325 t
= build_fold_addr_expr (first
);
5326 t
= fold_convert_loc (OMP_CLAUSE_LOCATION (c
),
5327 ptrdiff_type_node
, t
);
5328 tree ptr
= OMP_CLAUSE_DECL (c2
);
5329 ptr
= convert_from_reference (ptr
);
5330 if (!INDIRECT_TYPE_P (TREE_TYPE (ptr
)))
5331 ptr
= build_fold_addr_expr (ptr
);
5332 t
= fold_build2_loc (OMP_CLAUSE_LOCATION (c
), MINUS_EXPR
,
5333 ptrdiff_type_node
, t
,
5334 fold_convert_loc (OMP_CLAUSE_LOCATION (c
),
5335 ptrdiff_type_node
, ptr
));
5336 OMP_CLAUSE_SIZE (c2
) = t
;
5337 OMP_CLAUSE_CHAIN (c2
) = OMP_CLAUSE_CHAIN (c
);
5338 OMP_CLAUSE_CHAIN (c
) = c2
;
5339 ptr
= OMP_CLAUSE_DECL (c2
);
5340 if (OMP_CLAUSE_MAP_KIND (c2
) != GOMP_MAP_FIRSTPRIVATE_POINTER
5341 && TYPE_REF_P (TREE_TYPE (ptr
))
5342 && INDIRECT_TYPE_P (TREE_TYPE (TREE_TYPE (ptr
))))
5344 tree c3
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
5346 OMP_CLAUSE_SET_MAP_KIND (c3
, OMP_CLAUSE_MAP_KIND (c2
));
5347 OMP_CLAUSE_DECL (c3
) = ptr
;
5348 if (OMP_CLAUSE_MAP_KIND (c2
) == GOMP_MAP_ALWAYS_POINTER
)
5349 OMP_CLAUSE_DECL (c2
) = build_simple_mem_ref (ptr
);
5351 OMP_CLAUSE_DECL (c2
) = convert_from_reference (ptr
);
5352 OMP_CLAUSE_SIZE (c3
) = size_zero_node
;
5353 OMP_CLAUSE_CHAIN (c3
) = OMP_CLAUSE_CHAIN (c2
);
5354 OMP_CLAUSE_CHAIN (c2
) = c3
;
5361 /* Return identifier to look up for omp declare reduction. */
5364 omp_reduction_id (enum tree_code reduction_code
, tree reduction_id
, tree type
)
5366 const char *p
= NULL
;
5367 const char *m
= NULL
;
5368 switch (reduction_code
)
5376 case TRUTH_ANDIF_EXPR
:
5377 case TRUTH_ORIF_EXPR
:
5378 reduction_id
= ovl_op_identifier (false, reduction_code
);
5392 if (TREE_CODE (reduction_id
) != IDENTIFIER_NODE
)
5393 return error_mark_node
;
5394 p
= IDENTIFIER_POINTER (reduction_id
);
5397 if (type
!= NULL_TREE
)
5398 m
= mangle_type_string (TYPE_MAIN_VARIANT (type
));
5400 const char prefix
[] = "omp declare reduction ";
5401 size_t lenp
= sizeof (prefix
);
5402 if (strncmp (p
, prefix
, lenp
- 1) == 0)
5404 size_t len
= strlen (p
);
5405 size_t lenm
= m
? strlen (m
) + 1 : 0;
5406 char *name
= XALLOCAVEC (char, lenp
+ len
+ lenm
);
5408 memcpy (name
, prefix
, lenp
- 1);
5409 memcpy (name
+ lenp
- 1, p
, len
+ 1);
5412 name
[lenp
+ len
- 1] = '~';
5413 memcpy (name
+ lenp
+ len
, m
, lenm
);
5415 return get_identifier (name
);
5418 /* Lookup OpenMP UDR ID for TYPE, return the corresponding artificial
5419 FUNCTION_DECL or NULL_TREE if not found. */
5422 omp_reduction_lookup (location_t loc
, tree id
, tree type
, tree
*baselinkp
,
5423 vec
<tree
> *ambiguousp
)
5426 tree baselink
= NULL_TREE
;
5427 if (identifier_p (id
))
5430 bool nonint_cst_expression_p
;
5431 const char *error_msg
;
5432 id
= omp_reduction_id (ERROR_MARK
, id
, type
);
5433 tree decl
= lookup_name (id
);
5434 if (decl
== NULL_TREE
)
5435 decl
= error_mark_node
;
5436 id
= finish_id_expression (id
, decl
, NULL_TREE
, &idk
, false, true,
5437 &nonint_cst_expression_p
, false, true, false,
5438 false, &error_msg
, loc
);
5439 if (idk
== CP_ID_KIND_UNQUALIFIED
5440 && identifier_p (id
))
5442 vec
<tree
, va_gc
> *args
= NULL
;
5443 vec_safe_push (args
, build_reference_type (type
));
5444 id
= perform_koenig_lookup (id
, args
, tf_none
);
5447 else if (TREE_CODE (id
) == SCOPE_REF
)
5448 id
= lookup_qualified_name (TREE_OPERAND (id
, 0),
5449 omp_reduction_id (ERROR_MARK
,
5450 TREE_OPERAND (id
, 1),
5455 if (fns
&& is_overloaded_fn (fns
))
5457 for (lkp_iterator
iter (get_fns (fns
)); iter
; ++iter
)
5459 tree fndecl
= *iter
;
5460 if (TREE_CODE (fndecl
) == FUNCTION_DECL
)
5462 tree argtype
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (fndecl
)));
5463 if (same_type_p (TREE_TYPE (argtype
), type
))
5471 if (id
&& BASELINK_P (fns
))
5480 if (!id
&& CLASS_TYPE_P (type
) && TYPE_BINFO (type
))
5482 vec
<tree
> ambiguous
= vNULL
;
5483 tree binfo
= TYPE_BINFO (type
), base_binfo
, ret
= NULL_TREE
;
5485 if (ambiguousp
== NULL
)
5486 ambiguousp
= &ambiguous
;
5487 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
5489 id
= omp_reduction_lookup (loc
, orig_id
, BINFO_TYPE (base_binfo
),
5490 baselinkp
? baselinkp
: &baselink
,
5492 if (id
== NULL_TREE
)
5494 if (!ambiguousp
->is_empty ())
5495 ambiguousp
->safe_push (id
);
5496 else if (ret
!= NULL_TREE
)
5498 ambiguousp
->safe_push (ret
);
5499 ambiguousp
->safe_push (id
);
5505 if (ambiguousp
!= &ambiguous
)
5507 if (!ambiguous
.is_empty ())
5509 const char *str
= _("candidates are:");
5512 error_at (loc
, "user defined reduction lookup is ambiguous");
5513 FOR_EACH_VEC_ELT (ambiguous
, idx
, udr
)
5515 inform (DECL_SOURCE_LOCATION (udr
), "%s %#qD", str
, udr
);
5517 str
= get_spaces (str
);
5519 ambiguous
.release ();
5520 ret
= error_mark_node
;
5521 baselink
= NULL_TREE
;
5526 perform_or_defer_access_check (BASELINK_BINFO (baselink
),
5527 id
, id
, tf_warning_or_error
);
5531 /* Helper function for cp_parser_omp_declare_reduction_exprs
5533 Remove CLEANUP_STMT for data (omp_priv variable).
5534 Also append INIT_EXPR for DECL_INITIAL of omp_priv after its
5538 cp_remove_omp_priv_cleanup_stmt (tree
*tp
, int *walk_subtrees
, void *data
)
5542 else if (TREE_CODE (*tp
) == CLEANUP_STMT
&& CLEANUP_DECL (*tp
) == (tree
) data
)
5543 *tp
= CLEANUP_BODY (*tp
);
5544 else if (TREE_CODE (*tp
) == DECL_EXPR
)
5546 tree decl
= DECL_EXPR_DECL (*tp
);
5547 if (!processing_template_decl
5548 && decl
== (tree
) data
5549 && DECL_INITIAL (decl
)
5550 && DECL_INITIAL (decl
) != error_mark_node
)
5552 tree list
= NULL_TREE
;
5553 append_to_statement_list_force (*tp
, &list
);
5554 tree init_expr
= build2 (INIT_EXPR
, void_type_node
,
5555 decl
, DECL_INITIAL (decl
));
5556 DECL_INITIAL (decl
) = NULL_TREE
;
5557 append_to_statement_list_force (init_expr
, &list
);
5564 /* Data passed from cp_check_omp_declare_reduction to
5565 cp_check_omp_declare_reduction_r. */
5567 struct cp_check_omp_declare_reduction_data
5574 /* Helper function for cp_check_omp_declare_reduction, called via
5578 cp_check_omp_declare_reduction_r (tree
*tp
, int *, void *data
)
5580 struct cp_check_omp_declare_reduction_data
*udr_data
5581 = (struct cp_check_omp_declare_reduction_data
*) data
;
5583 && !DECL_ARTIFICIAL (*tp
)
5584 && *tp
!= DECL_EXPR_DECL (udr_data
->stmts
[udr_data
->combiner_p
? 0 : 3])
5585 && *tp
!= DECL_EXPR_DECL (udr_data
->stmts
[udr_data
->combiner_p
? 1 : 4]))
5587 location_t loc
= udr_data
->loc
;
5588 if (udr_data
->combiner_p
)
5589 error_at (loc
, "%<#pragma omp declare reduction%> combiner refers to "
5590 "variable %qD which is not %<omp_out%> nor %<omp_in%>",
5593 error_at (loc
, "%<#pragma omp declare reduction%> initializer refers "
5594 "to variable %qD which is not %<omp_priv%> nor "
5602 /* Diagnose violation of OpenMP #pragma omp declare reduction restrictions. */
5605 cp_check_omp_declare_reduction (tree udr
)
5607 tree type
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (udr
)));
5608 gcc_assert (TYPE_REF_P (type
));
5609 type
= TREE_TYPE (type
);
5611 location_t loc
= DECL_SOURCE_LOCATION (udr
);
5613 if (type
== error_mark_node
)
5615 if (ARITHMETIC_TYPE_P (type
))
5617 static enum tree_code predef_codes
[]
5618 = { PLUS_EXPR
, MULT_EXPR
, MINUS_EXPR
, BIT_AND_EXPR
, BIT_XOR_EXPR
,
5619 BIT_IOR_EXPR
, TRUTH_ANDIF_EXPR
, TRUTH_ORIF_EXPR
};
5620 for (i
= 0; i
< 8; i
++)
5622 tree id
= omp_reduction_id (predef_codes
[i
], NULL_TREE
, NULL_TREE
);
5623 const char *n1
= IDENTIFIER_POINTER (DECL_NAME (udr
));
5624 const char *n2
= IDENTIFIER_POINTER (id
);
5625 if (strncmp (n1
, n2
, IDENTIFIER_LENGTH (id
)) == 0
5626 && (n1
[IDENTIFIER_LENGTH (id
)] == '~'
5627 || n1
[IDENTIFIER_LENGTH (id
)] == '\0'))
5632 && TREE_CODE (type
) != COMPLEX_EXPR
)
5634 const char prefix_minmax
[] = "omp declare reduction m";
5635 size_t prefix_size
= sizeof (prefix_minmax
) - 1;
5636 const char *n
= IDENTIFIER_POINTER (DECL_NAME (udr
));
5637 if (strncmp (IDENTIFIER_POINTER (DECL_NAME (udr
)),
5638 prefix_minmax
, prefix_size
) == 0
5639 && ((n
[prefix_size
] == 'i' && n
[prefix_size
+ 1] == 'n')
5640 || (n
[prefix_size
] == 'a' && n
[prefix_size
+ 1] == 'x'))
5641 && (n
[prefix_size
+ 2] == '~' || n
[prefix_size
+ 2] == '\0'))
5646 error_at (loc
, "predeclared arithmetic type %qT in "
5647 "%<#pragma omp declare reduction%>", type
);
5651 else if (FUNC_OR_METHOD_TYPE_P (type
)
5652 || TREE_CODE (type
) == ARRAY_TYPE
)
5654 error_at (loc
, "function or array type %qT in "
5655 "%<#pragma omp declare reduction%>", type
);
5658 else if (TYPE_REF_P (type
))
5660 error_at (loc
, "reference type %qT in %<#pragma omp declare reduction%>",
5664 else if (TYPE_QUALS_NO_ADDR_SPACE (type
))
5666 error_at (loc
, "%<const%>, %<volatile%> or %<__restrict%>-qualified "
5667 "type %qT in %<#pragma omp declare reduction%>", type
);
5671 tree body
= DECL_SAVED_TREE (udr
);
5672 if (body
== NULL_TREE
|| TREE_CODE (body
) != STATEMENT_LIST
)
5675 tree_stmt_iterator tsi
;
5676 struct cp_check_omp_declare_reduction_data data
;
5677 memset (data
.stmts
, 0, sizeof data
.stmts
);
5678 for (i
= 0, tsi
= tsi_start (body
);
5679 i
< 7 && !tsi_end_p (tsi
);
5680 i
++, tsi_next (&tsi
))
5681 data
.stmts
[i
] = tsi_stmt (tsi
);
5683 gcc_assert (tsi_end_p (tsi
));
5686 gcc_assert (TREE_CODE (data
.stmts
[0]) == DECL_EXPR
5687 && TREE_CODE (data
.stmts
[1]) == DECL_EXPR
);
5688 if (TREE_NO_WARNING (DECL_EXPR_DECL (data
.stmts
[0])))
5690 data
.combiner_p
= true;
5691 if (cp_walk_tree (&data
.stmts
[2], cp_check_omp_declare_reduction_r
,
5693 TREE_NO_WARNING (DECL_EXPR_DECL (data
.stmts
[0])) = 1;
5697 gcc_assert (TREE_CODE (data
.stmts
[3]) == DECL_EXPR
5698 && TREE_CODE (data
.stmts
[4]) == DECL_EXPR
);
5699 data
.combiner_p
= false;
5700 if (cp_walk_tree (&data
.stmts
[5], cp_check_omp_declare_reduction_r
,
5702 || cp_walk_tree (&DECL_INITIAL (DECL_EXPR_DECL (data
.stmts
[3])),
5703 cp_check_omp_declare_reduction_r
, &data
, NULL
))
5704 TREE_NO_WARNING (DECL_EXPR_DECL (data
.stmts
[0])) = 1;
5706 gcc_assert (TREE_CODE (data
.stmts
[6]) == DECL_EXPR
);
5710 /* Helper function of finish_omp_clauses. Clone STMT as if we were making
5711 an inline call. But, remap
5712 the OMP_DECL1 VAR_DECL (omp_out resp. omp_orig) to PLACEHOLDER
5713 and OMP_DECL2 VAR_DECL (omp_in resp. omp_priv) to DECL. */
5716 clone_omp_udr (tree stmt
, tree omp_decl1
, tree omp_decl2
,
5717 tree decl
, tree placeholder
)
5720 hash_map
<tree
, tree
> decl_map
;
5722 decl_map
.put (omp_decl1
, placeholder
);
5723 decl_map
.put (omp_decl2
, decl
);
5724 memset (&id
, 0, sizeof (id
));
5725 id
.src_fn
= DECL_CONTEXT (omp_decl1
);
5726 id
.dst_fn
= current_function_decl
;
5727 id
.src_cfun
= DECL_STRUCT_FUNCTION (id
.src_fn
);
5728 id
.decl_map
= &decl_map
;
5730 id
.copy_decl
= copy_decl_no_change
;
5731 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
5732 id
.transform_new_cfg
= true;
5733 id
.transform_return_to_modify
= false;
5734 id
.transform_lang_insert_block
= NULL
;
5736 walk_tree (&stmt
, copy_tree_body_r
, &id
, NULL
);
5740 /* Helper function of finish_omp_clauses, called via cp_walk_tree.
5741 Find OMP_CLAUSE_PLACEHOLDER (passed in DATA) in *TP. */
5744 find_omp_placeholder_r (tree
*tp
, int *, void *data
)
5746 if (*tp
== (tree
) data
)
5751 /* Helper function of finish_omp_clauses. Handle OMP_CLAUSE_REDUCTION C.
5752 Return true if there is some error and the clause should be removed. */
5755 finish_omp_reduction_clause (tree c
, bool *need_default_ctor
, bool *need_dtor
)
5757 tree t
= OMP_CLAUSE_DECL (c
);
5758 bool predefined
= false;
5759 if (TREE_CODE (t
) == TREE_LIST
)
5761 gcc_assert (processing_template_decl
);
5764 tree type
= TREE_TYPE (t
);
5765 if (TREE_CODE (t
) == MEM_REF
)
5766 type
= TREE_TYPE (type
);
5767 if (TYPE_REF_P (type
))
5768 type
= TREE_TYPE (type
);
5769 if (TREE_CODE (type
) == ARRAY_TYPE
)
5772 gcc_assert (TREE_CODE (t
) != MEM_REF
);
5773 while (TREE_CODE (type
) == ARRAY_TYPE
)
5774 type
= TREE_TYPE (type
);
5775 if (!processing_template_decl
)
5777 t
= require_complete_type (t
);
5778 if (t
== error_mark_node
)
5780 tree size
= size_binop (EXACT_DIV_EXPR
, TYPE_SIZE_UNIT (oatype
),
5781 TYPE_SIZE_UNIT (type
));
5782 if (integer_zerop (size
))
5784 error_at (OMP_CLAUSE_LOCATION (c
),
5785 "%qE in %<reduction%> clause is a zero size array",
5786 omp_clause_printable_decl (t
));
5789 size
= size_binop (MINUS_EXPR
, size
, size_one_node
);
5790 size
= save_expr (size
);
5791 tree index_type
= build_index_type (size
);
5792 tree atype
= build_array_type (type
, index_type
);
5793 tree ptype
= build_pointer_type (type
);
5794 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
5795 t
= build_fold_addr_expr (t
);
5796 t
= build2 (MEM_REF
, atype
, t
, build_int_cst (ptype
, 0));
5797 OMP_CLAUSE_DECL (c
) = t
;
5800 if (type
== error_mark_node
)
5802 else if (ARITHMETIC_TYPE_P (type
))
5803 switch (OMP_CLAUSE_REDUCTION_CODE (c
))
5812 if (TREE_CODE (type
) == COMPLEX_TYPE
)
5819 if (FLOAT_TYPE_P (type
) || TREE_CODE (type
) == COMPLEX_TYPE
)
5823 case TRUTH_ANDIF_EXPR
:
5824 case TRUTH_ORIF_EXPR
:
5825 if (FLOAT_TYPE_P (type
))
5832 else if (TYPE_READONLY (type
))
5834 error_at (OMP_CLAUSE_LOCATION (c
),
5835 "%qE has const type for %<reduction%>",
5836 omp_clause_printable_decl (t
));
5839 else if (!processing_template_decl
)
5841 t
= require_complete_type (t
);
5842 if (t
== error_mark_node
)
5844 OMP_CLAUSE_DECL (c
) = t
;
5849 OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
) = NULL_TREE
;
5852 else if (processing_template_decl
)
5854 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
) == error_mark_node
)
5859 tree id
= OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
);
5861 type
= TYPE_MAIN_VARIANT (type
);
5862 OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
) = NULL_TREE
;
5863 if (id
== NULL_TREE
)
5864 id
= omp_reduction_id (OMP_CLAUSE_REDUCTION_CODE (c
),
5865 NULL_TREE
, NULL_TREE
);
5866 id
= omp_reduction_lookup (OMP_CLAUSE_LOCATION (c
), id
, type
, NULL
, NULL
);
5869 if (id
== error_mark_node
)
5872 tree body
= DECL_SAVED_TREE (id
);
5875 if (TREE_CODE (body
) == STATEMENT_LIST
)
5877 tree_stmt_iterator tsi
;
5878 tree placeholder
= NULL_TREE
, decl_placeholder
= NULL_TREE
;
5881 tree atype
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (id
)));
5882 atype
= TREE_TYPE (atype
);
5883 bool need_static_cast
= !same_type_p (type
, atype
);
5884 memset (stmts
, 0, sizeof stmts
);
5885 for (i
= 0, tsi
= tsi_start (body
);
5886 i
< 7 && !tsi_end_p (tsi
);
5887 i
++, tsi_next (&tsi
))
5888 stmts
[i
] = tsi_stmt (tsi
);
5889 gcc_assert (tsi_end_p (tsi
));
5893 gcc_assert (TREE_CODE (stmts
[0]) == DECL_EXPR
5894 && TREE_CODE (stmts
[1]) == DECL_EXPR
);
5895 placeholder
= build_lang_decl (VAR_DECL
, NULL_TREE
, type
);
5896 DECL_ARTIFICIAL (placeholder
) = 1;
5897 DECL_IGNORED_P (placeholder
) = 1;
5898 OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
) = placeholder
;
5899 if (TREE_CODE (t
) == MEM_REF
)
5901 decl_placeholder
= build_lang_decl (VAR_DECL
, NULL_TREE
,
5903 DECL_ARTIFICIAL (decl_placeholder
) = 1;
5904 DECL_IGNORED_P (decl_placeholder
) = 1;
5905 OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (c
) = decl_placeholder
;
5907 if (TREE_ADDRESSABLE (DECL_EXPR_DECL (stmts
[0])))
5908 cxx_mark_addressable (placeholder
);
5909 if (TREE_ADDRESSABLE (DECL_EXPR_DECL (stmts
[1]))
5910 && (decl_placeholder
5911 || !TYPE_REF_P (TREE_TYPE (OMP_CLAUSE_DECL (c
)))))
5912 cxx_mark_addressable (decl_placeholder
? decl_placeholder
5913 : OMP_CLAUSE_DECL (c
));
5914 tree omp_out
= placeholder
;
5915 tree omp_in
= decl_placeholder
? decl_placeholder
5916 : convert_from_reference (OMP_CLAUSE_DECL (c
));
5917 if (need_static_cast
)
5919 tree rtype
= build_reference_type (atype
);
5920 omp_out
= build_static_cast (rtype
, omp_out
,
5921 tf_warning_or_error
);
5922 omp_in
= build_static_cast (rtype
, omp_in
,
5923 tf_warning_or_error
);
5924 if (omp_out
== error_mark_node
|| omp_in
== error_mark_node
)
5926 omp_out
= convert_from_reference (omp_out
);
5927 omp_in
= convert_from_reference (omp_in
);
5929 OMP_CLAUSE_REDUCTION_MERGE (c
)
5930 = clone_omp_udr (stmts
[2], DECL_EXPR_DECL (stmts
[0]),
5931 DECL_EXPR_DECL (stmts
[1]), omp_in
, omp_out
);
5935 gcc_assert (TREE_CODE (stmts
[3]) == DECL_EXPR
5936 && TREE_CODE (stmts
[4]) == DECL_EXPR
);
5937 if (TREE_ADDRESSABLE (DECL_EXPR_DECL (stmts
[3]))
5938 && (decl_placeholder
5939 || !TYPE_REF_P (TREE_TYPE (OMP_CLAUSE_DECL (c
)))))
5940 cxx_mark_addressable (decl_placeholder
? decl_placeholder
5941 : OMP_CLAUSE_DECL (c
));
5942 if (TREE_ADDRESSABLE (DECL_EXPR_DECL (stmts
[4])))
5943 cxx_mark_addressable (placeholder
);
5944 tree omp_priv
= decl_placeholder
? decl_placeholder
5945 : convert_from_reference (OMP_CLAUSE_DECL (c
));
5946 tree omp_orig
= placeholder
;
5947 if (need_static_cast
)
5951 error_at (OMP_CLAUSE_LOCATION (c
),
5952 "user defined reduction with constructor "
5953 "initializer for base class %qT", atype
);
5956 tree rtype
= build_reference_type (atype
);
5957 omp_priv
= build_static_cast (rtype
, omp_priv
,
5958 tf_warning_or_error
);
5959 omp_orig
= build_static_cast (rtype
, omp_orig
,
5960 tf_warning_or_error
);
5961 if (omp_priv
== error_mark_node
5962 || omp_orig
== error_mark_node
)
5964 omp_priv
= convert_from_reference (omp_priv
);
5965 omp_orig
= convert_from_reference (omp_orig
);
5968 *need_default_ctor
= true;
5969 OMP_CLAUSE_REDUCTION_INIT (c
)
5970 = clone_omp_udr (stmts
[5], DECL_EXPR_DECL (stmts
[4]),
5971 DECL_EXPR_DECL (stmts
[3]),
5972 omp_priv
, omp_orig
);
5973 if (cp_walk_tree (&OMP_CLAUSE_REDUCTION_INIT (c
),
5974 find_omp_placeholder_r
, placeholder
, NULL
))
5975 OMP_CLAUSE_REDUCTION_OMP_ORIG_REF (c
) = 1;
5979 if (CLASS_TYPE_P (type
) && !pod_type_p (type
))
5980 *need_default_ctor
= true;
5984 tree v
= decl_placeholder
? decl_placeholder
5985 : convert_from_reference (t
);
5986 if (AGGREGATE_TYPE_P (TREE_TYPE (v
)))
5987 init
= build_constructor (TREE_TYPE (v
), NULL
);
5989 init
= fold_convert (TREE_TYPE (v
), integer_zero_node
);
5990 OMP_CLAUSE_REDUCTION_INIT (c
)
5991 = build2 (INIT_EXPR
, TREE_TYPE (v
), v
, init
);
5996 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
))
6000 error_at (OMP_CLAUSE_LOCATION (c
),
6001 "user defined reduction not found for %qE",
6002 omp_clause_printable_decl (t
));
6005 if (TREE_CODE (OMP_CLAUSE_DECL (c
)) == MEM_REF
)
6006 gcc_assert (TYPE_SIZE_UNIT (type
)
6007 && TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
);
6011 /* Called from finish_struct_1. linear(this) or linear(this:step)
6012 clauses might not be finalized yet because the class has been incomplete
6013 when parsing #pragma omp declare simd methods. Fix those up now. */
6016 finish_omp_declare_simd_methods (tree t
)
6018 if (processing_template_decl
)
6021 for (tree x
= TYPE_FIELDS (t
); x
; x
= DECL_CHAIN (x
))
6023 if (TREE_CODE (x
) == USING_DECL
6024 || !DECL_NONSTATIC_MEMBER_FUNCTION_P (x
))
6026 tree ods
= lookup_attribute ("omp declare simd", DECL_ATTRIBUTES (x
));
6027 if (!ods
|| !TREE_VALUE (ods
))
6029 for (tree c
= TREE_VALUE (TREE_VALUE (ods
)); c
; c
= OMP_CLAUSE_CHAIN (c
))
6030 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LINEAR
6031 && integer_zerop (OMP_CLAUSE_DECL (c
))
6032 && OMP_CLAUSE_LINEAR_STEP (c
)
6033 && TYPE_PTR_P (TREE_TYPE (OMP_CLAUSE_LINEAR_STEP (c
))))
6035 tree s
= OMP_CLAUSE_LINEAR_STEP (c
);
6036 s
= fold_convert_loc (OMP_CLAUSE_LOCATION (c
), sizetype
, s
);
6037 s
= fold_build2_loc (OMP_CLAUSE_LOCATION (c
), MULT_EXPR
,
6038 sizetype
, s
, TYPE_SIZE_UNIT (t
));
6039 OMP_CLAUSE_LINEAR_STEP (c
) = s
;
6044 /* Adjust sink depend clause to take into account pointer offsets.
6046 Return TRUE if there was a problem processing the offset, and the
6047 whole clause should be removed. */
6050 cp_finish_omp_clause_depend_sink (tree sink_clause
)
6052 tree t
= OMP_CLAUSE_DECL (sink_clause
);
6053 gcc_assert (TREE_CODE (t
) == TREE_LIST
);
6055 /* Make sure we don't adjust things twice for templates. */
6056 if (processing_template_decl
)
6059 for (; t
; t
= TREE_CHAIN (t
))
6061 tree decl
= TREE_VALUE (t
);
6062 if (TYPE_PTR_P (TREE_TYPE (decl
)))
6064 tree offset
= TREE_PURPOSE (t
);
6065 bool neg
= wi::neg_p (wi::to_wide (offset
));
6066 offset
= fold_unary (ABS_EXPR
, TREE_TYPE (offset
), offset
);
6067 decl
= mark_rvalue_use (decl
);
6068 decl
= convert_from_reference (decl
);
6069 tree t2
= pointer_int_sum (OMP_CLAUSE_LOCATION (sink_clause
),
6070 neg
? MINUS_EXPR
: PLUS_EXPR
,
6072 t2
= fold_build2_loc (OMP_CLAUSE_LOCATION (sink_clause
),
6073 MINUS_EXPR
, sizetype
,
6074 fold_convert (sizetype
, t2
),
6075 fold_convert (sizetype
, decl
));
6076 if (t2
== error_mark_node
)
6078 TREE_PURPOSE (t
) = t2
;
6084 /* Finish OpenMP iterators ITER. Return true if they are errorneous
6085 and clauses containing them should be removed. */
6088 cp_omp_finish_iterators (tree iter
)
6091 for (tree it
= iter
; it
; it
= TREE_CHAIN (it
))
6093 tree var
= TREE_VEC_ELT (it
, 0);
6094 tree begin
= TREE_VEC_ELT (it
, 1);
6095 tree end
= TREE_VEC_ELT (it
, 2);
6096 tree step
= TREE_VEC_ELT (it
, 3);
6098 tree type
= TREE_TYPE (var
);
6099 location_t loc
= DECL_SOURCE_LOCATION (var
);
6100 if (type
== error_mark_node
)
6105 if (type_dependent_expression_p (var
))
6107 if (!INTEGRAL_TYPE_P (type
) && !POINTER_TYPE_P (type
))
6109 error_at (loc
, "iterator %qD has neither integral nor pointer type",
6114 else if (TYPE_READONLY (type
))
6116 error_at (loc
, "iterator %qD has const qualified type", var
);
6120 if (type_dependent_expression_p (begin
)
6121 || type_dependent_expression_p (end
)
6122 || type_dependent_expression_p (step
))
6124 else if (error_operand_p (step
))
6129 else if (!INTEGRAL_TYPE_P (TREE_TYPE (step
)))
6131 error_at (EXPR_LOC_OR_LOC (step
, loc
),
6132 "iterator step with non-integral type");
6137 begin
= mark_rvalue_use (begin
);
6138 end
= mark_rvalue_use (end
);
6139 step
= mark_rvalue_use (step
);
6140 begin
= cp_build_c_cast (type
, begin
, tf_warning_or_error
);
6141 end
= cp_build_c_cast (type
, end
, tf_warning_or_error
);
6143 if (!processing_template_decl
)
6144 step
= orig_step
= save_expr (step
);
6145 tree stype
= POINTER_TYPE_P (type
) ? sizetype
: type
;
6146 step
= cp_build_c_cast (stype
, step
, tf_warning_or_error
);
6147 if (POINTER_TYPE_P (type
) && !processing_template_decl
)
6149 begin
= save_expr (begin
);
6150 step
= pointer_int_sum (loc
, PLUS_EXPR
, begin
, step
);
6151 step
= fold_build2_loc (loc
, MINUS_EXPR
, sizetype
,
6152 fold_convert (sizetype
, step
),
6153 fold_convert (sizetype
, begin
));
6154 step
= fold_convert (ssizetype
, step
);
6156 if (!processing_template_decl
)
6158 begin
= maybe_constant_value (begin
);
6159 end
= maybe_constant_value (end
);
6160 step
= maybe_constant_value (step
);
6161 orig_step
= maybe_constant_value (orig_step
);
6163 if (integer_zerop (step
))
6165 error_at (loc
, "iterator %qD has zero step", var
);
6170 if (begin
== error_mark_node
6171 || end
== error_mark_node
6172 || step
== error_mark_node
6173 || orig_step
== error_mark_node
)
6179 if (!processing_template_decl
)
6181 begin
= fold_build_cleanup_point_expr (TREE_TYPE (begin
), begin
);
6182 end
= fold_build_cleanup_point_expr (TREE_TYPE (end
), end
);
6183 step
= fold_build_cleanup_point_expr (TREE_TYPE (step
), step
);
6184 orig_step
= fold_build_cleanup_point_expr (TREE_TYPE (orig_step
),
6187 hash_set
<tree
> pset
;
6189 for (it2
= TREE_CHAIN (it
); it2
; it2
= TREE_CHAIN (it2
))
6191 tree var2
= TREE_VEC_ELT (it2
, 0);
6192 tree begin2
= TREE_VEC_ELT (it2
, 1);
6193 tree end2
= TREE_VEC_ELT (it2
, 2);
6194 tree step2
= TREE_VEC_ELT (it2
, 3);
6195 location_t loc2
= DECL_SOURCE_LOCATION (var2
);
6196 if (cp_walk_tree (&begin2
, find_omp_placeholder_r
, var
, &pset
))
6198 error_at (EXPR_LOC_OR_LOC (begin2
, loc2
),
6199 "begin expression refers to outer iterator %qD", var
);
6202 else if (cp_walk_tree (&end2
, find_omp_placeholder_r
, var
, &pset
))
6204 error_at (EXPR_LOC_OR_LOC (end2
, loc2
),
6205 "end expression refers to outer iterator %qD", var
);
6208 else if (cp_walk_tree (&step2
, find_omp_placeholder_r
, var
, &pset
))
6210 error_at (EXPR_LOC_OR_LOC (step2
, loc2
),
6211 "step expression refers to outer iterator %qD", var
);
6220 TREE_VEC_ELT (it
, 1) = begin
;
6221 TREE_VEC_ELT (it
, 2) = end
;
6222 if (processing_template_decl
)
6223 TREE_VEC_ELT (it
, 3) = orig_step
;
6226 TREE_VEC_ELT (it
, 3) = step
;
6227 TREE_VEC_ELT (it
, 4) = orig_step
;
6233 /* For all elements of CLAUSES, validate them vs OpenMP constraints.
6234 Remove any elements from the list that are invalid. */
6237 finish_omp_clauses (tree clauses
, enum c_omp_region_type ort
)
6239 bitmap_head generic_head
, firstprivate_head
, lastprivate_head
;
6240 bitmap_head aligned_head
, map_head
, map_field_head
, oacc_reduction_head
;
6242 tree safelen
= NULL_TREE
;
6243 bool branch_seen
= false;
6244 bool copyprivate_seen
= false;
6245 bool ordered_seen
= false;
6246 bool order_seen
= false;
6247 bool schedule_seen
= false;
6248 bool oacc_async
= false;
6249 tree last_iterators
= NULL_TREE
;
6250 bool last_iterators_remove
= false;
6251 /* 1 if normal/task reduction has been seen, -1 if inscan reduction
6252 has been seen, -2 if mixed inscan/normal reduction diagnosed. */
6253 int reduction_seen
= 0;
6255 bitmap_obstack_initialize (NULL
);
6256 bitmap_initialize (&generic_head
, &bitmap_default_obstack
);
6257 bitmap_initialize (&firstprivate_head
, &bitmap_default_obstack
);
6258 bitmap_initialize (&lastprivate_head
, &bitmap_default_obstack
);
6259 bitmap_initialize (&aligned_head
, &bitmap_default_obstack
);
6260 /* If ort == C_ORT_OMP_DECLARE_SIMD used as uniform_head instead. */
6261 bitmap_initialize (&map_head
, &bitmap_default_obstack
);
6262 bitmap_initialize (&map_field_head
, &bitmap_default_obstack
);
6263 /* If ort == C_ORT_OMP used as nontemporal_head or use_device_xxx_head
6265 bitmap_initialize (&oacc_reduction_head
, &bitmap_default_obstack
);
6267 if (ort
& C_ORT_ACC
)
6268 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
6269 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_ASYNC
)
6275 for (pc
= &clauses
, c
= clauses
; c
; c
= *pc
)
6277 bool remove
= false;
6278 bool field_ok
= false;
6280 switch (OMP_CLAUSE_CODE (c
))
6282 case OMP_CLAUSE_SHARED
:
6283 field_ok
= ((ort
& C_ORT_OMP_DECLARE_SIMD
) == C_ORT_OMP
);
6284 goto check_dup_generic
;
6285 case OMP_CLAUSE_PRIVATE
:
6286 field_ok
= ((ort
& C_ORT_OMP_DECLARE_SIMD
) == C_ORT_OMP
);
6287 goto check_dup_generic
;
6288 case OMP_CLAUSE_REDUCTION
:
6289 if (reduction_seen
== 0)
6290 reduction_seen
= OMP_CLAUSE_REDUCTION_INSCAN (c
) ? -1 : 1;
6291 else if (reduction_seen
!= -2
6292 && reduction_seen
!= (OMP_CLAUSE_REDUCTION_INSCAN (c
)
6295 error_at (OMP_CLAUSE_LOCATION (c
),
6296 "%<inscan%> and non-%<inscan%> %<reduction%> clauses "
6297 "on the same construct");
6298 reduction_seen
= -2;
6301 case OMP_CLAUSE_IN_REDUCTION
:
6302 case OMP_CLAUSE_TASK_REDUCTION
:
6303 field_ok
= ((ort
& C_ORT_OMP_DECLARE_SIMD
) == C_ORT_OMP
);
6304 t
= OMP_CLAUSE_DECL (c
);
6305 if (TREE_CODE (t
) == TREE_LIST
)
6307 if (handle_omp_array_sections (c
, ort
))
6312 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
6313 && OMP_CLAUSE_REDUCTION_INSCAN (c
))
6315 error_at (OMP_CLAUSE_LOCATION (c
),
6316 "%<inscan%> %<reduction%> clause with array "
6321 if (TREE_CODE (t
) == TREE_LIST
)
6323 while (TREE_CODE (t
) == TREE_LIST
)
6328 gcc_assert (TREE_CODE (t
) == MEM_REF
);
6329 t
= TREE_OPERAND (t
, 0);
6330 if (TREE_CODE (t
) == POINTER_PLUS_EXPR
)
6331 t
= TREE_OPERAND (t
, 0);
6332 if (TREE_CODE (t
) == ADDR_EXPR
6333 || INDIRECT_REF_P (t
))
6334 t
= TREE_OPERAND (t
, 0);
6336 tree n
= omp_clause_decl_field (t
);
6339 goto check_dup_generic_t
;
6342 cxx_mark_addressable (t
);
6343 goto check_dup_generic
;
6344 case OMP_CLAUSE_COPYPRIVATE
:
6345 copyprivate_seen
= true;
6346 field_ok
= ((ort
& C_ORT_OMP_DECLARE_SIMD
) == C_ORT_OMP
);
6347 goto check_dup_generic
;
6348 case OMP_CLAUSE_COPYIN
:
6349 goto check_dup_generic
;
6350 case OMP_CLAUSE_LINEAR
:
6351 field_ok
= ((ort
& C_ORT_OMP_DECLARE_SIMD
) == C_ORT_OMP
);
6352 t
= OMP_CLAUSE_DECL (c
);
6353 if (ort
!= C_ORT_OMP_DECLARE_SIMD
6354 && OMP_CLAUSE_LINEAR_KIND (c
) != OMP_CLAUSE_LINEAR_DEFAULT
)
6356 error_at (OMP_CLAUSE_LOCATION (c
),
6357 "modifier should not be specified in %<linear%> "
6358 "clause on %<simd%> or %<for%> constructs");
6359 OMP_CLAUSE_LINEAR_KIND (c
) = OMP_CLAUSE_LINEAR_DEFAULT
;
6361 if ((VAR_P (t
) || TREE_CODE (t
) == PARM_DECL
)
6362 && !type_dependent_expression_p (t
))
6364 tree type
= TREE_TYPE (t
);
6365 if ((OMP_CLAUSE_LINEAR_KIND (c
) == OMP_CLAUSE_LINEAR_REF
6366 || OMP_CLAUSE_LINEAR_KIND (c
) == OMP_CLAUSE_LINEAR_UVAL
)
6367 && !TYPE_REF_P (type
))
6369 error_at (OMP_CLAUSE_LOCATION (c
),
6370 "linear clause with %qs modifier applied to "
6371 "non-reference variable with %qT type",
6372 OMP_CLAUSE_LINEAR_KIND (c
) == OMP_CLAUSE_LINEAR_REF
6373 ? "ref" : "uval", TREE_TYPE (t
));
6377 if (TYPE_REF_P (type
))
6378 type
= TREE_TYPE (type
);
6379 if (OMP_CLAUSE_LINEAR_KIND (c
) != OMP_CLAUSE_LINEAR_REF
)
6381 if (!INTEGRAL_TYPE_P (type
)
6382 && !TYPE_PTR_P (type
))
6384 error_at (OMP_CLAUSE_LOCATION (c
),
6385 "linear clause applied to non-integral "
6386 "non-pointer variable with %qT type",
6393 t
= OMP_CLAUSE_LINEAR_STEP (c
);
6395 t
= integer_one_node
;
6396 if (t
== error_mark_node
)
6401 else if (!type_dependent_expression_p (t
)
6402 && !INTEGRAL_TYPE_P (TREE_TYPE (t
))
6403 && (ort
!= C_ORT_OMP_DECLARE_SIMD
6404 || TREE_CODE (t
) != PARM_DECL
6405 || !TYPE_REF_P (TREE_TYPE (t
))
6406 || !INTEGRAL_TYPE_P (TREE_TYPE (TREE_TYPE (t
)))))
6408 error_at (OMP_CLAUSE_LOCATION (c
),
6409 "linear step expression must be integral");
6415 t
= mark_rvalue_use (t
);
6416 if (ort
== C_ORT_OMP_DECLARE_SIMD
&& TREE_CODE (t
) == PARM_DECL
)
6418 OMP_CLAUSE_LINEAR_VARIABLE_STRIDE (c
) = 1;
6419 goto check_dup_generic
;
6421 if (!processing_template_decl
6422 && (VAR_P (OMP_CLAUSE_DECL (c
))
6423 || TREE_CODE (OMP_CLAUSE_DECL (c
)) == PARM_DECL
))
6425 if (ort
== C_ORT_OMP_DECLARE_SIMD
)
6427 t
= maybe_constant_value (t
);
6428 if (TREE_CODE (t
) != INTEGER_CST
)
6430 error_at (OMP_CLAUSE_LOCATION (c
),
6431 "%<linear%> clause step %qE is neither "
6432 "constant nor a parameter", t
);
6437 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
6438 tree type
= TREE_TYPE (OMP_CLAUSE_DECL (c
));
6439 if (TYPE_REF_P (type
))
6440 type
= TREE_TYPE (type
);
6441 if (OMP_CLAUSE_LINEAR_KIND (c
) == OMP_CLAUSE_LINEAR_REF
)
6443 type
= build_pointer_type (type
);
6444 tree d
= fold_convert (type
, OMP_CLAUSE_DECL (c
));
6445 t
= pointer_int_sum (OMP_CLAUSE_LOCATION (c
), PLUS_EXPR
,
6447 t
= fold_build2_loc (OMP_CLAUSE_LOCATION (c
),
6448 MINUS_EXPR
, sizetype
,
6449 fold_convert (sizetype
, t
),
6450 fold_convert (sizetype
, d
));
6451 if (t
== error_mark_node
)
6457 else if (TYPE_PTR_P (type
)
6458 /* Can't multiply the step yet if *this
6459 is still incomplete type. */
6460 && (ort
!= C_ORT_OMP_DECLARE_SIMD
6461 || TREE_CODE (OMP_CLAUSE_DECL (c
)) != PARM_DECL
6462 || !DECL_ARTIFICIAL (OMP_CLAUSE_DECL (c
))
6463 || DECL_NAME (OMP_CLAUSE_DECL (c
))
6465 || !TYPE_BEING_DEFINED (TREE_TYPE (type
))))
6467 tree d
= convert_from_reference (OMP_CLAUSE_DECL (c
));
6468 t
= pointer_int_sum (OMP_CLAUSE_LOCATION (c
), PLUS_EXPR
,
6470 t
= fold_build2_loc (OMP_CLAUSE_LOCATION (c
),
6471 MINUS_EXPR
, sizetype
,
6472 fold_convert (sizetype
, t
),
6473 fold_convert (sizetype
, d
));
6474 if (t
== error_mark_node
)
6481 t
= fold_convert (type
, t
);
6483 OMP_CLAUSE_LINEAR_STEP (c
) = t
;
6485 goto check_dup_generic
;
6487 t
= omp_clause_decl_field (OMP_CLAUSE_DECL (c
));
6490 if (!remove
&& OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_SHARED
)
6491 omp_note_field_privatization (t
, OMP_CLAUSE_DECL (c
));
6494 t
= OMP_CLAUSE_DECL (c
);
6495 check_dup_generic_t
:
6496 if (t
== current_class_ptr
6497 && (ort
!= C_ORT_OMP_DECLARE_SIMD
6498 || (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_LINEAR
6499 && OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_UNIFORM
)))
6501 error_at (OMP_CLAUSE_LOCATION (c
),
6502 "%<this%> allowed in OpenMP only in %<declare simd%>"
6507 if (!VAR_P (t
) && TREE_CODE (t
) != PARM_DECL
6508 && (!field_ok
|| TREE_CODE (t
) != FIELD_DECL
))
6510 if (processing_template_decl
&& TREE_CODE (t
) != OVERLOAD
)
6513 error_at (OMP_CLAUSE_LOCATION (c
),
6514 "%qD is not a variable in clause %qs", t
,
6515 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
6517 error_at (OMP_CLAUSE_LOCATION (c
),
6518 "%qE is not a variable in clause %qs", t
,
6519 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
6522 else if ((ort
== C_ORT_ACC
6523 && OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
)
6524 || (ort
== C_ORT_OMP
6525 && (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_USE_DEVICE_PTR
6526 || (OMP_CLAUSE_CODE (c
)
6527 == OMP_CLAUSE_USE_DEVICE_ADDR
))))
6529 if (bitmap_bit_p (&oacc_reduction_head
, DECL_UID (t
)))
6531 error_at (OMP_CLAUSE_LOCATION (c
),
6533 ? "%qD appears more than once in reduction clauses"
6534 : "%qD appears more than once in data clauses",
6539 bitmap_set_bit (&oacc_reduction_head
, DECL_UID (t
));
6541 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
6542 || bitmap_bit_p (&firstprivate_head
, DECL_UID (t
))
6543 || bitmap_bit_p (&lastprivate_head
, DECL_UID (t
)))
6545 error_at (OMP_CLAUSE_LOCATION (c
),
6546 "%qD appears more than once in data clauses", t
);
6549 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_PRIVATE
6550 && bitmap_bit_p (&map_head
, DECL_UID (t
)))
6552 if (ort
== C_ORT_ACC
)
6553 error_at (OMP_CLAUSE_LOCATION (c
),
6554 "%qD appears more than once in data clauses", t
);
6556 error_at (OMP_CLAUSE_LOCATION (c
),
6557 "%qD appears both in data and map clauses", t
);
6561 bitmap_set_bit (&generic_head
, DECL_UID (t
));
6566 && TREE_CODE (t
) == FIELD_DECL
6567 && t
== OMP_CLAUSE_DECL (c
)
6568 && ort
!= C_ORT_ACC
)
6571 = omp_privatize_field (t
, (OMP_CLAUSE_CODE (c
)
6572 == OMP_CLAUSE_SHARED
));
6573 if (OMP_CLAUSE_DECL (c
) == error_mark_node
)
6578 case OMP_CLAUSE_FIRSTPRIVATE
:
6579 t
= omp_clause_decl_field (OMP_CLAUSE_DECL (c
));
6581 omp_note_field_privatization (t
, OMP_CLAUSE_DECL (c
));
6583 t
= OMP_CLAUSE_DECL (c
);
6584 if (ort
!= C_ORT_ACC
&& t
== current_class_ptr
)
6586 error_at (OMP_CLAUSE_LOCATION (c
),
6587 "%<this%> allowed in OpenMP only in %<declare simd%>"
6592 if (!VAR_P (t
) && TREE_CODE (t
) != PARM_DECL
6593 && ((ort
& C_ORT_OMP_DECLARE_SIMD
) != C_ORT_OMP
6594 || TREE_CODE (t
) != FIELD_DECL
))
6596 if (processing_template_decl
&& TREE_CODE (t
) != OVERLOAD
)
6599 error_at (OMP_CLAUSE_LOCATION (c
),
6600 "%qD is not a variable in clause %<firstprivate%>",
6603 error_at (OMP_CLAUSE_LOCATION (c
),
6604 "%qE is not a variable in clause %<firstprivate%>",
6608 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
6609 || bitmap_bit_p (&firstprivate_head
, DECL_UID (t
)))
6611 error_at (OMP_CLAUSE_LOCATION (c
),
6612 "%qD appears more than once in data clauses", t
);
6615 else if (bitmap_bit_p (&map_head
, DECL_UID (t
)))
6617 if (ort
== C_ORT_ACC
)
6618 error_at (OMP_CLAUSE_LOCATION (c
),
6619 "%qD appears more than once in data clauses", t
);
6621 error_at (OMP_CLAUSE_LOCATION (c
),
6622 "%qD appears both in data and map clauses", t
);
6626 bitmap_set_bit (&firstprivate_head
, DECL_UID (t
));
6627 goto handle_field_decl
;
6629 case OMP_CLAUSE_LASTPRIVATE
:
6630 t
= omp_clause_decl_field (OMP_CLAUSE_DECL (c
));
6632 omp_note_field_privatization (t
, OMP_CLAUSE_DECL (c
));
6634 t
= OMP_CLAUSE_DECL (c
);
6635 if (t
== current_class_ptr
)
6637 error_at (OMP_CLAUSE_LOCATION (c
),
6638 "%<this%> allowed in OpenMP only in %<declare simd%>"
6643 if (!VAR_P (t
) && TREE_CODE (t
) != PARM_DECL
6644 && ((ort
& C_ORT_OMP_DECLARE_SIMD
) != C_ORT_OMP
6645 || TREE_CODE (t
) != FIELD_DECL
))
6647 if (processing_template_decl
&& TREE_CODE (t
) != OVERLOAD
)
6650 error_at (OMP_CLAUSE_LOCATION (c
),
6651 "%qD is not a variable in clause %<lastprivate%>",
6654 error_at (OMP_CLAUSE_LOCATION (c
),
6655 "%qE is not a variable in clause %<lastprivate%>",
6659 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
6660 || bitmap_bit_p (&lastprivate_head
, DECL_UID (t
)))
6662 error_at (OMP_CLAUSE_LOCATION (c
),
6663 "%qD appears more than once in data clauses", t
);
6667 bitmap_set_bit (&lastprivate_head
, DECL_UID (t
));
6668 goto handle_field_decl
;
6671 t
= OMP_CLAUSE_IF_EXPR (c
);
6672 t
= maybe_convert_cond (t
);
6673 if (t
== error_mark_node
)
6675 else if (!processing_template_decl
)
6676 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
6677 OMP_CLAUSE_IF_EXPR (c
) = t
;
6680 case OMP_CLAUSE_FINAL
:
6681 t
= OMP_CLAUSE_FINAL_EXPR (c
);
6682 t
= maybe_convert_cond (t
);
6683 if (t
== error_mark_node
)
6685 else if (!processing_template_decl
)
6686 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
6687 OMP_CLAUSE_FINAL_EXPR (c
) = t
;
6690 case OMP_CLAUSE_GANG
:
6691 /* Operand 1 is the gang static: argument. */
6692 t
= OMP_CLAUSE_OPERAND (c
, 1);
6695 if (t
== error_mark_node
)
6697 else if (!type_dependent_expression_p (t
)
6698 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
6700 error_at (OMP_CLAUSE_LOCATION (c
),
6701 "%<gang%> static expression must be integral");
6706 t
= mark_rvalue_use (t
);
6707 if (!processing_template_decl
)
6709 t
= maybe_constant_value (t
);
6710 if (TREE_CODE (t
) == INTEGER_CST
6711 && tree_int_cst_sgn (t
) != 1
6712 && t
!= integer_minus_one_node
)
6714 warning_at (OMP_CLAUSE_LOCATION (c
), 0,
6715 "%<gang%> static value must be "
6717 t
= integer_one_node
;
6719 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
6722 OMP_CLAUSE_OPERAND (c
, 1) = t
;
6724 /* Check operand 0, the num argument. */
6727 case OMP_CLAUSE_WORKER
:
6728 case OMP_CLAUSE_VECTOR
:
6729 if (OMP_CLAUSE_OPERAND (c
, 0) == NULL_TREE
)
6733 case OMP_CLAUSE_NUM_TASKS
:
6734 case OMP_CLAUSE_NUM_TEAMS
:
6735 case OMP_CLAUSE_NUM_THREADS
:
6736 case OMP_CLAUSE_NUM_GANGS
:
6737 case OMP_CLAUSE_NUM_WORKERS
:
6738 case OMP_CLAUSE_VECTOR_LENGTH
:
6739 t
= OMP_CLAUSE_OPERAND (c
, 0);
6740 if (t
== error_mark_node
)
6742 else if (!type_dependent_expression_p (t
)
6743 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
6745 switch (OMP_CLAUSE_CODE (c
))
6747 case OMP_CLAUSE_GANG
:
6748 error_at (OMP_CLAUSE_LOCATION (c
),
6749 "%<gang%> num expression must be integral"); break;
6750 case OMP_CLAUSE_VECTOR
:
6751 error_at (OMP_CLAUSE_LOCATION (c
),
6752 "%<vector%> length expression must be integral");
6754 case OMP_CLAUSE_WORKER
:
6755 error_at (OMP_CLAUSE_LOCATION (c
),
6756 "%<worker%> num expression must be integral");
6759 error_at (OMP_CLAUSE_LOCATION (c
),
6760 "%qs expression must be integral",
6761 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
6767 t
= mark_rvalue_use (t
);
6768 if (!processing_template_decl
)
6770 t
= maybe_constant_value (t
);
6771 if (TREE_CODE (t
) == INTEGER_CST
6772 && tree_int_cst_sgn (t
) != 1)
6774 switch (OMP_CLAUSE_CODE (c
))
6776 case OMP_CLAUSE_GANG
:
6777 warning_at (OMP_CLAUSE_LOCATION (c
), 0,
6778 "%<gang%> num value must be positive");
6780 case OMP_CLAUSE_VECTOR
:
6781 warning_at (OMP_CLAUSE_LOCATION (c
), 0,
6782 "%<vector%> length value must be "
6785 case OMP_CLAUSE_WORKER
:
6786 warning_at (OMP_CLAUSE_LOCATION (c
), 0,
6787 "%<worker%> num value must be "
6791 warning_at (OMP_CLAUSE_LOCATION (c
), 0,
6792 "%qs value must be positive",
6793 omp_clause_code_name
6794 [OMP_CLAUSE_CODE (c
)]);
6796 t
= integer_one_node
;
6798 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
6800 OMP_CLAUSE_OPERAND (c
, 0) = t
;
6804 case OMP_CLAUSE_SCHEDULE
:
6805 t
= OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c
);
6808 else if (t
== error_mark_node
)
6810 else if (!type_dependent_expression_p (t
)
6811 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
6813 error_at (OMP_CLAUSE_LOCATION (c
),
6814 "schedule chunk size expression must be integral");
6819 t
= mark_rvalue_use (t
);
6820 if (!processing_template_decl
)
6822 t
= maybe_constant_value (t
);
6823 if (TREE_CODE (t
) == INTEGER_CST
6824 && tree_int_cst_sgn (t
) != 1)
6826 warning_at (OMP_CLAUSE_LOCATION (c
), 0,
6827 "chunk size value must be positive");
6828 t
= integer_one_node
;
6830 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
6832 OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c
) = t
;
6835 schedule_seen
= true;
6838 case OMP_CLAUSE_SIMDLEN
:
6839 case OMP_CLAUSE_SAFELEN
:
6840 t
= OMP_CLAUSE_OPERAND (c
, 0);
6841 if (t
== error_mark_node
)
6843 else if (!type_dependent_expression_p (t
)
6844 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
6846 error_at (OMP_CLAUSE_LOCATION (c
),
6847 "%qs length expression must be integral",
6848 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
6853 t
= mark_rvalue_use (t
);
6854 if (!processing_template_decl
)
6856 t
= maybe_constant_value (t
);
6857 if (TREE_CODE (t
) != INTEGER_CST
6858 || tree_int_cst_sgn (t
) != 1)
6860 error_at (OMP_CLAUSE_LOCATION (c
),
6861 "%qs length expression must be positive "
6862 "constant integer expression",
6863 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
6867 OMP_CLAUSE_OPERAND (c
, 0) = t
;
6868 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_SAFELEN
)
6873 case OMP_CLAUSE_ASYNC
:
6874 t
= OMP_CLAUSE_ASYNC_EXPR (c
);
6875 if (t
== error_mark_node
)
6877 else if (!type_dependent_expression_p (t
)
6878 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
6880 error_at (OMP_CLAUSE_LOCATION (c
),
6881 "%<async%> expression must be integral");
6886 t
= mark_rvalue_use (t
);
6887 if (!processing_template_decl
)
6888 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
6889 OMP_CLAUSE_ASYNC_EXPR (c
) = t
;
6893 case OMP_CLAUSE_WAIT
:
6894 t
= OMP_CLAUSE_WAIT_EXPR (c
);
6895 if (t
== error_mark_node
)
6897 else if (!processing_template_decl
)
6898 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
6899 OMP_CLAUSE_WAIT_EXPR (c
) = t
;
6902 case OMP_CLAUSE_THREAD_LIMIT
:
6903 t
= OMP_CLAUSE_THREAD_LIMIT_EXPR (c
);
6904 if (t
== error_mark_node
)
6906 else if (!type_dependent_expression_p (t
)
6907 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
6909 error_at (OMP_CLAUSE_LOCATION (c
),
6910 "%<thread_limit%> expression must be integral");
6915 t
= mark_rvalue_use (t
);
6916 if (!processing_template_decl
)
6918 t
= maybe_constant_value (t
);
6919 if (TREE_CODE (t
) == INTEGER_CST
6920 && tree_int_cst_sgn (t
) != 1)
6922 warning_at (OMP_CLAUSE_LOCATION (c
), 0,
6923 "%<thread_limit%> value must be positive");
6924 t
= integer_one_node
;
6926 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
6928 OMP_CLAUSE_THREAD_LIMIT_EXPR (c
) = t
;
6932 case OMP_CLAUSE_DEVICE
:
6933 t
= OMP_CLAUSE_DEVICE_ID (c
);
6934 if (t
== error_mark_node
)
6936 else if (!type_dependent_expression_p (t
)
6937 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
6939 error_at (OMP_CLAUSE_LOCATION (c
),
6940 "%<device%> id must be integral");
6945 t
= mark_rvalue_use (t
);
6946 if (!processing_template_decl
)
6947 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
6948 OMP_CLAUSE_DEVICE_ID (c
) = t
;
6952 case OMP_CLAUSE_DIST_SCHEDULE
:
6953 t
= OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (c
);
6956 else if (t
== error_mark_node
)
6958 else if (!type_dependent_expression_p (t
)
6959 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
6961 error_at (OMP_CLAUSE_LOCATION (c
),
6962 "%<dist_schedule%> chunk size expression must be "
6968 t
= mark_rvalue_use (t
);
6969 if (!processing_template_decl
)
6970 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
6971 OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (c
) = t
;
6975 case OMP_CLAUSE_ALIGNED
:
6976 t
= OMP_CLAUSE_DECL (c
);
6977 if (t
== current_class_ptr
&& ort
!= C_ORT_OMP_DECLARE_SIMD
)
6979 error_at (OMP_CLAUSE_LOCATION (c
),
6980 "%<this%> allowed in OpenMP only in %<declare simd%>"
6985 if (!VAR_P (t
) && TREE_CODE (t
) != PARM_DECL
)
6987 if (processing_template_decl
&& TREE_CODE (t
) != OVERLOAD
)
6990 error_at (OMP_CLAUSE_LOCATION (c
),
6991 "%qD is not a variable in %<aligned%> clause", t
);
6993 error_at (OMP_CLAUSE_LOCATION (c
),
6994 "%qE is not a variable in %<aligned%> clause", t
);
6997 else if (!type_dependent_expression_p (t
)
6998 && !TYPE_PTR_P (TREE_TYPE (t
))
6999 && TREE_CODE (TREE_TYPE (t
)) != ARRAY_TYPE
7000 && (!TYPE_REF_P (TREE_TYPE (t
))
7001 || (!INDIRECT_TYPE_P (TREE_TYPE (TREE_TYPE (t
)))
7002 && (TREE_CODE (TREE_TYPE (TREE_TYPE (t
)))
7005 error_at (OMP_CLAUSE_LOCATION (c
),
7006 "%qE in %<aligned%> clause is neither a pointer nor "
7007 "an array nor a reference to pointer or array", t
);
7010 else if (bitmap_bit_p (&aligned_head
, DECL_UID (t
)))
7012 error_at (OMP_CLAUSE_LOCATION (c
),
7013 "%qD appears more than once in %<aligned%> clauses",
7018 bitmap_set_bit (&aligned_head
, DECL_UID (t
));
7019 t
= OMP_CLAUSE_ALIGNED_ALIGNMENT (c
);
7020 if (t
== error_mark_node
)
7022 else if (t
== NULL_TREE
)
7024 else if (!type_dependent_expression_p (t
)
7025 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
7027 error_at (OMP_CLAUSE_LOCATION (c
),
7028 "%<aligned%> clause alignment expression must "
7034 t
= mark_rvalue_use (t
);
7035 if (!processing_template_decl
)
7037 t
= maybe_constant_value (t
);
7038 if (TREE_CODE (t
) != INTEGER_CST
7039 || tree_int_cst_sgn (t
) != 1)
7041 error_at (OMP_CLAUSE_LOCATION (c
),
7042 "%<aligned%> clause alignment expression must "
7043 "be positive constant integer expression");
7047 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
7049 OMP_CLAUSE_ALIGNED_ALIGNMENT (c
) = t
;
7053 case OMP_CLAUSE_NONTEMPORAL
:
7054 t
= OMP_CLAUSE_DECL (c
);
7055 if (!VAR_P (t
) && TREE_CODE (t
) != PARM_DECL
)
7057 if (processing_template_decl
&& TREE_CODE (t
) != OVERLOAD
)
7060 error_at (OMP_CLAUSE_LOCATION (c
),
7061 "%qD is not a variable in %<nontemporal%> clause",
7064 error_at (OMP_CLAUSE_LOCATION (c
),
7065 "%qE is not a variable in %<nontemporal%> clause",
7069 else if (bitmap_bit_p (&oacc_reduction_head
, DECL_UID (t
)))
7071 error_at (OMP_CLAUSE_LOCATION (c
),
7072 "%qD appears more than once in %<nontemporal%> "
7077 bitmap_set_bit (&oacc_reduction_head
, DECL_UID (t
));
7080 case OMP_CLAUSE_DEPEND
:
7081 t
= OMP_CLAUSE_DECL (c
);
7084 gcc_assert (OMP_CLAUSE_DEPEND_KIND (c
)
7085 == OMP_CLAUSE_DEPEND_SOURCE
);
7088 if (OMP_CLAUSE_DEPEND_KIND (c
) == OMP_CLAUSE_DEPEND_SINK
)
7090 if (cp_finish_omp_clause_depend_sink (c
))
7094 if (TREE_CODE (t
) == TREE_LIST
7096 && TREE_CODE (TREE_PURPOSE (t
)) == TREE_VEC
)
7098 if (TREE_PURPOSE (t
) != last_iterators
)
7099 last_iterators_remove
7100 = cp_omp_finish_iterators (TREE_PURPOSE (t
));
7101 last_iterators
= TREE_PURPOSE (t
);
7103 if (last_iterators_remove
)
7104 t
= error_mark_node
;
7107 last_iterators
= NULL_TREE
;
7109 if (TREE_CODE (t
) == TREE_LIST
)
7111 if (handle_omp_array_sections (c
, ort
))
7113 else if (OMP_CLAUSE_DEPEND_KIND (c
) == OMP_CLAUSE_DEPEND_DEPOBJ
)
7115 error_at (OMP_CLAUSE_LOCATION (c
),
7116 "%<depend%> clause with %<depobj%> dependence "
7117 "type on array section");
7122 if (t
== error_mark_node
)
7124 else if (t
== current_class_ptr
)
7126 error_at (OMP_CLAUSE_LOCATION (c
),
7127 "%<this%> allowed in OpenMP only in %<declare simd%>"
7131 else if (processing_template_decl
&& TREE_CODE (t
) != OVERLOAD
)
7133 else if (!lvalue_p (t
))
7136 error_at (OMP_CLAUSE_LOCATION (c
),
7137 "%qD is not lvalue expression nor array section "
7138 "in %<depend%> clause", t
);
7140 error_at (OMP_CLAUSE_LOCATION (c
),
7141 "%qE is not lvalue expression nor array section "
7142 "in %<depend%> clause", t
);
7145 else if (TREE_CODE (t
) == COMPONENT_REF
7146 && TREE_CODE (TREE_OPERAND (t
, 1)) == FIELD_DECL
7147 && DECL_BIT_FIELD (TREE_OPERAND (t
, 1)))
7149 error_at (OMP_CLAUSE_LOCATION (c
),
7150 "bit-field %qE in %qs clause", t
, "depend");
7153 else if (OMP_CLAUSE_DEPEND_KIND (c
) == OMP_CLAUSE_DEPEND_DEPOBJ
)
7155 if (!c_omp_depend_t_p (TYPE_REF_P (TREE_TYPE (t
))
7156 ? TREE_TYPE (TREE_TYPE (t
))
7159 error_at (OMP_CLAUSE_LOCATION (c
),
7160 "%qE does not have %<omp_depend_t%> type in "
7161 "%<depend%> clause with %<depobj%> dependence "
7166 else if (c_omp_depend_t_p (TYPE_REF_P (TREE_TYPE (t
))
7167 ? TREE_TYPE (TREE_TYPE (t
))
7170 error_at (OMP_CLAUSE_LOCATION (c
),
7171 "%qE should not have %<omp_depend_t%> type in "
7172 "%<depend%> clause with dependence type other than "
7178 tree addr
= cp_build_addr_expr (t
, tf_warning_or_error
);
7179 if (addr
== error_mark_node
)
7183 t
= cp_build_indirect_ref (OMP_CLAUSE_LOCATION (c
),
7184 addr
, RO_UNARY_STAR
,
7185 tf_warning_or_error
);
7186 if (t
== error_mark_node
)
7188 else if (TREE_CODE (OMP_CLAUSE_DECL (c
)) == TREE_LIST
7189 && TREE_PURPOSE (OMP_CLAUSE_DECL (c
))
7190 && (TREE_CODE (TREE_PURPOSE (OMP_CLAUSE_DECL (c
)))
7192 TREE_VALUE (OMP_CLAUSE_DECL (c
)) = t
;
7194 OMP_CLAUSE_DECL (c
) = t
;
7199 case OMP_CLAUSE_MAP
:
7201 case OMP_CLAUSE_FROM
:
7202 case OMP_CLAUSE__CACHE_
:
7203 t
= OMP_CLAUSE_DECL (c
);
7204 if (TREE_CODE (t
) == TREE_LIST
)
7206 if (handle_omp_array_sections (c
, ort
))
7210 t
= OMP_CLAUSE_DECL (c
);
7211 if (TREE_CODE (t
) != TREE_LIST
7212 && !type_dependent_expression_p (t
)
7213 && !cp_omp_mappable_type (TREE_TYPE (t
)))
7215 error_at (OMP_CLAUSE_LOCATION (c
),
7216 "array section does not have mappable type "
7218 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
7219 cp_omp_emit_unmappable_type_notes (TREE_TYPE (t
));
7222 while (TREE_CODE (t
) == ARRAY_REF
)
7223 t
= TREE_OPERAND (t
, 0);
7224 if (TREE_CODE (t
) == COMPONENT_REF
7225 && TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
7227 while (TREE_CODE (t
) == COMPONENT_REF
)
7228 t
= TREE_OPERAND (t
, 0);
7229 if (REFERENCE_REF_P (t
))
7230 t
= TREE_OPERAND (t
, 0);
7231 if (bitmap_bit_p (&map_field_head
, DECL_UID (t
)))
7233 if (bitmap_bit_p (&map_head
, DECL_UID (t
)))
7235 if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_MAP
)
7236 error_at (OMP_CLAUSE_LOCATION (c
),
7237 "%qD appears more than once in motion"
7239 else if (ort
== C_ORT_ACC
)
7240 error_at (OMP_CLAUSE_LOCATION (c
),
7241 "%qD appears more than once in data"
7244 error_at (OMP_CLAUSE_LOCATION (c
),
7245 "%qD appears more than once in map"
7251 bitmap_set_bit (&map_head
, DECL_UID (t
));
7252 bitmap_set_bit (&map_field_head
, DECL_UID (t
));
7258 if (t
== error_mark_node
)
7263 if (REFERENCE_REF_P (t
)
7264 && TREE_CODE (TREE_OPERAND (t
, 0)) == COMPONENT_REF
)
7266 t
= TREE_OPERAND (t
, 0);
7267 OMP_CLAUSE_DECL (c
) = t
;
7269 if (TREE_CODE (t
) == COMPONENT_REF
7270 && (ort
& C_ORT_OMP_DECLARE_SIMD
) == C_ORT_OMP
7271 && OMP_CLAUSE_CODE (c
) != OMP_CLAUSE__CACHE_
)
7273 if (type_dependent_expression_p (t
))
7275 if (TREE_CODE (TREE_OPERAND (t
, 1)) == FIELD_DECL
7276 && DECL_BIT_FIELD (TREE_OPERAND (t
, 1)))
7278 error_at (OMP_CLAUSE_LOCATION (c
),
7279 "bit-field %qE in %qs clause",
7280 t
, omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
7283 else if (!cp_omp_mappable_type (TREE_TYPE (t
)))
7285 error_at (OMP_CLAUSE_LOCATION (c
),
7286 "%qE does not have a mappable type in %qs clause",
7287 t
, omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
7288 cp_omp_emit_unmappable_type_notes (TREE_TYPE (t
));
7291 while (TREE_CODE (t
) == COMPONENT_REF
)
7293 if (TREE_TYPE (TREE_OPERAND (t
, 0))
7294 && (TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0)))
7297 error_at (OMP_CLAUSE_LOCATION (c
),
7298 "%qE is a member of a union", t
);
7302 t
= TREE_OPERAND (t
, 0);
7306 if (REFERENCE_REF_P (t
))
7307 t
= TREE_OPERAND (t
, 0);
7308 if (VAR_P (t
) || TREE_CODE (t
) == PARM_DECL
)
7310 if (bitmap_bit_p (&map_field_head
, DECL_UID (t
)))
7311 goto handle_map_references
;
7314 if (!VAR_P (t
) && TREE_CODE (t
) != PARM_DECL
)
7316 if (processing_template_decl
&& TREE_CODE (t
) != OVERLOAD
)
7318 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_MAP
7319 && (OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_POINTER
7320 || OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_ALWAYS_POINTER
))
7323 error_at (OMP_CLAUSE_LOCATION (c
),
7324 "%qD is not a variable in %qs clause", t
,
7325 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
7327 error_at (OMP_CLAUSE_LOCATION (c
),
7328 "%qE is not a variable in %qs clause", t
,
7329 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
7332 else if (VAR_P (t
) && CP_DECL_THREAD_LOCAL_P (t
))
7334 error_at (OMP_CLAUSE_LOCATION (c
),
7335 "%qD is threadprivate variable in %qs clause", t
,
7336 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
7339 else if (ort
!= C_ORT_ACC
&& t
== current_class_ptr
)
7341 error_at (OMP_CLAUSE_LOCATION (c
),
7342 "%<this%> allowed in OpenMP only in %<declare simd%>"
7347 else if (!processing_template_decl
7348 && !TYPE_REF_P (TREE_TYPE (t
))
7349 && (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_MAP
7350 || (OMP_CLAUSE_MAP_KIND (c
)
7351 != GOMP_MAP_FIRSTPRIVATE_POINTER
))
7352 && !cxx_mark_addressable (t
))
7354 else if (!(OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_MAP
7355 && (OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_POINTER
7356 || (OMP_CLAUSE_MAP_KIND (c
)
7357 == GOMP_MAP_FIRSTPRIVATE_POINTER
)))
7358 && t
== OMP_CLAUSE_DECL (c
)
7359 && !type_dependent_expression_p (t
)
7360 && !cp_omp_mappable_type (TYPE_REF_P (TREE_TYPE (t
))
7361 ? TREE_TYPE (TREE_TYPE (t
))
7364 error_at (OMP_CLAUSE_LOCATION (c
),
7365 "%qD does not have a mappable type in %qs clause", t
,
7366 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
7367 cp_omp_emit_unmappable_type_notes (TREE_TYPE (t
));
7370 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_MAP
7371 && OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_FORCE_DEVICEPTR
7372 && !type_dependent_expression_p (t
)
7373 && !INDIRECT_TYPE_P (TREE_TYPE (t
)))
7375 error_at (OMP_CLAUSE_LOCATION (c
),
7376 "%qD is not a pointer variable", t
);
7379 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_MAP
7380 && OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_FIRSTPRIVATE_POINTER
)
7382 if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
7383 || bitmap_bit_p (&firstprivate_head
, DECL_UID (t
)))
7385 error_at (OMP_CLAUSE_LOCATION (c
),
7386 "%qD appears more than once in data clauses", t
);
7389 else if (bitmap_bit_p (&map_head
, DECL_UID (t
)))
7391 if (ort
== C_ORT_ACC
)
7392 error_at (OMP_CLAUSE_LOCATION (c
),
7393 "%qD appears more than once in data clauses", t
);
7395 error_at (OMP_CLAUSE_LOCATION (c
),
7396 "%qD appears both in data and map clauses", t
);
7400 bitmap_set_bit (&generic_head
, DECL_UID (t
));
7402 else if (bitmap_bit_p (&map_head
, DECL_UID (t
)))
7404 if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_MAP
)
7405 error_at (OMP_CLAUSE_LOCATION (c
),
7406 "%qD appears more than once in motion clauses", t
);
7407 if (ort
== C_ORT_ACC
)
7408 error_at (OMP_CLAUSE_LOCATION (c
),
7409 "%qD appears more than once in data clauses", t
);
7411 error_at (OMP_CLAUSE_LOCATION (c
),
7412 "%qD appears more than once in map clauses", t
);
7415 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
7416 || bitmap_bit_p (&firstprivate_head
, DECL_UID (t
)))
7418 if (ort
== C_ORT_ACC
)
7419 error_at (OMP_CLAUSE_LOCATION (c
),
7420 "%qD appears more than once in data clauses", t
);
7422 error_at (OMP_CLAUSE_LOCATION (c
),
7423 "%qD appears both in data and map clauses", t
);
7428 bitmap_set_bit (&map_head
, DECL_UID (t
));
7429 if (t
!= OMP_CLAUSE_DECL (c
)
7430 && TREE_CODE (OMP_CLAUSE_DECL (c
)) == COMPONENT_REF
)
7431 bitmap_set_bit (&map_field_head
, DECL_UID (t
));
7433 handle_map_references
:
7435 && !processing_template_decl
7436 && ort
!= C_ORT_DECLARE_SIMD
7437 && TYPE_REF_P (TREE_TYPE (OMP_CLAUSE_DECL (c
))))
7439 t
= OMP_CLAUSE_DECL (c
);
7440 if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_MAP
)
7442 OMP_CLAUSE_DECL (c
) = build_simple_mem_ref (t
);
7443 if (OMP_CLAUSE_SIZE (c
) == NULL_TREE
)
7445 = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (t
)));
7447 else if (OMP_CLAUSE_MAP_KIND (c
)
7448 != GOMP_MAP_FIRSTPRIVATE_POINTER
7449 && (OMP_CLAUSE_MAP_KIND (c
)
7450 != GOMP_MAP_FIRSTPRIVATE_REFERENCE
)
7451 && (OMP_CLAUSE_MAP_KIND (c
)
7452 != GOMP_MAP_ALWAYS_POINTER
))
7454 tree c2
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
7456 if (TREE_CODE (t
) == COMPONENT_REF
)
7457 OMP_CLAUSE_SET_MAP_KIND (c2
, GOMP_MAP_ALWAYS_POINTER
);
7459 OMP_CLAUSE_SET_MAP_KIND (c2
,
7460 GOMP_MAP_FIRSTPRIVATE_REFERENCE
);
7461 OMP_CLAUSE_DECL (c2
) = t
;
7462 OMP_CLAUSE_SIZE (c2
) = size_zero_node
;
7463 OMP_CLAUSE_CHAIN (c2
) = OMP_CLAUSE_CHAIN (c
);
7464 OMP_CLAUSE_CHAIN (c
) = c2
;
7465 OMP_CLAUSE_DECL (c
) = build_simple_mem_ref (t
);
7466 if (OMP_CLAUSE_SIZE (c
) == NULL_TREE
)
7468 = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (t
)));
7474 case OMP_CLAUSE_TO_DECLARE
:
7475 case OMP_CLAUSE_LINK
:
7476 t
= OMP_CLAUSE_DECL (c
);
7477 if (TREE_CODE (t
) == FUNCTION_DECL
7478 && OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_TO_DECLARE
)
7480 else if (!VAR_P (t
))
7482 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_TO_DECLARE
)
7484 if (TREE_CODE (t
) == TEMPLATE_ID_EXPR
)
7485 error_at (OMP_CLAUSE_LOCATION (c
),
7486 "template %qE in clause %qs", t
,
7487 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
7488 else if (really_overloaded_fn (t
))
7489 error_at (OMP_CLAUSE_LOCATION (c
),
7490 "overloaded function name %qE in clause %qs", t
,
7491 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
7493 error_at (OMP_CLAUSE_LOCATION (c
),
7494 "%qE is neither a variable nor a function name "
7496 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
7499 error_at (OMP_CLAUSE_LOCATION (c
),
7500 "%qE is not a variable in clause %qs", t
,
7501 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
7504 else if (DECL_THREAD_LOCAL_P (t
))
7506 error_at (OMP_CLAUSE_LOCATION (c
),
7507 "%qD is threadprivate variable in %qs clause", t
,
7508 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
7511 else if (!cp_omp_mappable_type (TREE_TYPE (t
)))
7513 error_at (OMP_CLAUSE_LOCATION (c
),
7514 "%qD does not have a mappable type in %qs clause", t
,
7515 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
7516 cp_omp_emit_unmappable_type_notes (TREE_TYPE (t
));
7521 if (bitmap_bit_p (&generic_head
, DECL_UID (t
)))
7523 error_at (OMP_CLAUSE_LOCATION (c
),
7524 "%qE appears more than once on the same "
7525 "%<declare target%> directive", t
);
7529 bitmap_set_bit (&generic_head
, DECL_UID (t
));
7532 case OMP_CLAUSE_UNIFORM
:
7533 t
= OMP_CLAUSE_DECL (c
);
7534 if (TREE_CODE (t
) != PARM_DECL
)
7536 if (processing_template_decl
)
7539 error_at (OMP_CLAUSE_LOCATION (c
),
7540 "%qD is not an argument in %<uniform%> clause", t
);
7542 error_at (OMP_CLAUSE_LOCATION (c
),
7543 "%qE is not an argument in %<uniform%> clause", t
);
7547 /* map_head bitmap is used as uniform_head if declare_simd. */
7548 bitmap_set_bit (&map_head
, DECL_UID (t
));
7549 goto check_dup_generic
;
7551 case OMP_CLAUSE_GRAINSIZE
:
7552 t
= OMP_CLAUSE_GRAINSIZE_EXPR (c
);
7553 if (t
== error_mark_node
)
7555 else if (!type_dependent_expression_p (t
)
7556 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
7558 error_at (OMP_CLAUSE_LOCATION (c
),
7559 "%<grainsize%> expression must be integral");
7564 t
= mark_rvalue_use (t
);
7565 if (!processing_template_decl
)
7567 t
= maybe_constant_value (t
);
7568 if (TREE_CODE (t
) == INTEGER_CST
7569 && tree_int_cst_sgn (t
) != 1)
7571 warning_at (OMP_CLAUSE_LOCATION (c
), 0,
7572 "%<grainsize%> value must be positive");
7573 t
= integer_one_node
;
7575 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
7577 OMP_CLAUSE_GRAINSIZE_EXPR (c
) = t
;
7581 case OMP_CLAUSE_PRIORITY
:
7582 t
= OMP_CLAUSE_PRIORITY_EXPR (c
);
7583 if (t
== error_mark_node
)
7585 else if (!type_dependent_expression_p (t
)
7586 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
7588 error_at (OMP_CLAUSE_LOCATION (c
),
7589 "%<priority%> expression must be integral");
7594 t
= mark_rvalue_use (t
);
7595 if (!processing_template_decl
)
7597 t
= maybe_constant_value (t
);
7598 if (TREE_CODE (t
) == INTEGER_CST
7599 && tree_int_cst_sgn (t
) == -1)
7601 warning_at (OMP_CLAUSE_LOCATION (c
), 0,
7602 "%<priority%> value must be non-negative");
7603 t
= integer_one_node
;
7605 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
7607 OMP_CLAUSE_PRIORITY_EXPR (c
) = t
;
7611 case OMP_CLAUSE_HINT
:
7612 t
= OMP_CLAUSE_HINT_EXPR (c
);
7613 if (t
== error_mark_node
)
7615 else if (!type_dependent_expression_p (t
)
7616 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
7618 error_at (OMP_CLAUSE_LOCATION (c
),
7619 "%<hint%> expression must be integral");
7624 t
= mark_rvalue_use (t
);
7625 if (!processing_template_decl
)
7627 t
= maybe_constant_value (t
);
7628 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
7629 if (TREE_CODE (t
) != INTEGER_CST
)
7631 error_at (OMP_CLAUSE_LOCATION (c
),
7632 "%<hint%> expression must be constant integer "
7637 OMP_CLAUSE_HINT_EXPR (c
) = t
;
7641 case OMP_CLAUSE_IS_DEVICE_PTR
:
7642 case OMP_CLAUSE_USE_DEVICE_PTR
:
7643 field_ok
= (ort
& C_ORT_OMP_DECLARE_SIMD
) == C_ORT_OMP
;
7644 t
= OMP_CLAUSE_DECL (c
);
7645 if (!type_dependent_expression_p (t
))
7647 tree type
= TREE_TYPE (t
);
7648 if (!TYPE_PTR_P (type
)
7649 && (!TYPE_REF_P (type
) || !TYPE_PTR_P (TREE_TYPE (type
))))
7651 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_USE_DEVICE_PTR
7652 && ort
== C_ORT_OMP
)
7654 error_at (OMP_CLAUSE_LOCATION (c
),
7655 "%qs variable is neither a pointer "
7656 "nor reference to pointer",
7657 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
7660 else if (TREE_CODE (type
) != ARRAY_TYPE
7661 && (!TYPE_REF_P (type
)
7662 || TREE_CODE (TREE_TYPE (type
)) != ARRAY_TYPE
))
7664 error_at (OMP_CLAUSE_LOCATION (c
),
7665 "%qs variable is neither a pointer, nor an "
7666 "array nor reference to pointer or array",
7667 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
7672 goto check_dup_generic
;
7674 case OMP_CLAUSE_USE_DEVICE_ADDR
:
7676 t
= OMP_CLAUSE_DECL (c
);
7677 if (!processing_template_decl
7678 && (VAR_P (t
) || TREE_CODE (t
) == PARM_DECL
)
7679 && !TYPE_REF_P (TREE_TYPE (t
))
7680 && !cxx_mark_addressable (t
))
7682 goto check_dup_generic
;
7684 case OMP_CLAUSE_NOWAIT
:
7685 case OMP_CLAUSE_DEFAULT
:
7686 case OMP_CLAUSE_UNTIED
:
7687 case OMP_CLAUSE_COLLAPSE
:
7688 case OMP_CLAUSE_MERGEABLE
:
7689 case OMP_CLAUSE_PARALLEL
:
7690 case OMP_CLAUSE_FOR
:
7691 case OMP_CLAUSE_SECTIONS
:
7692 case OMP_CLAUSE_TASKGROUP
:
7693 case OMP_CLAUSE_PROC_BIND
:
7694 case OMP_CLAUSE_DEVICE_TYPE
:
7695 case OMP_CLAUSE_NOGROUP
:
7696 case OMP_CLAUSE_THREADS
:
7697 case OMP_CLAUSE_SIMD
:
7698 case OMP_CLAUSE_DEFAULTMAP
:
7699 case OMP_CLAUSE_BIND
:
7700 case OMP_CLAUSE_AUTO
:
7701 case OMP_CLAUSE_INDEPENDENT
:
7702 case OMP_CLAUSE_SEQ
:
7703 case OMP_CLAUSE_IF_PRESENT
:
7704 case OMP_CLAUSE_FINALIZE
:
7707 case OMP_CLAUSE_TILE
:
7708 for (tree list
= OMP_CLAUSE_TILE_LIST (c
); !remove
&& list
;
7709 list
= TREE_CHAIN (list
))
7711 t
= TREE_VALUE (list
);
7713 if (t
== error_mark_node
)
7715 else if (!type_dependent_expression_p (t
)
7716 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
7718 error_at (OMP_CLAUSE_LOCATION (c
),
7719 "%<tile%> argument needs integral type");
7724 t
= mark_rvalue_use (t
);
7725 if (!processing_template_decl
)
7727 /* Zero is used to indicate '*', we permit you
7728 to get there via an ICE of value zero. */
7729 t
= maybe_constant_value (t
);
7730 if (!tree_fits_shwi_p (t
)
7731 || tree_to_shwi (t
) < 0)
7733 error_at (OMP_CLAUSE_LOCATION (c
),
7734 "%<tile%> argument needs positive "
7735 "integral constant");
7738 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
7742 /* Update list item. */
7743 TREE_VALUE (list
) = t
;
7747 case OMP_CLAUSE_ORDERED
:
7748 ordered_seen
= true;
7751 case OMP_CLAUSE_ORDER
:
7758 case OMP_CLAUSE_INBRANCH
:
7759 case OMP_CLAUSE_NOTINBRANCH
:
7762 error_at (OMP_CLAUSE_LOCATION (c
),
7763 "%<inbranch%> clause is incompatible with "
7770 case OMP_CLAUSE_INCLUSIVE
:
7771 case OMP_CLAUSE_EXCLUSIVE
:
7772 t
= omp_clause_decl_field (OMP_CLAUSE_DECL (c
));
7774 t
= OMP_CLAUSE_DECL (c
);
7775 if (t
== current_class_ptr
)
7777 error_at (OMP_CLAUSE_LOCATION (c
),
7778 "%<this%> allowed in OpenMP only in %<declare simd%>"
7784 && TREE_CODE (t
) != PARM_DECL
7785 && TREE_CODE (t
) != FIELD_DECL
)
7787 if (processing_template_decl
&& TREE_CODE (t
) != OVERLOAD
)
7790 error_at (OMP_CLAUSE_LOCATION (c
),
7791 "%qD is not a variable in clause %qs", t
,
7792 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
7794 error_at (OMP_CLAUSE_LOCATION (c
),
7795 "%qE is not a variable in clause %qs", t
,
7796 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
7806 *pc
= OMP_CLAUSE_CHAIN (c
);
7808 pc
= &OMP_CLAUSE_CHAIN (c
);
7811 if (reduction_seen
< 0 && (ordered_seen
|| schedule_seen
))
7812 reduction_seen
= -2;
7814 for (pc
= &clauses
, c
= clauses
; c
; c
= *pc
)
7816 enum omp_clause_code c_kind
= OMP_CLAUSE_CODE (c
);
7817 bool remove
= false;
7818 bool need_complete_type
= false;
7819 bool need_default_ctor
= false;
7820 bool need_copy_ctor
= false;
7821 bool need_copy_assignment
= false;
7822 bool need_implicitly_determined
= false;
7823 bool need_dtor
= false;
7824 tree type
, inner_type
;
7828 case OMP_CLAUSE_SHARED
:
7829 need_implicitly_determined
= true;
7831 case OMP_CLAUSE_PRIVATE
:
7832 need_complete_type
= true;
7833 need_default_ctor
= true;
7835 need_implicitly_determined
= true;
7837 case OMP_CLAUSE_FIRSTPRIVATE
:
7838 need_complete_type
= true;
7839 need_copy_ctor
= true;
7841 need_implicitly_determined
= true;
7843 case OMP_CLAUSE_LASTPRIVATE
:
7844 need_complete_type
= true;
7845 need_copy_assignment
= true;
7846 need_implicitly_determined
= true;
7848 case OMP_CLAUSE_REDUCTION
:
7849 if (reduction_seen
== -2)
7850 OMP_CLAUSE_REDUCTION_INSCAN (c
) = 0;
7851 if (OMP_CLAUSE_REDUCTION_INSCAN (c
))
7852 need_copy_assignment
= true;
7853 need_implicitly_determined
= true;
7855 case OMP_CLAUSE_IN_REDUCTION
:
7856 case OMP_CLAUSE_TASK_REDUCTION
:
7857 case OMP_CLAUSE_INCLUSIVE
:
7858 case OMP_CLAUSE_EXCLUSIVE
:
7859 need_implicitly_determined
= true;
7861 case OMP_CLAUSE_LINEAR
:
7862 if (ort
!= C_ORT_OMP_DECLARE_SIMD
)
7863 need_implicitly_determined
= true;
7864 else if (OMP_CLAUSE_LINEAR_VARIABLE_STRIDE (c
)
7865 && !bitmap_bit_p (&map_head
,
7866 DECL_UID (OMP_CLAUSE_LINEAR_STEP (c
))))
7868 error_at (OMP_CLAUSE_LOCATION (c
),
7869 "%<linear%> clause step is a parameter %qD not "
7870 "specified in %<uniform%> clause",
7871 OMP_CLAUSE_LINEAR_STEP (c
));
7872 *pc
= OMP_CLAUSE_CHAIN (c
);
7876 case OMP_CLAUSE_COPYPRIVATE
:
7877 need_copy_assignment
= true;
7879 case OMP_CLAUSE_COPYIN
:
7880 need_copy_assignment
= true;
7882 case OMP_CLAUSE_SIMDLEN
:
7884 && !processing_template_decl
7885 && tree_int_cst_lt (OMP_CLAUSE_SAFELEN_EXPR (safelen
),
7886 OMP_CLAUSE_SIMDLEN_EXPR (c
)))
7888 error_at (OMP_CLAUSE_LOCATION (c
),
7889 "%<simdlen%> clause value is bigger than "
7890 "%<safelen%> clause value");
7891 OMP_CLAUSE_SIMDLEN_EXPR (c
)
7892 = OMP_CLAUSE_SAFELEN_EXPR (safelen
);
7894 pc
= &OMP_CLAUSE_CHAIN (c
);
7896 case OMP_CLAUSE_SCHEDULE
:
7898 && (OMP_CLAUSE_SCHEDULE_KIND (c
)
7899 & OMP_CLAUSE_SCHEDULE_NONMONOTONIC
))
7901 error_at (OMP_CLAUSE_LOCATION (c
),
7902 "%<nonmonotonic%> schedule modifier specified "
7903 "together with %<ordered%> clause");
7904 OMP_CLAUSE_SCHEDULE_KIND (c
)
7905 = (enum omp_clause_schedule_kind
)
7906 (OMP_CLAUSE_SCHEDULE_KIND (c
)
7907 & ~OMP_CLAUSE_SCHEDULE_NONMONOTONIC
);
7909 if (reduction_seen
== -2)
7910 error_at (OMP_CLAUSE_LOCATION (c
),
7911 "%qs clause specified together with %<inscan%> "
7912 "%<reduction%> clause", "schedule");
7913 pc
= &OMP_CLAUSE_CHAIN (c
);
7915 case OMP_CLAUSE_NOGROUP
:
7918 error_at (OMP_CLAUSE_LOCATION (c
),
7919 "%<nogroup%> clause must not be used together with "
7920 "%<reduction%> clause");
7921 *pc
= OMP_CLAUSE_CHAIN (c
);
7924 pc
= &OMP_CLAUSE_CHAIN (c
);
7926 case OMP_CLAUSE_ORDERED
:
7927 if (reduction_seen
== -2)
7928 error_at (OMP_CLAUSE_LOCATION (c
),
7929 "%qs clause specified together with %<inscan%> "
7930 "%<reduction%> clause", "ordered");
7931 pc
= &OMP_CLAUSE_CHAIN (c
);
7933 case OMP_CLAUSE_ORDER
:
7936 error_at (OMP_CLAUSE_LOCATION (c
),
7937 "%<order%> clause must not be used together "
7938 "with %<ordered%>");
7939 *pc
= OMP_CLAUSE_CHAIN (c
);
7942 pc
= &OMP_CLAUSE_CHAIN (c
);
7944 case OMP_CLAUSE_NOWAIT
:
7945 if (copyprivate_seen
)
7947 error_at (OMP_CLAUSE_LOCATION (c
),
7948 "%<nowait%> clause must not be used together "
7949 "with %<copyprivate%>");
7950 *pc
= OMP_CLAUSE_CHAIN (c
);
7955 pc
= &OMP_CLAUSE_CHAIN (c
);
7959 t
= OMP_CLAUSE_DECL (c
);
7960 if (processing_template_decl
7961 && !VAR_P (t
) && TREE_CODE (t
) != PARM_DECL
)
7963 pc
= &OMP_CLAUSE_CHAIN (c
);
7969 case OMP_CLAUSE_LASTPRIVATE
:
7970 if (!bitmap_bit_p (&firstprivate_head
, DECL_UID (t
)))
7972 need_default_ctor
= true;
7977 case OMP_CLAUSE_REDUCTION
:
7978 case OMP_CLAUSE_IN_REDUCTION
:
7979 case OMP_CLAUSE_TASK_REDUCTION
:
7980 if (finish_omp_reduction_clause (c
, &need_default_ctor
,
7984 t
= OMP_CLAUSE_DECL (c
);
7987 case OMP_CLAUSE_COPYIN
:
7988 if (!VAR_P (t
) || !CP_DECL_THREAD_LOCAL_P (t
))
7990 error_at (OMP_CLAUSE_LOCATION (c
),
7991 "%qE must be %<threadprivate%> for %<copyin%>", t
);
8000 if (need_complete_type
|| need_copy_assignment
)
8002 t
= require_complete_type (t
);
8003 if (t
== error_mark_node
)
8005 else if (!processing_template_decl
8006 && TYPE_REF_P (TREE_TYPE (t
))
8007 && !complete_type_or_else (TREE_TYPE (TREE_TYPE (t
)), t
))
8010 if (need_implicitly_determined
)
8012 const char *share_name
= NULL
;
8014 if (VAR_P (t
) && CP_DECL_THREAD_LOCAL_P (t
))
8015 share_name
= "threadprivate";
8016 else switch (cxx_omp_predetermined_sharing_1 (t
))
8018 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
8020 case OMP_CLAUSE_DEFAULT_SHARED
:
8021 if ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_SHARED
8022 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
)
8023 && c_omp_predefined_variable (t
))
8024 /* The __func__ variable and similar function-local predefined
8025 variables may be listed in a shared or firstprivate
8029 && OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
8031 && cxx_omp_const_qual_no_mutable (t
))
8033 tree ctx
= CP_DECL_CONTEXT (t
);
8034 /* const qualified static data members without mutable
8035 member may be specified in firstprivate clause. */
8036 if (TYPE_P (ctx
) && MAYBE_CLASS_TYPE_P (ctx
))
8039 share_name
= "shared";
8041 case OMP_CLAUSE_DEFAULT_PRIVATE
:
8042 share_name
= "private";
8049 error_at (OMP_CLAUSE_LOCATION (c
),
8050 "%qE is predetermined %qs for %qs",
8051 omp_clause_printable_decl (t
), share_name
,
8052 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
8055 else if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_SHARED
8056 && OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_FIRSTPRIVATE
8057 && cxx_omp_const_qual_no_mutable (t
))
8059 error_at (OMP_CLAUSE_LOCATION (c
),
8060 "%<const%> qualified %qE without %<mutable%> member "
8061 "may appear only in %<shared%> or %<firstprivate%> "
8062 "clauses", omp_clause_printable_decl (t
));
8067 /* We're interested in the base element, not arrays. */
8068 inner_type
= type
= TREE_TYPE (t
);
8069 if ((need_complete_type
8070 || need_copy_assignment
8071 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
8072 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_IN_REDUCTION
8073 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_TASK_REDUCTION
)
8074 && TYPE_REF_P (inner_type
))
8075 inner_type
= TREE_TYPE (inner_type
);
8076 while (TREE_CODE (inner_type
) == ARRAY_TYPE
)
8077 inner_type
= TREE_TYPE (inner_type
);
8079 /* Check for special function availability by building a call to one.
8080 Save the results, because later we won't be in the right context
8081 for making these queries. */
8082 if (CLASS_TYPE_P (inner_type
)
8083 && COMPLETE_TYPE_P (inner_type
)
8084 && (need_default_ctor
|| need_copy_ctor
8085 || need_copy_assignment
|| need_dtor
)
8086 && !type_dependent_expression_p (t
)
8087 && cxx_omp_create_clause_info (c
, inner_type
, need_default_ctor
,
8088 need_copy_ctor
, need_copy_assignment
,
8093 && c_kind
== OMP_CLAUSE_SHARED
8094 && processing_template_decl
)
8096 t
= omp_clause_decl_field (OMP_CLAUSE_DECL (c
));
8098 OMP_CLAUSE_DECL (c
) = t
;
8102 *pc
= OMP_CLAUSE_CHAIN (c
);
8104 pc
= &OMP_CLAUSE_CHAIN (c
);
8107 bitmap_obstack_release (NULL
);
8111 /* Start processing OpenMP clauses that can include any
8112 privatization clauses for non-static data members. */
8115 push_omp_privatization_clauses (bool ignore_next
)
8117 if (omp_private_member_ignore_next
)
8119 omp_private_member_ignore_next
= ignore_next
;
8122 omp_private_member_ignore_next
= ignore_next
;
8123 if (omp_private_member_map
)
8124 omp_private_member_vec
.safe_push (error_mark_node
);
8125 return push_stmt_list ();
8128 /* Revert remapping of any non-static data members since
8129 the last push_omp_privatization_clauses () call. */
8132 pop_omp_privatization_clauses (tree stmt
)
8134 if (stmt
== NULL_TREE
)
8136 stmt
= pop_stmt_list (stmt
);
8137 if (omp_private_member_map
)
8139 while (!omp_private_member_vec
.is_empty ())
8141 tree t
= omp_private_member_vec
.pop ();
8142 if (t
== error_mark_node
)
8147 bool no_decl_expr
= t
== integer_zero_node
;
8149 t
= omp_private_member_vec
.pop ();
8150 tree
*v
= omp_private_member_map
->get (t
);
8154 omp_private_member_map
->remove (t
);
8156 delete omp_private_member_map
;
8157 omp_private_member_map
= NULL
;
8162 /* Remember OpenMP privatization clauses mapping and clear it.
8163 Used for lambdas. */
8166 save_omp_privatization_clauses (vec
<tree
> &save
)
8169 if (omp_private_member_ignore_next
)
8170 save
.safe_push (integer_one_node
);
8171 omp_private_member_ignore_next
= false;
8172 if (!omp_private_member_map
)
8175 while (!omp_private_member_vec
.is_empty ())
8177 tree t
= omp_private_member_vec
.pop ();
8178 if (t
== error_mark_node
)
8184 if (t
== integer_zero_node
)
8185 t
= omp_private_member_vec
.pop ();
8186 tree
*v
= omp_private_member_map
->get (t
);
8188 save
.safe_push (*v
);
8193 delete omp_private_member_map
;
8194 omp_private_member_map
= NULL
;
8197 /* Restore OpenMP privatization clauses mapping saved by the
8201 restore_omp_privatization_clauses (vec
<tree
> &save
)
8203 gcc_assert (omp_private_member_vec
.is_empty ());
8204 omp_private_member_ignore_next
= false;
8205 if (save
.is_empty ())
8207 if (save
.length () == 1 && save
[0] == integer_one_node
)
8209 omp_private_member_ignore_next
= true;
8214 omp_private_member_map
= new hash_map
<tree
, tree
>;
8215 while (!save
.is_empty ())
8217 tree t
= save
.pop ();
8219 if (t
!= error_mark_node
)
8221 if (t
== integer_one_node
)
8223 omp_private_member_ignore_next
= true;
8224 gcc_assert (save
.is_empty ());
8227 if (t
== integer_zero_node
)
8229 tree
&v
= omp_private_member_map
->get_or_insert (t
);
8232 omp_private_member_vec
.safe_push (t
);
8234 omp_private_member_vec
.safe_push (n
);
8239 /* For all variables in the tree_list VARS, mark them as thread local. */
8242 finish_omp_threadprivate (tree vars
)
8246 /* Mark every variable in VARS to be assigned thread local storage. */
8247 for (t
= vars
; t
; t
= TREE_CHAIN (t
))
8249 tree v
= TREE_PURPOSE (t
);
8251 if (error_operand_p (v
))
8253 else if (!VAR_P (v
))
8254 error ("%<threadprivate%> %qD is not file, namespace "
8255 "or block scope variable", v
);
8256 /* If V had already been marked threadprivate, it doesn't matter
8257 whether it had been used prior to this point. */
8258 else if (TREE_USED (v
)
8259 && (DECL_LANG_SPECIFIC (v
) == NULL
8260 || !CP_DECL_THREADPRIVATE_P (v
)))
8261 error ("%qE declared %<threadprivate%> after first use", v
);
8262 else if (! TREE_STATIC (v
) && ! DECL_EXTERNAL (v
))
8263 error ("automatic variable %qE cannot be %<threadprivate%>", v
);
8264 else if (! COMPLETE_TYPE_P (complete_type (TREE_TYPE (v
))))
8265 error ("%<threadprivate%> %qE has incomplete type", v
);
8266 else if (TREE_STATIC (v
) && TYPE_P (CP_DECL_CONTEXT (v
))
8267 && CP_DECL_CONTEXT (v
) != current_class_type
)
8268 error ("%<threadprivate%> %qE directive not "
8269 "in %qT definition", v
, CP_DECL_CONTEXT (v
));
8272 /* Allocate a LANG_SPECIFIC structure for V, if needed. */
8273 if (DECL_LANG_SPECIFIC (v
) == NULL
)
8274 retrofit_lang_decl (v
);
8276 if (! CP_DECL_THREAD_LOCAL_P (v
))
8278 CP_DECL_THREAD_LOCAL_P (v
) = true;
8279 set_decl_tls_model (v
, decl_default_tls_model (v
));
8280 /* If rtl has been already set for this var, call
8281 make_decl_rtl once again, so that encode_section_info
8282 has a chance to look at the new decl flags. */
8283 if (DECL_RTL_SET_P (v
))
8286 CP_DECL_THREADPRIVATE_P (v
) = 1;
8291 /* Build an OpenMP structured block. */
8294 begin_omp_structured_block (void)
8296 return do_pushlevel (sk_omp
);
8300 finish_omp_structured_block (tree block
)
8302 return do_poplevel (block
);
8305 /* Similarly, except force the retention of the BLOCK. */
8308 begin_omp_parallel (void)
8310 keep_next_level (true);
8311 return begin_omp_structured_block ();
8314 /* Generate OACC_DATA, with CLAUSES and BLOCK as its compound
8318 finish_oacc_data (tree clauses
, tree block
)
8322 block
= finish_omp_structured_block (block
);
8324 stmt
= make_node (OACC_DATA
);
8325 TREE_TYPE (stmt
) = void_type_node
;
8326 OACC_DATA_CLAUSES (stmt
) = clauses
;
8327 OACC_DATA_BODY (stmt
) = block
;
8329 return add_stmt (stmt
);
8332 /* Generate OACC_HOST_DATA, with CLAUSES and BLOCK as its compound
8336 finish_oacc_host_data (tree clauses
, tree block
)
8340 block
= finish_omp_structured_block (block
);
8342 stmt
= make_node (OACC_HOST_DATA
);
8343 TREE_TYPE (stmt
) = void_type_node
;
8344 OACC_HOST_DATA_CLAUSES (stmt
) = clauses
;
8345 OACC_HOST_DATA_BODY (stmt
) = block
;
8347 return add_stmt (stmt
);
8350 /* Generate OMP construct CODE, with BODY and CLAUSES as its compound
8354 finish_omp_construct (enum tree_code code
, tree body
, tree clauses
)
8356 body
= finish_omp_structured_block (body
);
8358 tree stmt
= make_node (code
);
8359 TREE_TYPE (stmt
) = void_type_node
;
8360 OMP_BODY (stmt
) = body
;
8361 OMP_CLAUSES (stmt
) = clauses
;
8363 return add_stmt (stmt
);
8367 finish_omp_parallel (tree clauses
, tree body
)
8371 body
= finish_omp_structured_block (body
);
8373 stmt
= make_node (OMP_PARALLEL
);
8374 TREE_TYPE (stmt
) = void_type_node
;
8375 OMP_PARALLEL_CLAUSES (stmt
) = clauses
;
8376 OMP_PARALLEL_BODY (stmt
) = body
;
8378 return add_stmt (stmt
);
8382 begin_omp_task (void)
8384 keep_next_level (true);
8385 return begin_omp_structured_block ();
8389 finish_omp_task (tree clauses
, tree body
)
8393 body
= finish_omp_structured_block (body
);
8395 stmt
= make_node (OMP_TASK
);
8396 TREE_TYPE (stmt
) = void_type_node
;
8397 OMP_TASK_CLAUSES (stmt
) = clauses
;
8398 OMP_TASK_BODY (stmt
) = body
;
8400 return add_stmt (stmt
);
8403 /* Helper function for finish_omp_for. Convert Ith random access iterator
8404 into integral iterator. Return FALSE if successful. */
8407 handle_omp_for_class_iterator (int i
, location_t locus
, enum tree_code code
,
8408 tree declv
, tree orig_declv
, tree initv
,
8409 tree condv
, tree incrv
, tree
*body
,
8410 tree
*pre_body
, tree
&clauses
,
8411 int collapse
, int ordered
)
8413 tree diff
, iter_init
, iter_incr
= NULL
, last
;
8414 tree incr_var
= NULL
, orig_pre_body
, orig_body
, c
;
8415 tree decl
= TREE_VEC_ELT (declv
, i
);
8416 tree init
= TREE_VEC_ELT (initv
, i
);
8417 tree cond
= TREE_VEC_ELT (condv
, i
);
8418 tree incr
= TREE_VEC_ELT (incrv
, i
);
8420 location_t elocus
= locus
;
8422 if (init
&& EXPR_HAS_LOCATION (init
))
8423 elocus
= EXPR_LOCATION (init
);
8425 switch (TREE_CODE (cond
))
8432 if (TREE_OPERAND (cond
, 1) == iter
)
8433 cond
= build2 (swap_tree_comparison (TREE_CODE (cond
)),
8434 TREE_TYPE (cond
), iter
, TREE_OPERAND (cond
, 0));
8435 if (TREE_OPERAND (cond
, 0) != iter
)
8436 cond
= error_mark_node
;
8439 tree tem
= build_x_binary_op (EXPR_LOCATION (cond
),
8442 TREE_OPERAND (cond
, 1), ERROR_MARK
,
8443 NULL
, tf_warning_or_error
);
8444 if (error_operand_p (tem
))
8449 cond
= error_mark_node
;
8452 if (cond
== error_mark_node
)
8454 error_at (elocus
, "invalid controlling predicate");
8457 diff
= build_x_binary_op (elocus
, MINUS_EXPR
, TREE_OPERAND (cond
, 1),
8458 ERROR_MARK
, iter
, ERROR_MARK
, NULL
,
8459 tf_warning_or_error
);
8460 diff
= cp_fully_fold (diff
);
8461 if (error_operand_p (diff
))
8463 if (TREE_CODE (TREE_TYPE (diff
)) != INTEGER_TYPE
)
8465 error_at (elocus
, "difference between %qE and %qD does not have integer type",
8466 TREE_OPERAND (cond
, 1), iter
);
8469 if (!c_omp_check_loop_iv_exprs (locus
, orig_declv
,
8470 TREE_VEC_ELT (declv
, i
), NULL_TREE
,
8471 cond
, cp_walk_subtrees
))
8474 switch (TREE_CODE (incr
))
8476 case PREINCREMENT_EXPR
:
8477 case PREDECREMENT_EXPR
:
8478 case POSTINCREMENT_EXPR
:
8479 case POSTDECREMENT_EXPR
:
8480 if (TREE_OPERAND (incr
, 0) != iter
)
8482 incr
= error_mark_node
;
8485 iter_incr
= build_x_unary_op (EXPR_LOCATION (incr
),
8486 TREE_CODE (incr
), iter
,
8487 tf_warning_or_error
);
8488 if (error_operand_p (iter_incr
))
8490 else if (TREE_CODE (incr
) == PREINCREMENT_EXPR
8491 || TREE_CODE (incr
) == POSTINCREMENT_EXPR
)
8492 incr
= integer_one_node
;
8494 incr
= integer_minus_one_node
;
8497 if (TREE_OPERAND (incr
, 0) != iter
)
8498 incr
= error_mark_node
;
8499 else if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
8500 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
8502 tree rhs
= TREE_OPERAND (incr
, 1);
8503 if (TREE_OPERAND (rhs
, 0) == iter
)
8505 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs
, 1)))
8507 incr
= error_mark_node
;
8510 iter_incr
= build_x_modify_expr (EXPR_LOCATION (rhs
),
8511 iter
, TREE_CODE (rhs
),
8512 TREE_OPERAND (rhs
, 1),
8513 tf_warning_or_error
);
8514 if (error_operand_p (iter_incr
))
8516 incr
= TREE_OPERAND (rhs
, 1);
8517 incr
= cp_convert (TREE_TYPE (diff
), incr
,
8518 tf_warning_or_error
);
8519 if (TREE_CODE (rhs
) == MINUS_EXPR
)
8521 incr
= build1 (NEGATE_EXPR
, TREE_TYPE (diff
), incr
);
8522 incr
= fold_simple (incr
);
8524 if (TREE_CODE (incr
) != INTEGER_CST
8525 && (TREE_CODE (incr
) != NOP_EXPR
8526 || (TREE_CODE (TREE_OPERAND (incr
, 0))
8531 else if (TREE_OPERAND (rhs
, 1) == iter
)
8533 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs
, 0))) != INTEGER_TYPE
8534 || TREE_CODE (rhs
) != PLUS_EXPR
)
8535 incr
= error_mark_node
;
8538 iter_incr
= build_x_binary_op (EXPR_LOCATION (rhs
),
8540 TREE_OPERAND (rhs
, 0),
8543 tf_warning_or_error
);
8544 if (error_operand_p (iter_incr
))
8546 iter_incr
= build_x_modify_expr (EXPR_LOCATION (rhs
),
8549 tf_warning_or_error
);
8550 if (error_operand_p (iter_incr
))
8552 incr
= TREE_OPERAND (rhs
, 0);
8557 incr
= error_mark_node
;
8560 incr
= error_mark_node
;
8563 incr
= error_mark_node
;
8567 if (incr
== error_mark_node
)
8569 error_at (elocus
, "invalid increment expression");
8573 incr
= cp_convert (TREE_TYPE (diff
), incr
, tf_warning_or_error
);
8574 incr
= cp_fully_fold (incr
);
8575 tree loop_iv_seen
= NULL_TREE
;
8576 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
8577 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
8578 && OMP_CLAUSE_DECL (c
) == iter
)
8580 if (code
== OMP_TASKLOOP
|| code
== OMP_LOOP
)
8583 OMP_CLAUSE_LASTPRIVATE_LOOP_IV (c
) = 1;
8587 else if ((code
== OMP_TASKLOOP
|| code
== OMP_LOOP
)
8588 && OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_PRIVATE
8589 && OMP_CLAUSE_DECL (c
) == iter
)
8592 if (code
== OMP_TASKLOOP
)
8593 OMP_CLAUSE_PRIVATE_TASKLOOP_IV (c
) = 1;
8596 decl
= create_temporary_var (TREE_TYPE (diff
));
8598 add_decl_expr (decl
);
8599 last
= create_temporary_var (TREE_TYPE (diff
));
8601 add_decl_expr (last
);
8602 if (c
&& iter_incr
== NULL
&& TREE_CODE (incr
) != INTEGER_CST
8603 && (!ordered
|| (i
< collapse
&& collapse
> 1)))
8605 incr_var
= create_temporary_var (TREE_TYPE (diff
));
8606 pushdecl (incr_var
);
8607 add_decl_expr (incr_var
);
8609 gcc_assert (stmts_are_full_exprs_p ());
8610 tree diffvar
= NULL_TREE
;
8611 if (code
== OMP_TASKLOOP
)
8615 tree ivc
= build_omp_clause (locus
, OMP_CLAUSE_FIRSTPRIVATE
);
8616 OMP_CLAUSE_DECL (ivc
) = iter
;
8617 cxx_omp_finish_clause (ivc
, NULL
);
8618 OMP_CLAUSE_CHAIN (ivc
) = clauses
;
8621 tree lvc
= build_omp_clause (locus
, OMP_CLAUSE_FIRSTPRIVATE
);
8622 OMP_CLAUSE_DECL (lvc
) = last
;
8623 OMP_CLAUSE_CHAIN (lvc
) = clauses
;
8625 diffvar
= create_temporary_var (TREE_TYPE (diff
));
8627 add_decl_expr (diffvar
);
8629 else if (code
== OMP_LOOP
)
8633 /* While iterators on the loop construct are predetermined
8634 lastprivate, if the decl is not declared inside of the
8635 loop, OMP_CLAUSE_LASTPRIVATE should have been added
8637 loop_iv_seen
= build_omp_clause (locus
, OMP_CLAUSE_FIRSTPRIVATE
);
8638 OMP_CLAUSE_DECL (loop_iv_seen
) = iter
;
8639 OMP_CLAUSE_CHAIN (loop_iv_seen
) = clauses
;
8640 clauses
= loop_iv_seen
;
8642 else if (OMP_CLAUSE_CODE (loop_iv_seen
) == OMP_CLAUSE_PRIVATE
)
8644 OMP_CLAUSE_PRIVATE_DEBUG (loop_iv_seen
) = 0;
8645 OMP_CLAUSE_PRIVATE_OUTER_REF (loop_iv_seen
) = 0;
8646 OMP_CLAUSE_CODE (loop_iv_seen
) = OMP_CLAUSE_FIRSTPRIVATE
;
8648 if (OMP_CLAUSE_CODE (loop_iv_seen
) == OMP_CLAUSE_FIRSTPRIVATE
)
8649 cxx_omp_finish_clause (loop_iv_seen
, NULL
);
8652 orig_pre_body
= *pre_body
;
8653 *pre_body
= push_stmt_list ();
8655 add_stmt (orig_pre_body
);
8657 finish_expr_stmt (build_x_modify_expr (elocus
,
8658 iter
, NOP_EXPR
, init
,
8659 tf_warning_or_error
));
8660 init
= build_int_cst (TREE_TYPE (diff
), 0);
8661 if (c
&& iter_incr
== NULL
8662 && (!ordered
|| (i
< collapse
&& collapse
> 1)))
8666 finish_expr_stmt (build_x_modify_expr (elocus
,
8668 incr
, tf_warning_or_error
));
8671 iter_incr
= build_x_modify_expr (elocus
,
8672 iter
, PLUS_EXPR
, incr
,
8673 tf_warning_or_error
);
8675 if (c
&& ordered
&& i
< collapse
&& collapse
> 1)
8677 finish_expr_stmt (build_x_modify_expr (elocus
,
8678 last
, NOP_EXPR
, init
,
8679 tf_warning_or_error
));
8682 finish_expr_stmt (build_x_modify_expr (elocus
,
8684 diff
, tf_warning_or_error
));
8687 *pre_body
= pop_stmt_list (*pre_body
);
8689 cond
= cp_build_binary_op (elocus
,
8690 TREE_CODE (cond
), decl
, diff
,
8691 tf_warning_or_error
);
8692 incr
= build_modify_expr (elocus
, decl
, NULL_TREE
, PLUS_EXPR
,
8693 elocus
, incr
, NULL_TREE
);
8696 *body
= push_stmt_list ();
8697 iter_init
= build2 (MINUS_EXPR
, TREE_TYPE (diff
), decl
, last
);
8698 iter_init
= build_x_modify_expr (elocus
,
8699 iter
, PLUS_EXPR
, iter_init
,
8700 tf_warning_or_error
);
8701 if (iter_init
!= error_mark_node
)
8702 iter_init
= build1 (NOP_EXPR
, void_type_node
, iter_init
);
8703 finish_expr_stmt (iter_init
);
8704 finish_expr_stmt (build_x_modify_expr (elocus
,
8705 last
, NOP_EXPR
, decl
,
8706 tf_warning_or_error
));
8707 add_stmt (orig_body
);
8708 *body
= pop_stmt_list (*body
);
8712 OMP_CLAUSE_LASTPRIVATE_STMT (c
) = push_stmt_list ();
8714 finish_expr_stmt (iter_incr
);
8718 if (i
< collapse
&& collapse
> 1 && !error_operand_p (iter_incr
))
8719 iter_init
= build2 (PLUS_EXPR
, TREE_TYPE (diff
),
8720 iter_init
, iter_incr
);
8721 iter_init
= build2 (MINUS_EXPR
, TREE_TYPE (diff
), iter_init
, last
);
8722 iter_init
= build_x_modify_expr (elocus
,
8723 iter
, PLUS_EXPR
, iter_init
,
8724 tf_warning_or_error
);
8725 if (iter_init
!= error_mark_node
)
8726 iter_init
= build1 (NOP_EXPR
, void_type_node
, iter_init
);
8727 finish_expr_stmt (iter_init
);
8729 OMP_CLAUSE_LASTPRIVATE_STMT (c
)
8730 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (c
));
8733 if (TREE_CODE (TREE_VEC_ELT (orig_declv
, i
)) == TREE_LIST
)
8735 tree t
= TREE_VEC_ELT (orig_declv
, i
);
8736 gcc_assert (TREE_PURPOSE (t
) == NULL_TREE
8737 && TREE_VALUE (t
) == NULL_TREE
8738 && TREE_CODE (TREE_CHAIN (t
)) == TREE_VEC
);
8739 TREE_PURPOSE (t
) = TREE_VEC_ELT (declv
, i
);
8740 TREE_VALUE (t
) = last
;
8743 TREE_VEC_ELT (orig_declv
, i
)
8744 = tree_cons (TREE_VEC_ELT (declv
, i
), last
, NULL_TREE
);
8745 TREE_VEC_ELT (declv
, i
) = decl
;
8746 TREE_VEC_ELT (initv
, i
) = init
;
8747 TREE_VEC_ELT (condv
, i
) = cond
;
8748 TREE_VEC_ELT (incrv
, i
) = incr
;
8753 /* Build and validate an OMP_FOR statement. CLAUSES, BODY, COND, INCR
8754 are directly for their associated operands in the statement. DECL
8755 and INIT are a combo; if DECL is NULL then INIT ought to be a
8756 MODIFY_EXPR, and the DECL should be extracted. PRE_BODY are
8757 optional statements that need to go before the loop into its
8761 finish_omp_for (location_t locus
, enum tree_code code
, tree declv
,
8762 tree orig_declv
, tree initv
, tree condv
, tree incrv
,
8763 tree body
, tree pre_body
, vec
<tree
> *orig_inits
, tree clauses
)
8765 tree omp_for
= NULL
, orig_incr
= NULL
;
8766 tree decl
= NULL
, init
, cond
, incr
;
8772 gcc_assert (TREE_VEC_LENGTH (declv
) == TREE_VEC_LENGTH (initv
));
8773 gcc_assert (TREE_VEC_LENGTH (declv
) == TREE_VEC_LENGTH (condv
));
8774 gcc_assert (TREE_VEC_LENGTH (declv
) == TREE_VEC_LENGTH (incrv
));
8775 if (TREE_VEC_LENGTH (declv
) > 1)
8779 c
= omp_find_clause (clauses
, OMP_CLAUSE_TILE
);
8781 collapse
= list_length (OMP_CLAUSE_TILE_LIST (c
));
8784 c
= omp_find_clause (clauses
, OMP_CLAUSE_COLLAPSE
);
8786 collapse
= tree_to_shwi (OMP_CLAUSE_COLLAPSE_EXPR (c
));
8787 if (collapse
!= TREE_VEC_LENGTH (declv
))
8788 ordered
= TREE_VEC_LENGTH (declv
);
8791 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
8793 decl
= TREE_VEC_ELT (declv
, i
);
8794 init
= TREE_VEC_ELT (initv
, i
);
8795 cond
= TREE_VEC_ELT (condv
, i
);
8796 incr
= TREE_VEC_ELT (incrv
, i
);
8802 switch (TREE_CODE (init
))
8805 decl
= TREE_OPERAND (init
, 0);
8806 init
= TREE_OPERAND (init
, 1);
8809 if (TREE_CODE (TREE_OPERAND (init
, 1)) == NOP_EXPR
)
8811 decl
= TREE_OPERAND (init
, 0);
8812 init
= TREE_OPERAND (init
, 2);
8822 "expected iteration declaration or initialization");
8827 if (init
&& EXPR_HAS_LOCATION (init
))
8828 elocus
= EXPR_LOCATION (init
);
8830 if (cond
== global_namespace
)
8835 error_at (elocus
, "missing controlling predicate");
8841 error_at (elocus
, "missing increment expression");
8845 TREE_VEC_ELT (declv
, i
) = decl
;
8846 TREE_VEC_ELT (initv
, i
) = init
;
8853 FOR_EACH_VEC_ELT (*orig_inits
, i
, orig_init
)
8855 && !c_omp_check_loop_iv_exprs (locus
, orig_declv
8856 ? orig_declv
: declv
,
8857 TREE_VEC_ELT (declv
, i
), orig_init
,
8858 NULL_TREE
, cp_walk_subtrees
))
8864 if (dependent_omp_for_p (declv
, initv
, condv
, incrv
))
8868 stmt
= make_node (code
);
8870 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
8872 /* This is really just a place-holder. We'll be decomposing this
8873 again and going through the cp_build_modify_expr path below when
8874 we instantiate the thing. */
8875 TREE_VEC_ELT (initv
, i
)
8876 = build2 (MODIFY_EXPR
, void_type_node
, TREE_VEC_ELT (declv
, i
),
8877 TREE_VEC_ELT (initv
, i
));
8880 TREE_TYPE (stmt
) = void_type_node
;
8881 OMP_FOR_INIT (stmt
) = initv
;
8882 OMP_FOR_COND (stmt
) = condv
;
8883 OMP_FOR_INCR (stmt
) = incrv
;
8884 OMP_FOR_BODY (stmt
) = body
;
8885 OMP_FOR_PRE_BODY (stmt
) = pre_body
;
8886 OMP_FOR_CLAUSES (stmt
) = clauses
;
8888 SET_EXPR_LOCATION (stmt
, locus
);
8889 return add_stmt (stmt
);
8893 orig_declv
= copy_node (declv
);
8895 if (processing_template_decl
)
8896 orig_incr
= make_tree_vec (TREE_VEC_LENGTH (incrv
));
8898 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); )
8900 decl
= TREE_VEC_ELT (declv
, i
);
8901 init
= TREE_VEC_ELT (initv
, i
);
8902 cond
= TREE_VEC_ELT (condv
, i
);
8903 incr
= TREE_VEC_ELT (incrv
, i
);
8905 TREE_VEC_ELT (orig_incr
, i
) = incr
;
8908 if (init
&& EXPR_HAS_LOCATION (init
))
8909 elocus
= EXPR_LOCATION (init
);
8913 error_at (elocus
, "expected iteration declaration or initialization");
8917 if (incr
&& TREE_CODE (incr
) == MODOP_EXPR
)
8920 TREE_VEC_ELT (orig_incr
, i
) = incr
;
8921 incr
= cp_build_modify_expr (elocus
, TREE_OPERAND (incr
, 0),
8922 TREE_CODE (TREE_OPERAND (incr
, 1)),
8923 TREE_OPERAND (incr
, 2),
8924 tf_warning_or_error
);
8927 if (CLASS_TYPE_P (TREE_TYPE (decl
)))
8929 if (code
== OMP_SIMD
)
8931 error_at (elocus
, "%<#pragma omp simd%> used with class "
8932 "iteration variable %qE", decl
);
8935 if (handle_omp_for_class_iterator (i
, locus
, code
, declv
, orig_declv
,
8936 initv
, condv
, incrv
, &body
,
8943 if (!INTEGRAL_TYPE_P (TREE_TYPE (decl
))
8944 && !TYPE_PTR_P (TREE_TYPE (decl
)))
8946 error_at (elocus
, "invalid type for iteration variable %qE", decl
);
8950 if (!processing_template_decl
)
8952 init
= fold_build_cleanup_point_expr (TREE_TYPE (init
), init
);
8953 init
= cp_build_modify_expr (elocus
, decl
, NOP_EXPR
, init
,
8954 tf_warning_or_error
);
8957 init
= build2 (MODIFY_EXPR
, void_type_node
, decl
, init
);
8959 && TREE_SIDE_EFFECTS (cond
)
8960 && COMPARISON_CLASS_P (cond
)
8961 && !processing_template_decl
)
8963 tree t
= TREE_OPERAND (cond
, 0);
8964 if (TREE_SIDE_EFFECTS (t
)
8966 && (TREE_CODE (t
) != NOP_EXPR
8967 || TREE_OPERAND (t
, 0) != decl
))
8968 TREE_OPERAND (cond
, 0)
8969 = fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
8971 t
= TREE_OPERAND (cond
, 1);
8972 if (TREE_SIDE_EFFECTS (t
)
8974 && (TREE_CODE (t
) != NOP_EXPR
8975 || TREE_OPERAND (t
, 0) != decl
))
8976 TREE_OPERAND (cond
, 1)
8977 = fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
8979 if (decl
== error_mark_node
|| init
== error_mark_node
)
8982 TREE_VEC_ELT (declv
, i
) = decl
;
8983 TREE_VEC_ELT (initv
, i
) = init
;
8984 TREE_VEC_ELT (condv
, i
) = cond
;
8985 TREE_VEC_ELT (incrv
, i
) = incr
;
8989 if (pre_body
&& IS_EMPTY_STMT (pre_body
))
8992 omp_for
= c_finish_omp_for (locus
, code
, declv
, orig_declv
, initv
, condv
,
8993 incrv
, body
, pre_body
,
8994 !processing_template_decl
);
8996 /* Check for iterators appearing in lb, b or incr expressions. */
8997 if (omp_for
&& !c_omp_check_loop_iv (omp_for
, orig_declv
, cp_walk_subtrees
))
8998 omp_for
= NULL_TREE
;
9000 if (omp_for
== NULL
)
9005 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INCR (omp_for
)); i
++)
9007 decl
= TREE_OPERAND (TREE_VEC_ELT (OMP_FOR_INIT (omp_for
), i
), 0);
9008 incr
= TREE_VEC_ELT (OMP_FOR_INCR (omp_for
), i
);
9010 if (TREE_CODE (incr
) != MODIFY_EXPR
)
9013 if (TREE_SIDE_EFFECTS (TREE_OPERAND (incr
, 1))
9014 && BINARY_CLASS_P (TREE_OPERAND (incr
, 1))
9015 && !processing_template_decl
)
9017 tree t
= TREE_OPERAND (TREE_OPERAND (incr
, 1), 0);
9018 if (TREE_SIDE_EFFECTS (t
)
9020 && (TREE_CODE (t
) != NOP_EXPR
9021 || TREE_OPERAND (t
, 0) != decl
))
9022 TREE_OPERAND (TREE_OPERAND (incr
, 1), 0)
9023 = fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
9025 t
= TREE_OPERAND (TREE_OPERAND (incr
, 1), 1);
9026 if (TREE_SIDE_EFFECTS (t
)
9028 && (TREE_CODE (t
) != NOP_EXPR
9029 || TREE_OPERAND (t
, 0) != decl
))
9030 TREE_OPERAND (TREE_OPERAND (incr
, 1), 1)
9031 = fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
9035 TREE_VEC_ELT (OMP_FOR_INCR (omp_for
), i
) = TREE_VEC_ELT (orig_incr
, i
);
9037 OMP_FOR_CLAUSES (omp_for
) = clauses
;
9039 /* For simd loops with non-static data member iterators, we could have added
9040 OMP_CLAUSE_LINEAR clauses without OMP_CLAUSE_LINEAR_STEP. As we know the
9041 step at this point, fill it in. */
9042 if (code
== OMP_SIMD
&& !processing_template_decl
9043 && TREE_VEC_LENGTH (OMP_FOR_INCR (omp_for
)) == 1)
9044 for (tree c
= omp_find_clause (clauses
, OMP_CLAUSE_LINEAR
); c
;
9045 c
= omp_find_clause (OMP_CLAUSE_CHAIN (c
), OMP_CLAUSE_LINEAR
))
9046 if (OMP_CLAUSE_LINEAR_STEP (c
) == NULL_TREE
)
9048 decl
= TREE_OPERAND (TREE_VEC_ELT (OMP_FOR_INIT (omp_for
), 0), 0);
9049 gcc_assert (decl
== OMP_CLAUSE_DECL (c
));
9050 incr
= TREE_VEC_ELT (OMP_FOR_INCR (omp_for
), 0);
9052 switch (TREE_CODE (incr
))
9054 case PREINCREMENT_EXPR
:
9055 case POSTINCREMENT_EXPR
:
9056 /* c_omp_for_incr_canonicalize_ptr() should have been
9057 called to massage things appropriately. */
9058 gcc_assert (!INDIRECT_TYPE_P (TREE_TYPE (decl
)));
9059 OMP_CLAUSE_LINEAR_STEP (c
) = build_int_cst (TREE_TYPE (decl
), 1);
9061 case PREDECREMENT_EXPR
:
9062 case POSTDECREMENT_EXPR
:
9063 /* c_omp_for_incr_canonicalize_ptr() should have been
9064 called to massage things appropriately. */
9065 gcc_assert (!INDIRECT_TYPE_P (TREE_TYPE (decl
)));
9066 OMP_CLAUSE_LINEAR_STEP (c
)
9067 = build_int_cst (TREE_TYPE (decl
), -1);
9070 gcc_assert (TREE_OPERAND (incr
, 0) == decl
);
9071 incr
= TREE_OPERAND (incr
, 1);
9072 switch (TREE_CODE (incr
))
9075 if (TREE_OPERAND (incr
, 1) == decl
)
9076 step
= TREE_OPERAND (incr
, 0);
9078 step
= TREE_OPERAND (incr
, 1);
9081 case POINTER_PLUS_EXPR
:
9082 gcc_assert (TREE_OPERAND (incr
, 0) == decl
);
9083 step
= TREE_OPERAND (incr
, 1);
9088 stept
= TREE_TYPE (decl
);
9089 if (INDIRECT_TYPE_P (stept
))
9091 step
= fold_convert (stept
, step
);
9092 if (TREE_CODE (incr
) == MINUS_EXPR
)
9093 step
= fold_build1 (NEGATE_EXPR
, stept
, step
);
9094 OMP_CLAUSE_LINEAR_STEP (c
) = step
;
9100 /* Override saved methods on OMP_LOOP's OMP_CLAUSE_LASTPRIVATE_LOOP_IV
9101 clauses, we need copy ctor for those rather than default ctor,
9102 plus as for other lastprivates assignment op and dtor. */
9103 if (code
== OMP_LOOP
&& !processing_template_decl
)
9104 for (tree c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
9105 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
9106 && OMP_CLAUSE_LASTPRIVATE_LOOP_IV (c
)
9107 && cxx_omp_create_clause_info (c
, TREE_TYPE (OMP_CLAUSE_DECL (c
)),
9108 false, true, true, true))
9109 CP_OMP_CLAUSE_INFO (c
) = NULL_TREE
;
9114 /* Fix up range for decls. Those decls were pushed into BIND's BIND_EXPR_VARS
9115 and need to be moved into the BIND_EXPR inside of the OMP_FOR's body. */
9118 finish_omp_for_block (tree bind
, tree omp_for
)
9120 if (omp_for
== NULL_TREE
9121 || !OMP_FOR_ORIG_DECLS (omp_for
)
9122 || bind
== NULL_TREE
9123 || TREE_CODE (bind
) != BIND_EXPR
)
9126 for (int i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (omp_for
)); i
++)
9127 if (TREE_CODE (TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (omp_for
), i
)) == TREE_LIST
9128 && TREE_CHAIN (TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (omp_for
), i
)))
9130 tree v
= TREE_CHAIN (TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (omp_for
), i
));
9131 gcc_assert (BIND_EXPR_BLOCK (bind
)
9132 && (BIND_EXPR_VARS (bind
)
9133 == BLOCK_VARS (BIND_EXPR_BLOCK (bind
))));
9134 for (int j
= 2; j
< TREE_VEC_LENGTH (v
); j
++)
9135 for (tree
*p
= &BIND_EXPR_VARS (bind
); *p
; p
= &DECL_CHAIN (*p
))
9137 if (*p
== TREE_VEC_ELT (v
, j
))
9140 *p
= DECL_CHAIN (*p
);
9143 b
= make_node (BLOCK
);
9144 b
= build3 (BIND_EXPR
, void_type_node
, NULL_TREE
,
9145 OMP_FOR_BODY (omp_for
), b
);
9146 TREE_SIDE_EFFECTS (b
) = 1;
9147 OMP_FOR_BODY (omp_for
) = b
;
9149 DECL_CHAIN (var
) = BIND_EXPR_VARS (b
);
9150 BIND_EXPR_VARS (b
) = var
;
9151 BLOCK_VARS (BIND_EXPR_BLOCK (b
)) = var
;
9154 BLOCK_VARS (BIND_EXPR_BLOCK (bind
)) = BIND_EXPR_VARS (bind
);
9160 finish_omp_atomic (location_t loc
, enum tree_code code
, enum tree_code opcode
,
9161 tree lhs
, tree rhs
, tree v
, tree lhs1
, tree rhs1
,
9162 tree clauses
, enum omp_memory_order mo
)
9177 dependent_p
= false;
9180 /* Even in a template, we can detect invalid uses of the atomic
9181 pragma if neither LHS nor RHS is type-dependent. */
9182 if (processing_template_decl
)
9184 dependent_p
= (type_dependent_expression_p (lhs
)
9185 || (rhs
&& type_dependent_expression_p (rhs
))
9186 || (v
&& type_dependent_expression_p (v
))
9187 || (lhs1
&& type_dependent_expression_p (lhs1
))
9188 || (rhs1
&& type_dependent_expression_p (rhs1
)));
9191 gcc_assert (TREE_CODE (clauses
) == OMP_CLAUSE
9192 && OMP_CLAUSE_CODE (clauses
) == OMP_CLAUSE_HINT
9193 && OMP_CLAUSE_CHAIN (clauses
) == NULL_TREE
);
9194 if (type_dependent_expression_p (OMP_CLAUSE_HINT_EXPR (clauses
))
9195 || TREE_CODE (OMP_CLAUSE_HINT_EXPR (clauses
)) != INTEGER_CST
)
9200 lhs
= build_non_dependent_expr (lhs
);
9202 rhs
= build_non_dependent_expr (rhs
);
9204 v
= build_non_dependent_expr (v
);
9206 lhs1
= build_non_dependent_expr (lhs1
);
9208 rhs1
= build_non_dependent_expr (rhs1
);
9213 bool swapped
= false;
9214 if (rhs1
&& cp_tree_equal (lhs
, rhs
))
9216 std::swap (rhs
, rhs1
);
9217 swapped
= !commutative_tree_code (opcode
);
9219 if (rhs1
&& !cp_tree_equal (lhs
, rhs1
))
9221 if (code
== OMP_ATOMIC
)
9222 error ("%<#pragma omp atomic update%> uses two different "
9223 "expressions for memory");
9225 error ("%<#pragma omp atomic capture%> uses two different "
9226 "expressions for memory");
9229 if (lhs1
&& !cp_tree_equal (lhs
, lhs1
))
9231 if (code
== OMP_ATOMIC
)
9232 error ("%<#pragma omp atomic update%> uses two different "
9233 "expressions for memory");
9235 error ("%<#pragma omp atomic capture%> uses two different "
9236 "expressions for memory");
9239 stmt
= c_finish_omp_atomic (loc
, code
, opcode
, lhs
, rhs
,
9240 v
, lhs1
, rhs1
, swapped
, mo
,
9241 processing_template_decl
!= 0);
9242 if (stmt
== error_mark_node
)
9245 if (processing_template_decl
)
9247 if (code
== OMP_ATOMIC_READ
)
9249 stmt
= build_min_nt_loc (loc
, OMP_ATOMIC_READ
, orig_lhs
);
9250 OMP_ATOMIC_MEMORY_ORDER (stmt
) = mo
;
9251 stmt
= build2 (MODIFY_EXPR
, void_type_node
, orig_v
, stmt
);
9255 if (opcode
== NOP_EXPR
)
9256 stmt
= build2 (MODIFY_EXPR
, void_type_node
, orig_lhs
, orig_rhs
);
9258 stmt
= build2 (opcode
, void_type_node
, orig_lhs
, orig_rhs
);
9260 stmt
= build_min_nt_loc (EXPR_LOCATION (orig_rhs1
),
9261 COMPOUND_EXPR
, orig_rhs1
, stmt
);
9262 if (code
!= OMP_ATOMIC
)
9264 stmt
= build_min_nt_loc (loc
, code
, orig_lhs1
, stmt
);
9265 OMP_ATOMIC_MEMORY_ORDER (stmt
) = mo
;
9266 stmt
= build2 (MODIFY_EXPR
, void_type_node
, orig_v
, stmt
);
9269 stmt
= build2 (OMP_ATOMIC
, void_type_node
,
9270 clauses
? clauses
: integer_zero_node
, stmt
);
9271 OMP_ATOMIC_MEMORY_ORDER (stmt
) = mo
;
9272 SET_EXPR_LOCATION (stmt
, loc
);
9275 /* Avoid -Wunused-value warnings here, the whole construct has side-effects
9276 and even if it might be wrapped from fold-const.c or c-omp.c wrapped
9277 in some tree that appears to be unused, the value is not unused. */
9278 warning_sentinel
w (warn_unused_value
);
9279 finish_expr_stmt (stmt
);
9283 finish_omp_barrier (void)
9285 tree fn
= builtin_decl_explicit (BUILT_IN_GOMP_BARRIER
);
9287 tree stmt
= finish_call_expr (fn
, &vec
, false, false, tf_warning_or_error
);
9288 finish_expr_stmt (stmt
);
9292 finish_omp_depobj (location_t loc
, tree depobj
,
9293 enum omp_clause_depend_kind kind
, tree clause
)
9295 if (!error_operand_p (depobj
) && !type_dependent_expression_p (depobj
))
9297 if (!lvalue_p (depobj
))
9299 error_at (EXPR_LOC_OR_LOC (depobj
, loc
),
9300 "%<depobj%> expression is not lvalue expression");
9301 depobj
= error_mark_node
;
9305 if (processing_template_decl
)
9307 if (clause
== NULL_TREE
)
9308 clause
= build_int_cst (integer_type_node
, kind
);
9309 add_stmt (build_min_nt_loc (loc
, OMP_DEPOBJ
, depobj
, clause
));
9313 if (!error_operand_p (depobj
))
9315 tree addr
= cp_build_addr_expr (depobj
, tf_warning_or_error
);
9316 if (addr
== error_mark_node
)
9317 depobj
= error_mark_node
;
9319 depobj
= cp_build_indirect_ref (loc
, addr
, RO_UNARY_STAR
,
9320 tf_warning_or_error
);
9323 c_finish_omp_depobj (loc
, depobj
, kind
, clause
);
9327 finish_omp_flush (int mo
)
9329 tree fn
= builtin_decl_explicit (BUILT_IN_SYNC_SYNCHRONIZE
);
9331 if (mo
!= MEMMODEL_LAST
)
9333 fn
= builtin_decl_explicit (BUILT_IN_ATOMIC_THREAD_FENCE
);
9334 vec
->quick_push (build_int_cst (integer_type_node
, mo
));
9336 tree stmt
= finish_call_expr (fn
, &vec
, false, false, tf_warning_or_error
);
9337 finish_expr_stmt (stmt
);
9341 finish_omp_taskwait (void)
9343 tree fn
= builtin_decl_explicit (BUILT_IN_GOMP_TASKWAIT
);
9345 tree stmt
= finish_call_expr (fn
, &vec
, false, false, tf_warning_or_error
);
9346 finish_expr_stmt (stmt
);
9350 finish_omp_taskyield (void)
9352 tree fn
= builtin_decl_explicit (BUILT_IN_GOMP_TASKYIELD
);
9354 tree stmt
= finish_call_expr (fn
, &vec
, false, false, tf_warning_or_error
);
9355 finish_expr_stmt (stmt
);
9359 finish_omp_cancel (tree clauses
)
9361 tree fn
= builtin_decl_explicit (BUILT_IN_GOMP_CANCEL
);
9363 if (omp_find_clause (clauses
, OMP_CLAUSE_PARALLEL
))
9365 else if (omp_find_clause (clauses
, OMP_CLAUSE_FOR
))
9367 else if (omp_find_clause (clauses
, OMP_CLAUSE_SECTIONS
))
9369 else if (omp_find_clause (clauses
, OMP_CLAUSE_TASKGROUP
))
9373 error ("%<#pragma omp cancel%> must specify one of "
9374 "%<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses");
9378 tree ifc
= omp_find_clause (clauses
, OMP_CLAUSE_IF
);
9379 if (ifc
!= NULL_TREE
)
9381 if (OMP_CLAUSE_IF_MODIFIER (ifc
) != ERROR_MARK
9382 && OMP_CLAUSE_IF_MODIFIER (ifc
) != VOID_CST
)
9383 error_at (OMP_CLAUSE_LOCATION (ifc
),
9384 "expected %<cancel%> %<if%> clause modifier");
9387 tree ifc2
= omp_find_clause (OMP_CLAUSE_CHAIN (ifc
), OMP_CLAUSE_IF
);
9388 if (ifc2
!= NULL_TREE
)
9390 gcc_assert (OMP_CLAUSE_IF_MODIFIER (ifc
) == VOID_CST
9391 && OMP_CLAUSE_IF_MODIFIER (ifc2
) != ERROR_MARK
9392 && OMP_CLAUSE_IF_MODIFIER (ifc2
) != VOID_CST
);
9393 error_at (OMP_CLAUSE_LOCATION (ifc2
),
9394 "expected %<cancel%> %<if%> clause modifier");
9398 if (!processing_template_decl
)
9399 ifc
= maybe_convert_cond (OMP_CLAUSE_IF_EXPR (ifc
));
9401 ifc
= build_x_binary_op (OMP_CLAUSE_LOCATION (ifc
), NE_EXPR
,
9402 OMP_CLAUSE_IF_EXPR (ifc
), ERROR_MARK
,
9403 integer_zero_node
, ERROR_MARK
,
9404 NULL
, tf_warning_or_error
);
9407 ifc
= boolean_true_node
;
9408 vec
->quick_push (build_int_cst (integer_type_node
, mask
));
9409 vec
->quick_push (ifc
);
9410 tree stmt
= finish_call_expr (fn
, &vec
, false, false, tf_warning_or_error
);
9411 finish_expr_stmt (stmt
);
9415 finish_omp_cancellation_point (tree clauses
)
9417 tree fn
= builtin_decl_explicit (BUILT_IN_GOMP_CANCELLATION_POINT
);
9419 if (omp_find_clause (clauses
, OMP_CLAUSE_PARALLEL
))
9421 else if (omp_find_clause (clauses
, OMP_CLAUSE_FOR
))
9423 else if (omp_find_clause (clauses
, OMP_CLAUSE_SECTIONS
))
9425 else if (omp_find_clause (clauses
, OMP_CLAUSE_TASKGROUP
))
9429 error ("%<#pragma omp cancellation point%> must specify one of "
9430 "%<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses");
9434 = make_tree_vector_single (build_int_cst (integer_type_node
, mask
));
9435 tree stmt
= finish_call_expr (fn
, &vec
, false, false, tf_warning_or_error
);
9436 finish_expr_stmt (stmt
);
9439 /* Begin a __transaction_atomic or __transaction_relaxed statement.
9440 If PCOMPOUND is non-null, this is for a function-transaction-block, and we
9441 should create an extra compound stmt. */
9444 begin_transaction_stmt (location_t loc
, tree
*pcompound
, int flags
)
9449 *pcompound
= begin_compound_stmt (0);
9451 r
= build_stmt (loc
, TRANSACTION_EXPR
, NULL_TREE
);
9453 /* Only add the statement to the function if support enabled. */
9457 error_at (loc
, ((flags
& TM_STMT_ATTR_RELAXED
) != 0
9458 ? G_("%<__transaction_relaxed%> without "
9459 "transactional memory support enabled")
9460 : G_("%<__transaction_atomic%> without "
9461 "transactional memory support enabled")));
9463 TRANSACTION_EXPR_BODY (r
) = push_stmt_list ();
9464 TREE_SIDE_EFFECTS (r
) = 1;
9468 /* End a __transaction_atomic or __transaction_relaxed statement.
9469 If COMPOUND_STMT is non-null, this is for a function-transaction-block,
9470 and we should end the compound. If NOEX is non-NULL, we wrap the body in
9471 a MUST_NOT_THROW_EXPR with NOEX as condition. */
9474 finish_transaction_stmt (tree stmt
, tree compound_stmt
, int flags
, tree noex
)
9476 TRANSACTION_EXPR_BODY (stmt
) = pop_stmt_list (TRANSACTION_EXPR_BODY (stmt
));
9477 TRANSACTION_EXPR_OUTER (stmt
) = (flags
& TM_STMT_ATTR_OUTER
) != 0;
9478 TRANSACTION_EXPR_RELAXED (stmt
) = (flags
& TM_STMT_ATTR_RELAXED
) != 0;
9479 TRANSACTION_EXPR_IS_STMT (stmt
) = 1;
9481 /* noexcept specifications are not allowed for function transactions. */
9482 gcc_assert (!(noex
&& compound_stmt
));
9485 tree body
= build_must_not_throw_expr (TRANSACTION_EXPR_BODY (stmt
),
9487 protected_set_expr_location
9488 (body
, EXPR_LOCATION (TRANSACTION_EXPR_BODY (stmt
)));
9489 TREE_SIDE_EFFECTS (body
) = 1;
9490 TRANSACTION_EXPR_BODY (stmt
) = body
;
9494 finish_compound_stmt (compound_stmt
);
9497 /* Build a __transaction_atomic or __transaction_relaxed expression. If
9498 NOEX is non-NULL, we wrap the body in a MUST_NOT_THROW_EXPR with NOEX as
9502 build_transaction_expr (location_t loc
, tree expr
, int flags
, tree noex
)
9507 expr
= build_must_not_throw_expr (expr
, noex
);
9508 protected_set_expr_location (expr
, loc
);
9509 TREE_SIDE_EFFECTS (expr
) = 1;
9511 ret
= build1 (TRANSACTION_EXPR
, TREE_TYPE (expr
), expr
);
9512 if (flags
& TM_STMT_ATTR_RELAXED
)
9513 TRANSACTION_EXPR_RELAXED (ret
) = 1;
9514 TREE_SIDE_EFFECTS (ret
) = 1;
9515 SET_EXPR_LOCATION (ret
, loc
);
9520 init_cp_semantics (void)
9524 /* Build a STATIC_ASSERT for a static assertion with the condition
9525 CONDITION and the message text MESSAGE. LOCATION is the location
9526 of the static assertion in the source code. When MEMBER_P, this
9527 static assertion is a member of a class. */
9529 finish_static_assert (tree condition
, tree message
, location_t location
,
9532 tsubst_flags_t complain
= tf_warning_or_error
;
9534 if (message
== NULL_TREE
9535 || message
== error_mark_node
9536 || condition
== NULL_TREE
9537 || condition
== error_mark_node
)
9540 if (check_for_bare_parameter_packs (condition
))
9541 condition
= error_mark_node
;
9543 if (instantiation_dependent_expression_p (condition
))
9545 /* We're in a template; build a STATIC_ASSERT and put it in
9549 assertion
= make_node (STATIC_ASSERT
);
9550 STATIC_ASSERT_CONDITION (assertion
) = condition
;
9551 STATIC_ASSERT_MESSAGE (assertion
) = message
;
9552 STATIC_ASSERT_SOURCE_LOCATION (assertion
) = location
;
9555 maybe_add_class_template_decl_list (current_class_type
,
9559 add_stmt (assertion
);
9564 /* Save the condition in case it was a concept check. */
9565 tree orig_condition
= condition
;
9567 /* Fold the expression and convert it to a boolean value. */
9568 condition
= perform_implicit_conversion_flags (boolean_type_node
, condition
,
9569 complain
, LOOKUP_NORMAL
);
9570 condition
= fold_non_dependent_expr (condition
, complain
,
9571 /*manifestly_const_eval=*/true);
9573 if (TREE_CODE (condition
) == INTEGER_CST
&& !integer_zerop (condition
))
9574 /* Do nothing; the condition is satisfied. */
9578 location_t saved_loc
= input_location
;
9580 input_location
= location
;
9581 if (TREE_CODE (condition
) == INTEGER_CST
9582 && integer_zerop (condition
))
9584 int sz
= TREE_INT_CST_LOW (TYPE_SIZE_UNIT
9585 (TREE_TYPE (TREE_TYPE (message
))));
9586 int len
= TREE_STRING_LENGTH (message
) / sz
- 1;
9587 /* Report the error. */
9589 error ("static assertion failed");
9591 error ("static assertion failed: %s",
9592 TREE_STRING_POINTER (message
));
9594 /* Actually explain the failure if this is a concept check. */
9595 if (concept_check_p (orig_condition
))
9596 diagnose_constraints (location
, orig_condition
, NULL_TREE
);
9598 else if (condition
&& condition
!= error_mark_node
)
9600 error ("non-constant condition for static assertion");
9601 if (require_rvalue_constant_expression (condition
))
9602 cxx_constant_value (condition
);
9604 input_location
= saved_loc
;
9608 /* Implements the C++0x decltype keyword. Returns the type of EXPR,
9609 suitable for use as a type-specifier.
9611 ID_EXPRESSION_OR_MEMBER_ACCESS_P is true when EXPR was parsed as an
9612 id-expression or a class member access, FALSE when it was parsed as
9613 a full expression. */
9616 finish_decltype_type (tree expr
, bool id_expression_or_member_access_p
,
9617 tsubst_flags_t complain
)
9619 tree type
= NULL_TREE
;
9621 if (!expr
|| error_operand_p (expr
))
9622 return error_mark_node
;
9625 || TREE_CODE (expr
) == TYPE_DECL
9626 || (TREE_CODE (expr
) == BIT_NOT_EXPR
9627 && TYPE_P (TREE_OPERAND (expr
, 0))))
9629 if (complain
& tf_error
)
9630 error ("argument to %<decltype%> must be an expression");
9631 return error_mark_node
;
9634 /* Depending on the resolution of DR 1172, we may later need to distinguish
9635 instantiation-dependent but not type-dependent expressions so that, say,
9636 A<decltype(sizeof(T))>::U doesn't require 'typename'. */
9637 if (instantiation_dependent_uneval_expression_p (expr
))
9639 type
= cxx_make_type (DECLTYPE_TYPE
);
9640 DECLTYPE_TYPE_EXPR (type
) = expr
;
9641 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type
)
9642 = id_expression_or_member_access_p
;
9643 SET_TYPE_STRUCTURAL_EQUALITY (type
);
9648 /* The type denoted by decltype(e) is defined as follows: */
9650 expr
= resolve_nondeduced_context (expr
, complain
);
9652 if (invalid_nonstatic_memfn_p (input_location
, expr
, complain
))
9653 return error_mark_node
;
9655 if (type_unknown_p (expr
))
9657 if (complain
& tf_error
)
9658 error ("%<decltype%> cannot resolve address of overloaded function");
9659 return error_mark_node
;
9662 /* To get the size of a static data member declared as an array of
9663 unknown bound, we need to instantiate it. */
9665 && VAR_HAD_UNKNOWN_BOUND (expr
)
9666 && DECL_TEMPLATE_INSTANTIATION (expr
))
9667 instantiate_decl (expr
, /*defer_ok*/true, /*expl_inst_mem*/false);
9669 if (id_expression_or_member_access_p
)
9671 /* If e is an id-expression or a class member access (5.2.5
9672 [expr.ref]), decltype(e) is defined as the type of the entity
9673 named by e. If there is no such entity, or e names a set of
9674 overloaded functions, the program is ill-formed. */
9675 if (identifier_p (expr
))
9676 expr
= lookup_name (expr
);
9678 if (INDIRECT_REF_P (expr
)
9679 || TREE_CODE (expr
) == VIEW_CONVERT_EXPR
)
9680 /* This can happen when the expression is, e.g., "a.b". Just
9681 look at the underlying operand. */
9682 expr
= TREE_OPERAND (expr
, 0);
9684 if (TREE_CODE (expr
) == OFFSET_REF
9685 || TREE_CODE (expr
) == MEMBER_REF
9686 || TREE_CODE (expr
) == SCOPE_REF
)
9687 /* We're only interested in the field itself. If it is a
9688 BASELINK, we will need to see through it in the next
9690 expr
= TREE_OPERAND (expr
, 1);
9692 if (BASELINK_P (expr
))
9693 /* See through BASELINK nodes to the underlying function. */
9694 expr
= BASELINK_FUNCTIONS (expr
);
9696 /* decltype of a decomposition name drops references in the tuple case
9697 (unlike decltype of a normal variable) and keeps cv-qualifiers from
9698 the containing object in the other cases (unlike decltype of a member
9699 access expression). */
9700 if (DECL_DECOMPOSITION_P (expr
))
9702 if (DECL_HAS_VALUE_EXPR_P (expr
))
9703 /* Expr is an array or struct subobject proxy, handle
9704 bit-fields properly. */
9705 return unlowered_expr_type (expr
);
9707 /* Expr is a reference variable for the tuple case. */
9708 return lookup_decomp_type (expr
);
9711 switch (TREE_CODE (expr
))
9714 if (DECL_BIT_FIELD_TYPE (expr
))
9716 type
= DECL_BIT_FIELD_TYPE (expr
);
9719 /* Fall through for fields that aren't bitfields. */
9727 case TEMPLATE_PARM_INDEX
:
9728 expr
= mark_type_use (expr
);
9729 type
= TREE_TYPE (expr
);
9733 type
= error_mark_node
;
9738 mark_type_use (expr
);
9739 type
= is_bitfield_expr_with_lowered_type (expr
);
9741 type
= TREE_TYPE (TREE_OPERAND (expr
, 1));
9749 /* We can get here when the id-expression refers to an
9750 enumerator or non-type template parameter. */
9751 type
= TREE_TYPE (expr
);
9755 /* Handle instantiated template non-type arguments. */
9756 type
= TREE_TYPE (expr
);
9762 /* Within a lambda-expression:
9764 Every occurrence of decltype((x)) where x is a possibly
9765 parenthesized id-expression that names an entity of
9766 automatic storage duration is treated as if x were
9767 transformed into an access to a corresponding data member
9768 of the closure type that would have been declared if x
9769 were a use of the denoted entity. */
9770 if (outer_automatic_var_p (expr
)
9771 && current_function_decl
9772 && LAMBDA_FUNCTION_P (current_function_decl
))
9773 type
= capture_decltype (expr
);
9774 else if (error_operand_p (expr
))
9775 type
= error_mark_node
;
9776 else if (expr
== current_class_ptr
)
9777 /* If the expression is just "this", we want the
9778 cv-unqualified pointer for the "this" type. */
9779 type
= TYPE_MAIN_VARIANT (TREE_TYPE (expr
));
9782 /* Otherwise, where T is the type of e, if e is an lvalue,
9783 decltype(e) is defined as T&; if an xvalue, T&&; otherwise, T. */
9784 cp_lvalue_kind clk
= lvalue_kind (expr
);
9785 type
= unlowered_expr_type (expr
);
9786 gcc_assert (!TYPE_REF_P (type
));
9788 /* For vector types, pick a non-opaque variant. */
9789 if (VECTOR_TYPE_P (type
))
9790 type
= strip_typedefs (type
);
9792 if (clk
!= clk_none
&& !(clk
& clk_class
))
9793 type
= cp_build_reference_type (type
, (clk
& clk_rvalueref
));
9800 /* Called from trait_expr_value to evaluate either __has_nothrow_assign or
9801 __has_nothrow_copy, depending on assign_p. Returns true iff all
9802 the copy {ctor,assign} fns are nothrow. */
9805 classtype_has_nothrow_assign_or_copy_p (tree type
, bool assign_p
)
9807 tree fns
= NULL_TREE
;
9809 if (assign_p
|| TYPE_HAS_COPY_CTOR (type
))
9810 fns
= get_class_binding (type
, assign_p
? assign_op_identifier
9813 bool saw_copy
= false;
9814 for (ovl_iterator
iter (fns
); iter
; ++iter
)
9818 if (copy_fn_p (fn
) > 0)
9821 if (!maybe_instantiate_noexcept (fn
)
9822 || !TYPE_NOTHROW_P (TREE_TYPE (fn
)))
9830 /* Actually evaluates the trait. */
9833 trait_expr_value (cp_trait_kind kind
, tree type1
, tree type2
)
9835 enum tree_code type_code1
;
9838 type_code1
= TREE_CODE (type1
);
9842 case CPTK_HAS_NOTHROW_ASSIGN
:
9843 type1
= strip_array_types (type1
);
9844 return (!CP_TYPE_CONST_P (type1
) && type_code1
!= REFERENCE_TYPE
9845 && (trait_expr_value (CPTK_HAS_TRIVIAL_ASSIGN
, type1
, type2
)
9846 || (CLASS_TYPE_P (type1
)
9847 && classtype_has_nothrow_assign_or_copy_p (type1
,
9850 case CPTK_HAS_TRIVIAL_ASSIGN
:
9851 /* ??? The standard seems to be missing the "or array of such a class
9852 type" wording for this trait. */
9853 type1
= strip_array_types (type1
);
9854 return (!CP_TYPE_CONST_P (type1
) && type_code1
!= REFERENCE_TYPE
9855 && (trivial_type_p (type1
)
9856 || (CLASS_TYPE_P (type1
)
9857 && TYPE_HAS_TRIVIAL_COPY_ASSIGN (type1
))));
9859 case CPTK_HAS_NOTHROW_CONSTRUCTOR
:
9860 type1
= strip_array_types (type1
);
9861 return (trait_expr_value (CPTK_HAS_TRIVIAL_CONSTRUCTOR
, type1
, type2
)
9862 || (CLASS_TYPE_P (type1
)
9863 && (t
= locate_ctor (type1
))
9864 && maybe_instantiate_noexcept (t
)
9865 && TYPE_NOTHROW_P (TREE_TYPE (t
))));
9867 case CPTK_HAS_TRIVIAL_CONSTRUCTOR
:
9868 type1
= strip_array_types (type1
);
9869 return (trivial_type_p (type1
)
9870 || (CLASS_TYPE_P (type1
) && TYPE_HAS_TRIVIAL_DFLT (type1
)));
9872 case CPTK_HAS_NOTHROW_COPY
:
9873 type1
= strip_array_types (type1
);
9874 return (trait_expr_value (CPTK_HAS_TRIVIAL_COPY
, type1
, type2
)
9875 || (CLASS_TYPE_P (type1
)
9876 && classtype_has_nothrow_assign_or_copy_p (type1
, false)));
9878 case CPTK_HAS_TRIVIAL_COPY
:
9879 /* ??? The standard seems to be missing the "or array of such a class
9880 type" wording for this trait. */
9881 type1
= strip_array_types (type1
);
9882 return (trivial_type_p (type1
) || type_code1
== REFERENCE_TYPE
9883 || (CLASS_TYPE_P (type1
) && TYPE_HAS_TRIVIAL_COPY_CTOR (type1
)));
9885 case CPTK_HAS_TRIVIAL_DESTRUCTOR
:
9886 type1
= strip_array_types (type1
);
9887 return (trivial_type_p (type1
) || type_code1
== REFERENCE_TYPE
9888 || (CLASS_TYPE_P (type1
)
9889 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type1
)));
9891 case CPTK_HAS_VIRTUAL_DESTRUCTOR
:
9892 return type_has_virtual_destructor (type1
);
9894 case CPTK_HAS_UNIQUE_OBJ_REPRESENTATIONS
:
9895 return type_has_unique_obj_representations (type1
);
9897 case CPTK_IS_ABSTRACT
:
9898 return ABSTRACT_CLASS_TYPE_P (type1
);
9900 case CPTK_IS_AGGREGATE
:
9901 return CP_AGGREGATE_TYPE_P (type1
);
9903 case CPTK_IS_BASE_OF
:
9904 return (NON_UNION_CLASS_TYPE_P (type1
) && NON_UNION_CLASS_TYPE_P (type2
)
9905 && (same_type_ignoring_top_level_qualifiers_p (type1
, type2
)
9906 || DERIVED_FROM_P (type1
, type2
)));
9909 return NON_UNION_CLASS_TYPE_P (type1
);
9912 return NON_UNION_CLASS_TYPE_P (type1
) && CLASSTYPE_EMPTY_P (type1
);
9915 return type_code1
== ENUMERAL_TYPE
;
9918 return CLASS_TYPE_P (type1
) && CLASSTYPE_FINAL (type1
);
9920 case CPTK_IS_LITERAL_TYPE
:
9921 return literal_type_p (type1
);
9924 return pod_type_p (type1
);
9926 case CPTK_IS_POLYMORPHIC
:
9927 return CLASS_TYPE_P (type1
) && TYPE_POLYMORPHIC_P (type1
);
9929 case CPTK_IS_SAME_AS
:
9930 return same_type_p (type1
, type2
);
9932 case CPTK_IS_STD_LAYOUT
:
9933 return std_layout_type_p (type1
);
9935 case CPTK_IS_TRIVIAL
:
9936 return trivial_type_p (type1
);
9938 case CPTK_IS_TRIVIALLY_ASSIGNABLE
:
9939 return is_trivially_xible (MODIFY_EXPR
, type1
, type2
);
9941 case CPTK_IS_TRIVIALLY_CONSTRUCTIBLE
:
9942 return is_trivially_xible (INIT_EXPR
, type1
, type2
);
9944 case CPTK_IS_TRIVIALLY_COPYABLE
:
9945 return trivially_copyable_p (type1
);
9948 return type_code1
== UNION_TYPE
;
9950 case CPTK_IS_ASSIGNABLE
:
9951 return is_xible (MODIFY_EXPR
, type1
, type2
);
9953 case CPTK_IS_CONSTRUCTIBLE
:
9954 return is_xible (INIT_EXPR
, type1
, type2
);
9962 /* If TYPE is an array of unknown bound, or (possibly cv-qualified)
9963 void, or a complete type, returns true, otherwise false. */
9966 check_trait_type (tree type
)
9968 if (type
== NULL_TREE
)
9971 if (TREE_CODE (type
) == TREE_LIST
)
9972 return (check_trait_type (TREE_VALUE (type
))
9973 && check_trait_type (TREE_CHAIN (type
)));
9975 if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
)
9976 && COMPLETE_TYPE_P (TREE_TYPE (type
)))
9979 if (VOID_TYPE_P (type
))
9982 return !!complete_type_or_else (strip_array_types (type
), NULL_TREE
);
9985 /* Process a trait expression. */
9988 finish_trait_expr (location_t loc
, cp_trait_kind kind
, tree type1
, tree type2
)
9990 if (type1
== error_mark_node
9991 || type2
== error_mark_node
)
9992 return error_mark_node
;
9994 if (processing_template_decl
)
9996 tree trait_expr
= make_node (TRAIT_EXPR
);
9997 TREE_TYPE (trait_expr
) = boolean_type_node
;
9998 TRAIT_EXPR_TYPE1 (trait_expr
) = type1
;
9999 TRAIT_EXPR_TYPE2 (trait_expr
) = type2
;
10000 TRAIT_EXPR_KIND (trait_expr
) = kind
;
10001 TRAIT_EXPR_LOCATION (trait_expr
) = loc
;
10007 case CPTK_HAS_NOTHROW_ASSIGN
:
10008 case CPTK_HAS_TRIVIAL_ASSIGN
:
10009 case CPTK_HAS_NOTHROW_CONSTRUCTOR
:
10010 case CPTK_HAS_TRIVIAL_CONSTRUCTOR
:
10011 case CPTK_HAS_NOTHROW_COPY
:
10012 case CPTK_HAS_TRIVIAL_COPY
:
10013 case CPTK_HAS_TRIVIAL_DESTRUCTOR
:
10014 case CPTK_HAS_UNIQUE_OBJ_REPRESENTATIONS
:
10015 case CPTK_HAS_VIRTUAL_DESTRUCTOR
:
10016 case CPTK_IS_ABSTRACT
:
10017 case CPTK_IS_AGGREGATE
:
10018 case CPTK_IS_EMPTY
:
10019 case CPTK_IS_FINAL
:
10020 case CPTK_IS_LITERAL_TYPE
:
10022 case CPTK_IS_POLYMORPHIC
:
10023 case CPTK_IS_STD_LAYOUT
:
10024 case CPTK_IS_TRIVIAL
:
10025 case CPTK_IS_TRIVIALLY_COPYABLE
:
10026 if (!check_trait_type (type1
))
10027 return error_mark_node
;
10030 case CPTK_IS_ASSIGNABLE
:
10031 case CPTK_IS_CONSTRUCTIBLE
:
10034 case CPTK_IS_TRIVIALLY_ASSIGNABLE
:
10035 case CPTK_IS_TRIVIALLY_CONSTRUCTIBLE
:
10036 if (!check_trait_type (type1
)
10037 || !check_trait_type (type2
))
10038 return error_mark_node
;
10041 case CPTK_IS_BASE_OF
:
10042 if (NON_UNION_CLASS_TYPE_P (type1
) && NON_UNION_CLASS_TYPE_P (type2
)
10043 && !same_type_ignoring_top_level_qualifiers_p (type1
, type2
)
10044 && !complete_type_or_else (type2
, NULL_TREE
))
10045 /* We already issued an error. */
10046 return error_mark_node
;
10049 case CPTK_IS_CLASS
:
10051 case CPTK_IS_UNION
:
10052 case CPTK_IS_SAME_AS
:
10056 gcc_unreachable ();
10059 tree val
= (trait_expr_value (kind
, type1
, type2
)
10060 ? boolean_true_node
: boolean_false_node
);
10061 return maybe_wrap_with_location (val
, loc
);
10064 /* Do-nothing variants of functions to handle pragma FLOAT_CONST_DECIMAL64,
10065 which is ignored for C++. */
10068 set_float_const_decimal64 (void)
10073 clear_float_const_decimal64 (void)
10078 float_const_decimal64_p (void)
10084 /* Return true if T designates the implied `this' parameter. */
10087 is_this_parameter (tree t
)
10089 if (!DECL_P (t
) || DECL_NAME (t
) != this_identifier
)
10091 gcc_assert (TREE_CODE (t
) == PARM_DECL
|| is_capture_proxy (t
)
10092 || (cp_binding_oracle
&& TREE_CODE (t
) == VAR_DECL
));
10096 /* Insert the deduced return type for an auto function. */
10099 apply_deduced_return_type (tree fco
, tree return_type
)
10103 if (return_type
== error_mark_node
)
10106 if (DECL_CONV_FN_P (fco
))
10107 DECL_NAME (fco
) = make_conv_op_name (return_type
);
10109 TREE_TYPE (fco
) = change_return_type (return_type
, TREE_TYPE (fco
));
10111 result
= DECL_RESULT (fco
);
10112 if (result
== NULL_TREE
)
10114 if (TREE_TYPE (result
) == return_type
)
10117 if (!processing_template_decl
&& !VOID_TYPE_P (return_type
)
10118 && !complete_type_or_else (return_type
, NULL_TREE
))
10121 /* We already have a DECL_RESULT from start_preparsed_function.
10122 Now we need to redo the work it and allocate_struct_function
10123 did to reflect the new type. */
10124 gcc_assert (current_function_decl
== fco
);
10125 result
= build_decl (input_location
, RESULT_DECL
, NULL_TREE
,
10126 TYPE_MAIN_VARIANT (return_type
));
10127 DECL_ARTIFICIAL (result
) = 1;
10128 DECL_IGNORED_P (result
) = 1;
10129 cp_apply_type_quals_to_decl (cp_type_quals (return_type
),
10132 DECL_RESULT (fco
) = result
;
10134 if (!processing_template_decl
)
10136 bool aggr
= aggregate_value_p (result
, fco
);
10137 #ifdef PCC_STATIC_STRUCT_RETURN
10138 cfun
->returns_pcc_struct
= aggr
;
10140 cfun
->returns_struct
= aggr
;
10144 /* DECL is a local variable or parameter from the surrounding scope of a
10145 lambda-expression. Returns the decltype for a use of the capture field
10146 for DECL even if it hasn't been captured yet. */
10149 capture_decltype (tree decl
)
10151 tree lam
= CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (current_function_decl
));
10152 tree cap
= lookup_name_real (DECL_NAME (decl
), /*type*/0, /*nonclass*/1,
10153 /*block_p=*/true, /*ns*/0, LOOKUP_HIDDEN
);
10156 if (cap
&& is_capture_proxy (cap
))
10157 type
= TREE_TYPE (cap
);
10159 switch (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lam
))
10162 error ("%qD is not captured", decl
);
10163 return error_mark_node
;
10166 type
= TREE_TYPE (decl
);
10167 if (TYPE_REF_P (type
)
10168 && TREE_CODE (TREE_TYPE (type
)) != FUNCTION_TYPE
)
10169 type
= TREE_TYPE (type
);
10172 case CPLD_REFERENCE
:
10173 type
= TREE_TYPE (decl
);
10174 if (!TYPE_REF_P (type
))
10175 type
= build_reference_type (TREE_TYPE (decl
));
10179 gcc_unreachable ();
10182 if (!TYPE_REF_P (type
))
10184 if (!LAMBDA_EXPR_MUTABLE_P (lam
))
10185 type
= cp_build_qualified_type (type
, (cp_type_quals (type
)
10186 |TYPE_QUAL_CONST
));
10187 type
= build_reference_type (type
);
10192 /* Build a unary fold expression of EXPR over OP. If IS_RIGHT is true,
10193 this is a right unary fold. Otherwise it is a left unary fold. */
10196 finish_unary_fold_expr (tree expr
, int op
, tree_code dir
)
10198 /* Build a pack expansion (assuming expr has pack type). */
10199 if (!uses_parameter_packs (expr
))
10201 error_at (location_of (expr
), "operand of fold expression has no "
10202 "unexpanded parameter packs");
10203 return error_mark_node
;
10205 tree pack
= make_pack_expansion (expr
);
10207 /* Build the fold expression. */
10208 tree code
= build_int_cstu (integer_type_node
, abs (op
));
10209 tree fold
= build_min_nt_loc (UNKNOWN_LOCATION
, dir
, code
, pack
);
10210 FOLD_EXPR_MODIFY_P (fold
) = (op
< 0);
10215 finish_left_unary_fold_expr (tree expr
, int op
)
10217 return finish_unary_fold_expr (expr
, op
, UNARY_LEFT_FOLD_EXPR
);
10221 finish_right_unary_fold_expr (tree expr
, int op
)
10223 return finish_unary_fold_expr (expr
, op
, UNARY_RIGHT_FOLD_EXPR
);
10226 /* Build a binary fold expression over EXPR1 and EXPR2. The
10227 associativity of the fold is determined by EXPR1 and EXPR2 (whichever
10228 has an unexpanded parameter pack). */
10231 finish_binary_fold_expr (tree pack
, tree init
, int op
, tree_code dir
)
10233 pack
= make_pack_expansion (pack
);
10234 tree code
= build_int_cstu (integer_type_node
, abs (op
));
10235 tree fold
= build_min_nt_loc (UNKNOWN_LOCATION
, dir
, code
, pack
, init
);
10236 FOLD_EXPR_MODIFY_P (fold
) = (op
< 0);
10241 finish_binary_fold_expr (tree expr1
, tree expr2
, int op
)
10243 // Determine which expr has an unexpanded parameter pack and
10244 // set the pack and initial term.
10245 bool pack1
= uses_parameter_packs (expr1
);
10246 bool pack2
= uses_parameter_packs (expr2
);
10247 if (pack1
&& !pack2
)
10248 return finish_binary_fold_expr (expr1
, expr2
, op
, BINARY_RIGHT_FOLD_EXPR
);
10249 else if (pack2
&& !pack1
)
10250 return finish_binary_fold_expr (expr2
, expr1
, op
, BINARY_LEFT_FOLD_EXPR
);
10254 error ("both arguments in binary fold have unexpanded parameter packs");
10256 error ("no unexpanded parameter packs in binary fold");
10258 return error_mark_node
;
10261 /* Finish __builtin_launder (arg). */
10264 finish_builtin_launder (location_t loc
, tree arg
, tsubst_flags_t complain
)
10266 tree orig_arg
= arg
;
10267 if (!type_dependent_expression_p (arg
))
10268 arg
= decay_conversion (arg
, complain
);
10269 if (error_operand_p (arg
))
10270 return error_mark_node
;
10271 if (!type_dependent_expression_p (arg
)
10272 && !TYPE_PTR_P (TREE_TYPE (arg
)))
10274 error_at (loc
, "non-pointer argument to %<__builtin_launder%>");
10275 return error_mark_node
;
10277 if (processing_template_decl
)
10279 return build_call_expr_internal_loc (loc
, IFN_LAUNDER
,
10280 TREE_TYPE (arg
), 1, arg
);
10283 /* Finish __builtin_convertvector (arg, type). */
10286 cp_build_vec_convert (tree arg
, location_t loc
, tree type
,
10287 tsubst_flags_t complain
)
10289 if (error_operand_p (type
))
10290 return error_mark_node
;
10291 if (error_operand_p (arg
))
10292 return error_mark_node
;
10294 tree ret
= NULL_TREE
;
10295 if (!type_dependent_expression_p (arg
) && !dependent_type_p (type
))
10296 ret
= c_build_vec_convert (cp_expr_loc_or_input_loc (arg
), arg
,
10297 loc
, type
, (complain
& tf_error
) != 0);
10299 if (!processing_template_decl
)
10302 return build_call_expr_internal_loc (loc
, IFN_VEC_CONVERT
, type
, 1, arg
);
10305 #include "gt-cp-semantics.h"