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-2015 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"
33 #include "double-int.h"
42 #include "stor-layout.h"
43 #include "stringpool.h"
45 #include "c-family/c-common.h"
46 #include "c-family/c-objc.h"
47 #include "tree-inline.h"
52 #include "diagnostic.h"
55 #include "plugin-api.h"
56 #include "hard-reg-set.h"
61 #include "tree-iterator.h"
63 #include "hash-table.h"
69 #include "gomp-constants.h"
71 /* There routines provide a modular interface to perform many parsing
72 operations. They may therefore be used during actual parsing, or
73 during template instantiation, which may be regarded as a
74 degenerate form of parsing. */
76 static tree
maybe_convert_cond (tree
);
77 static tree
finalize_nrv_r (tree
*, int *, void *);
78 static tree
capture_decltype (tree
);
81 /* Deferred Access Checking Overview
82 ---------------------------------
84 Most C++ expressions and declarations require access checking
85 to be performed during parsing. However, in several cases,
86 this has to be treated differently.
88 For member declarations, access checking has to be deferred
89 until more information about the declaration is known. For
101 When we are parsing the function return type `A::X', we don't
102 really know if this is allowed until we parse the function name.
104 Furthermore, some contexts require that access checking is
105 never performed at all. These include class heads, and template
108 Typical use of access checking functions is described here:
110 1. When we enter a context that requires certain access checking
111 mode, the function `push_deferring_access_checks' is called with
112 DEFERRING argument specifying the desired mode. Access checking
113 may be performed immediately (dk_no_deferred), deferred
114 (dk_deferred), or not performed (dk_no_check).
116 2. When a declaration such as a type, or a variable, is encountered,
117 the function `perform_or_defer_access_check' is called. It
118 maintains a vector of all deferred checks.
120 3. The global `current_class_type' or `current_function_decl' is then
121 setup by the parser. `enforce_access' relies on these information
124 4. Upon exiting the context mentioned in step 1,
125 `perform_deferred_access_checks' is called to check all declaration
126 stored in the vector. `pop_deferring_access_checks' is then
127 called to restore the previous access checking mode.
129 In case of parsing error, we simply call `pop_deferring_access_checks'
130 without `perform_deferred_access_checks'. */
132 typedef struct GTY(()) deferred_access
{
133 /* A vector representing name-lookups for which we have deferred
134 checking access controls. We cannot check the accessibility of
135 names used in a decl-specifier-seq until we know what is being
136 declared because code like:
143 A::B* A::f() { return 0; }
145 is valid, even though `A::B' is not generally accessible. */
146 vec
<deferred_access_check
, va_gc
> * GTY(()) deferred_access_checks
;
148 /* The current mode of access checks. */
149 enum deferring_kind deferring_access_checks_kind
;
153 /* Data for deferred access checking. */
154 static GTY(()) vec
<deferred_access
, va_gc
> *deferred_access_stack
;
155 static GTY(()) unsigned deferred_access_no_check
;
157 /* Save the current deferred access states and start deferred
158 access checking iff DEFER_P is true. */
161 push_deferring_access_checks (deferring_kind deferring
)
163 /* For context like template instantiation, access checking
164 disabling applies to all nested context. */
165 if (deferred_access_no_check
|| deferring
== dk_no_check
)
166 deferred_access_no_check
++;
169 deferred_access e
= {NULL
, deferring
};
170 vec_safe_push (deferred_access_stack
, e
);
174 /* Save the current deferred access states and start deferred access
175 checking, continuing the set of deferred checks in CHECKS. */
178 reopen_deferring_access_checks (vec
<deferred_access_check
, va_gc
> * checks
)
180 push_deferring_access_checks (dk_deferred
);
181 if (!deferred_access_no_check
)
182 deferred_access_stack
->last().deferred_access_checks
= checks
;
185 /* Resume deferring access checks again after we stopped doing
189 resume_deferring_access_checks (void)
191 if (!deferred_access_no_check
)
192 deferred_access_stack
->last().deferring_access_checks_kind
= dk_deferred
;
195 /* Stop deferring access checks. */
198 stop_deferring_access_checks (void)
200 if (!deferred_access_no_check
)
201 deferred_access_stack
->last().deferring_access_checks_kind
= dk_no_deferred
;
204 /* Discard the current deferred access checks and restore the
208 pop_deferring_access_checks (void)
210 if (deferred_access_no_check
)
211 deferred_access_no_check
--;
213 deferred_access_stack
->pop ();
216 /* Returns a TREE_LIST representing the deferred checks.
217 The TREE_PURPOSE of each node is the type through which the
218 access occurred; the TREE_VALUE is the declaration named.
221 vec
<deferred_access_check
, va_gc
> *
222 get_deferred_access_checks (void)
224 if (deferred_access_no_check
)
227 return (deferred_access_stack
->last().deferred_access_checks
);
230 /* Take current deferred checks and combine with the
231 previous states if we also defer checks previously.
232 Otherwise perform checks now. */
235 pop_to_parent_deferring_access_checks (void)
237 if (deferred_access_no_check
)
238 deferred_access_no_check
--;
241 vec
<deferred_access_check
, va_gc
> *checks
;
242 deferred_access
*ptr
;
244 checks
= (deferred_access_stack
->last ().deferred_access_checks
);
246 deferred_access_stack
->pop ();
247 ptr
= &deferred_access_stack
->last ();
248 if (ptr
->deferring_access_checks_kind
== dk_no_deferred
)
251 perform_access_checks (checks
, tf_warning_or_error
);
255 /* Merge with parent. */
257 deferred_access_check
*chk
, *probe
;
259 FOR_EACH_VEC_SAFE_ELT (checks
, i
, chk
)
261 FOR_EACH_VEC_SAFE_ELT (ptr
->deferred_access_checks
, j
, probe
)
263 if (probe
->binfo
== chk
->binfo
&&
264 probe
->decl
== chk
->decl
&&
265 probe
->diag_decl
== chk
->diag_decl
)
268 /* Insert into parent's checks. */
269 vec_safe_push (ptr
->deferred_access_checks
, *chk
);
276 /* Perform the access checks in CHECKS. The TREE_PURPOSE of each node
277 is the BINFO indicating the qualifying scope used to access the
278 DECL node stored in the TREE_VALUE of the node. If CHECKS is empty
279 or we aren't in SFINAE context or all the checks succeed return TRUE,
283 perform_access_checks (vec
<deferred_access_check
, va_gc
> *checks
,
284 tsubst_flags_t complain
)
287 deferred_access_check
*chk
;
288 location_t loc
= input_location
;
294 FOR_EACH_VEC_SAFE_ELT (checks
, i
, chk
)
296 input_location
= chk
->loc
;
297 ok
&= enforce_access (chk
->binfo
, chk
->decl
, chk
->diag_decl
, complain
);
300 input_location
= loc
;
301 return (complain
& tf_error
) ? true : ok
;
304 /* Perform the deferred access checks.
306 After performing the checks, we still have to keep the list
307 `deferred_access_stack->deferred_access_checks' since we may want
308 to check access for them again later in a different context.
315 A::X A::a, x; // No error for `A::a', error for `x'
317 We have to perform deferred access of `A::X', first with `A::a',
318 next with `x'. Return value like perform_access_checks above. */
321 perform_deferred_access_checks (tsubst_flags_t complain
)
323 return perform_access_checks (get_deferred_access_checks (), complain
);
326 /* Defer checking the accessibility of DECL, when looked up in
327 BINFO. DIAG_DECL is the declaration to use to print diagnostics.
328 Return value like perform_access_checks above. */
331 perform_or_defer_access_check (tree binfo
, tree decl
, tree diag_decl
,
332 tsubst_flags_t complain
)
335 deferred_access
*ptr
;
336 deferred_access_check
*chk
;
339 /* Exit if we are in a context that no access checking is performed.
341 if (deferred_access_no_check
)
344 gcc_assert (TREE_CODE (binfo
) == TREE_BINFO
);
346 ptr
= &deferred_access_stack
->last ();
348 /* If we are not supposed to defer access checks, just check now. */
349 if (ptr
->deferring_access_checks_kind
== dk_no_deferred
)
351 bool ok
= enforce_access (binfo
, decl
, diag_decl
, complain
);
352 return (complain
& tf_error
) ? true : ok
;
355 /* See if we are already going to perform this check. */
356 FOR_EACH_VEC_SAFE_ELT (ptr
->deferred_access_checks
, i
, chk
)
358 if (chk
->decl
== decl
&& chk
->binfo
== binfo
&&
359 chk
->diag_decl
== diag_decl
)
364 /* If not, record the check. */
365 deferred_access_check new_access
= {binfo
, decl
, diag_decl
, input_location
};
366 vec_safe_push (ptr
->deferred_access_checks
, new_access
);
371 /* Returns nonzero if the current statement is a full expression,
372 i.e. temporaries created during that statement should be destroyed
373 at the end of the statement. */
376 stmts_are_full_exprs_p (void)
378 return current_stmt_tree ()->stmts_are_full_exprs_p
;
381 /* T is a statement. Add it to the statement-tree. This is the C++
382 version. The C/ObjC frontends have a slightly different version of
388 enum tree_code code
= TREE_CODE (t
);
390 if (EXPR_P (t
) && code
!= LABEL_EXPR
)
392 if (!EXPR_HAS_LOCATION (t
))
393 SET_EXPR_LOCATION (t
, input_location
);
395 /* When we expand a statement-tree, we must know whether or not the
396 statements are full-expressions. We record that fact here. */
397 STMT_IS_FULL_EXPR_P (t
) = stmts_are_full_exprs_p ();
400 if (code
== LABEL_EXPR
|| code
== CASE_LABEL_EXPR
)
401 STATEMENT_LIST_HAS_LABEL (cur_stmt_list
) = 1;
403 /* Add T to the statement-tree. Non-side-effect statements need to be
404 recorded during statement expressions. */
405 gcc_checking_assert (!stmt_list_stack
->is_empty ());
406 append_to_statement_list_force (t
, &cur_stmt_list
);
411 /* Returns the stmt_tree to which statements are currently being added. */
414 current_stmt_tree (void)
417 ? &cfun
->language
->base
.x_stmt_tree
418 : &scope_chain
->x_stmt_tree
);
421 /* If statements are full expressions, wrap STMT in a CLEANUP_POINT_EXPR. */
424 maybe_cleanup_point_expr (tree expr
)
426 if (!processing_template_decl
&& stmts_are_full_exprs_p ())
427 expr
= fold_build_cleanup_point_expr (TREE_TYPE (expr
), expr
);
431 /* Like maybe_cleanup_point_expr except have the type of the new expression be
432 void so we don't need to create a temporary variable to hold the inner
433 expression. The reason why we do this is because the original type might be
434 an aggregate and we cannot create a temporary variable for that type. */
437 maybe_cleanup_point_expr_void (tree expr
)
439 if (!processing_template_decl
&& stmts_are_full_exprs_p ())
440 expr
= fold_build_cleanup_point_expr (void_type_node
, expr
);
446 /* Create a declaration statement for the declaration given by the DECL. */
449 add_decl_expr (tree decl
)
451 tree r
= build_stmt (input_location
, DECL_EXPR
, decl
);
452 if (DECL_INITIAL (decl
)
453 || (DECL_SIZE (decl
) && TREE_SIDE_EFFECTS (DECL_SIZE (decl
))))
454 r
= maybe_cleanup_point_expr_void (r
);
458 /* Finish a scope. */
461 do_poplevel (tree stmt_list
)
465 if (stmts_are_full_exprs_p ())
466 block
= poplevel (kept_level_p (), 1, 0);
468 stmt_list
= pop_stmt_list (stmt_list
);
470 if (!processing_template_decl
)
472 stmt_list
= c_build_bind_expr (input_location
, block
, stmt_list
);
473 /* ??? See c_end_compound_stmt re statement expressions. */
479 /* Begin a new scope. */
482 do_pushlevel (scope_kind sk
)
484 tree ret
= push_stmt_list ();
485 if (stmts_are_full_exprs_p ())
486 begin_scope (sk
, NULL
);
490 /* Queue a cleanup. CLEANUP is an expression/statement to be executed
491 when the current scope is exited. EH_ONLY is true when this is not
492 meant to apply to normal control flow transfer. */
495 push_cleanup (tree decl
, tree cleanup
, bool eh_only
)
497 tree stmt
= build_stmt (input_location
, CLEANUP_STMT
, NULL
, cleanup
, decl
);
498 CLEANUP_EH_ONLY (stmt
) = eh_only
;
500 CLEANUP_BODY (stmt
) = push_stmt_list ();
503 /* Simple infinite loop tracking for -Wreturn-type. We keep a stack of all
504 the current loops, represented by 'NULL_TREE' if we've seen a possible
505 exit, and 'error_mark_node' if not. This is currently used only to
506 suppress the warning about a function with no return statements, and
507 therefore we don't bother noting returns as possible exits. We also
508 don't bother with gotos. */
511 begin_maybe_infinite_loop (tree cond
)
513 /* Only track this while parsing a function, not during instantiation. */
514 if (!cfun
|| (DECL_TEMPLATE_INSTANTIATION (current_function_decl
)
515 && !processing_template_decl
))
517 bool maybe_infinite
= true;
520 cond
= fold_non_dependent_expr (cond
);
521 maybe_infinite
= integer_nonzerop (cond
);
523 vec_safe_push (cp_function_chain
->infinite_loops
,
524 maybe_infinite
? error_mark_node
: NULL_TREE
);
528 /* A break is a possible exit for the current loop. */
531 break_maybe_infinite_loop (void)
535 cp_function_chain
->infinite_loops
->last() = NULL_TREE
;
538 /* If we reach the end of the loop without seeing a possible exit, we have
542 end_maybe_infinite_loop (tree cond
)
544 if (!cfun
|| (DECL_TEMPLATE_INSTANTIATION (current_function_decl
)
545 && !processing_template_decl
))
547 tree current
= cp_function_chain
->infinite_loops
->pop();
548 if (current
!= NULL_TREE
)
550 cond
= fold_non_dependent_expr (cond
);
551 if (integer_nonzerop (cond
))
552 current_function_infinite_loop
= 1;
557 /* Begin a conditional that might contain a declaration. When generating
558 normal code, we want the declaration to appear before the statement
559 containing the conditional. When generating template code, we want the
560 conditional to be rendered as the raw DECL_EXPR. */
563 begin_cond (tree
*cond_p
)
565 if (processing_template_decl
)
566 *cond_p
= push_stmt_list ();
569 /* Finish such a conditional. */
572 finish_cond (tree
*cond_p
, tree expr
)
574 if (processing_template_decl
)
576 tree cond
= pop_stmt_list (*cond_p
);
578 if (expr
== NULL_TREE
)
579 /* Empty condition in 'for'. */
580 gcc_assert (empty_expr_stmt_p (cond
));
581 else if (check_for_bare_parameter_packs (expr
))
582 expr
= error_mark_node
;
583 else if (!empty_expr_stmt_p (cond
))
584 expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (expr
), cond
, expr
);
589 /* If *COND_P specifies a conditional with a declaration, transform the
592 for (; A x = 42;) { }
594 while (true) { A x = 42; if (!x) break; }
595 for (;;) { A x = 42; if (!x) break; }
596 The statement list for BODY will be empty if the conditional did
597 not declare anything. */
600 simplify_loop_decl_cond (tree
*cond_p
, tree body
)
604 if (!TREE_SIDE_EFFECTS (body
))
608 *cond_p
= boolean_true_node
;
610 if_stmt
= begin_if_stmt ();
611 cond
= cp_build_unary_op (TRUTH_NOT_EXPR
, cond
, 0, tf_warning_or_error
);
612 finish_if_stmt_cond (cond
, if_stmt
);
613 finish_break_stmt ();
614 finish_then_clause (if_stmt
);
615 finish_if_stmt (if_stmt
);
618 /* Finish a goto-statement. */
621 finish_goto_stmt (tree destination
)
623 if (identifier_p (destination
))
624 destination
= lookup_label (destination
);
626 /* We warn about unused labels with -Wunused. That means we have to
627 mark the used labels as used. */
628 if (TREE_CODE (destination
) == LABEL_DECL
)
629 TREE_USED (destination
) = 1;
632 if (check_no_cilk (destination
,
633 "Cilk array notation cannot be used as a computed goto expression",
634 "%<_Cilk_spawn%> statement cannot be used as a computed goto expression"))
635 destination
= error_mark_node
;
636 destination
= mark_rvalue_use (destination
);
637 if (!processing_template_decl
)
639 destination
= cp_convert (ptr_type_node
, destination
,
640 tf_warning_or_error
);
641 if (error_operand_p (destination
))
644 = fold_build_cleanup_point_expr (TREE_TYPE (destination
),
649 check_goto (destination
);
651 return add_stmt (build_stmt (input_location
, GOTO_EXPR
, destination
));
654 /* COND is the condition-expression for an if, while, etc.,
655 statement. Convert it to a boolean value, if appropriate.
656 In addition, verify sequence points if -Wsequence-point is enabled. */
659 maybe_convert_cond (tree cond
)
661 /* Empty conditions remain empty. */
665 /* Wait until we instantiate templates before doing conversion. */
666 if (processing_template_decl
)
669 if (warn_sequence_point
)
670 verify_sequence_points (cond
);
672 /* Do the conversion. */
673 cond
= convert_from_reference (cond
);
675 if (TREE_CODE (cond
) == MODIFY_EXPR
676 && !TREE_NO_WARNING (cond
)
679 warning (OPT_Wparentheses
,
680 "suggest parentheses around assignment used as truth value");
681 TREE_NO_WARNING (cond
) = 1;
684 return condition_conversion (cond
);
687 /* Finish an expression-statement, whose EXPRESSION is as indicated. */
690 finish_expr_stmt (tree expr
)
694 if (expr
!= NULL_TREE
)
696 if (!processing_template_decl
)
698 if (warn_sequence_point
)
699 verify_sequence_points (expr
);
700 expr
= convert_to_void (expr
, ICV_STATEMENT
, tf_warning_or_error
);
702 else if (!type_dependent_expression_p (expr
))
703 convert_to_void (build_non_dependent_expr (expr
), ICV_STATEMENT
,
704 tf_warning_or_error
);
706 if (check_for_bare_parameter_packs (expr
))
707 expr
= error_mark_node
;
709 /* Simplification of inner statement expressions, compound exprs,
710 etc can result in us already having an EXPR_STMT. */
711 if (TREE_CODE (expr
) != CLEANUP_POINT_EXPR
)
713 if (TREE_CODE (expr
) != EXPR_STMT
)
714 expr
= build_stmt (input_location
, EXPR_STMT
, expr
);
715 expr
= maybe_cleanup_point_expr_void (expr
);
725 /* Begin an if-statement. Returns a newly created IF_STMT if
732 scope
= do_pushlevel (sk_cond
);
733 r
= build_stmt (input_location
, IF_STMT
, NULL_TREE
,
734 NULL_TREE
, NULL_TREE
, scope
);
735 begin_cond (&IF_COND (r
));
739 /* Process the COND of an if-statement, which may be given by
743 finish_if_stmt_cond (tree cond
, tree if_stmt
)
745 finish_cond (&IF_COND (if_stmt
), maybe_convert_cond (cond
));
747 THEN_CLAUSE (if_stmt
) = push_stmt_list ();
750 /* Finish the then-clause of an if-statement, which may be given by
754 finish_then_clause (tree if_stmt
)
756 THEN_CLAUSE (if_stmt
) = pop_stmt_list (THEN_CLAUSE (if_stmt
));
760 /* Begin the else-clause of an if-statement. */
763 begin_else_clause (tree if_stmt
)
765 ELSE_CLAUSE (if_stmt
) = push_stmt_list ();
768 /* Finish the else-clause of an if-statement, which may be given by
772 finish_else_clause (tree if_stmt
)
774 ELSE_CLAUSE (if_stmt
) = pop_stmt_list (ELSE_CLAUSE (if_stmt
));
777 /* Finish an if-statement. */
780 finish_if_stmt (tree if_stmt
)
782 tree scope
= IF_SCOPE (if_stmt
);
783 IF_SCOPE (if_stmt
) = NULL
;
784 add_stmt (do_poplevel (scope
));
787 /* Begin a while-statement. Returns a newly created WHILE_STMT if
791 begin_while_stmt (void)
794 r
= build_stmt (input_location
, WHILE_STMT
, NULL_TREE
, NULL_TREE
);
796 WHILE_BODY (r
) = do_pushlevel (sk_block
);
797 begin_cond (&WHILE_COND (r
));
801 /* Process the COND of a while-statement, which may be given by
805 finish_while_stmt_cond (tree cond
, tree while_stmt
, bool ivdep
)
807 if (check_no_cilk (cond
,
808 "Cilk array notation cannot be used as a condition for while statement",
809 "%<_Cilk_spawn%> statement cannot be used as a condition for while statement"))
810 cond
= error_mark_node
;
811 cond
= maybe_convert_cond (cond
);
812 finish_cond (&WHILE_COND (while_stmt
), cond
);
813 begin_maybe_infinite_loop (cond
);
814 if (ivdep
&& cond
!= error_mark_node
)
815 WHILE_COND (while_stmt
) = build2 (ANNOTATE_EXPR
,
816 TREE_TYPE (WHILE_COND (while_stmt
)),
817 WHILE_COND (while_stmt
),
818 build_int_cst (integer_type_node
,
819 annot_expr_ivdep_kind
));
820 simplify_loop_decl_cond (&WHILE_COND (while_stmt
), WHILE_BODY (while_stmt
));
823 /* Finish a while-statement, which may be given by WHILE_STMT. */
826 finish_while_stmt (tree while_stmt
)
828 end_maybe_infinite_loop (boolean_true_node
);
829 WHILE_BODY (while_stmt
) = do_poplevel (WHILE_BODY (while_stmt
));
832 /* Begin a do-statement. Returns a newly created DO_STMT if
838 tree r
= build_stmt (input_location
, DO_STMT
, NULL_TREE
, NULL_TREE
);
839 begin_maybe_infinite_loop (boolean_true_node
);
841 DO_BODY (r
) = push_stmt_list ();
845 /* Finish the body of a do-statement, which may be given by DO_STMT. */
848 finish_do_body (tree do_stmt
)
850 tree body
= DO_BODY (do_stmt
) = pop_stmt_list (DO_BODY (do_stmt
));
852 if (TREE_CODE (body
) == STATEMENT_LIST
&& STATEMENT_LIST_TAIL (body
))
853 body
= STATEMENT_LIST_TAIL (body
)->stmt
;
855 if (IS_EMPTY_STMT (body
))
856 warning (OPT_Wempty_body
,
857 "suggest explicit braces around empty body in %<do%> statement");
860 /* Finish a do-statement, which may be given by DO_STMT, and whose
861 COND is as indicated. */
864 finish_do_stmt (tree cond
, tree do_stmt
, bool ivdep
)
866 if (check_no_cilk (cond
,
867 "Cilk array notation cannot be used as a condition for a do-while statement",
868 "%<_Cilk_spawn%> statement cannot be used as a condition for a do-while statement"))
869 cond
= error_mark_node
;
870 cond
= maybe_convert_cond (cond
);
871 end_maybe_infinite_loop (cond
);
872 if (ivdep
&& cond
!= error_mark_node
)
873 cond
= build2 (ANNOTATE_EXPR
, TREE_TYPE (cond
), cond
,
874 build_int_cst (integer_type_node
, annot_expr_ivdep_kind
));
875 DO_COND (do_stmt
) = cond
;
878 /* Finish a return-statement. The EXPRESSION returned, if any, is as
882 finish_return_stmt (tree expr
)
887 expr
= check_return_expr (expr
, &no_warning
);
889 if (error_operand_p (expr
)
890 || (flag_openmp
&& !check_omp_return ()))
892 /* Suppress -Wreturn-type for this function. */
893 if (warn_return_type
)
894 TREE_NO_WARNING (current_function_decl
) = true;
895 return error_mark_node
;
898 if (!processing_template_decl
)
900 if (warn_sequence_point
)
901 verify_sequence_points (expr
);
903 if (DECL_DESTRUCTOR_P (current_function_decl
)
904 || (DECL_CONSTRUCTOR_P (current_function_decl
)
905 && targetm
.cxx
.cdtor_returns_this ()))
907 /* Similarly, all destructors must run destructors for
908 base-classes before returning. So, all returns in a
909 destructor get sent to the DTOR_LABEL; finish_function emits
910 code to return a value there. */
911 return finish_goto_stmt (cdtor_label
);
915 r
= build_stmt (input_location
, RETURN_EXPR
, expr
);
916 TREE_NO_WARNING (r
) |= no_warning
;
917 r
= maybe_cleanup_point_expr_void (r
);
923 /* Begin the scope of a for-statement or a range-for-statement.
924 Both the returned trees are to be used in a call to
925 begin_for_stmt or begin_range_for_stmt. */
928 begin_for_scope (tree
*init
)
930 tree scope
= NULL_TREE
;
931 if (flag_new_for_scope
> 0)
932 scope
= do_pushlevel (sk_for
);
934 if (processing_template_decl
)
935 *init
= push_stmt_list ();
942 /* Begin a for-statement. Returns a new FOR_STMT.
943 SCOPE and INIT should be the return of begin_for_scope,
947 begin_for_stmt (tree scope
, tree init
)
951 r
= build_stmt (input_location
, FOR_STMT
, NULL_TREE
, NULL_TREE
,
952 NULL_TREE
, NULL_TREE
, NULL_TREE
);
954 if (scope
== NULL_TREE
)
956 gcc_assert (!init
|| !(flag_new_for_scope
> 0));
958 scope
= begin_for_scope (&init
);
960 FOR_INIT_STMT (r
) = init
;
961 FOR_SCOPE (r
) = scope
;
966 /* Finish the for-init-statement of a for-statement, which may be
967 given by FOR_STMT. */
970 finish_for_init_stmt (tree for_stmt
)
972 if (processing_template_decl
)
973 FOR_INIT_STMT (for_stmt
) = pop_stmt_list (FOR_INIT_STMT (for_stmt
));
975 FOR_BODY (for_stmt
) = do_pushlevel (sk_block
);
976 begin_cond (&FOR_COND (for_stmt
));
979 /* Finish the COND of a for-statement, which may be given by
983 finish_for_cond (tree cond
, tree for_stmt
, bool ivdep
)
985 if (check_no_cilk (cond
,
986 "Cilk array notation cannot be used in a condition for a for-loop",
987 "%<_Cilk_spawn%> statement cannot be used in a condition for a for-loop"))
988 cond
= error_mark_node
;
989 cond
= maybe_convert_cond (cond
);
990 finish_cond (&FOR_COND (for_stmt
), cond
);
991 begin_maybe_infinite_loop (cond
);
992 if (ivdep
&& cond
!= error_mark_node
)
993 FOR_COND (for_stmt
) = build2 (ANNOTATE_EXPR
,
994 TREE_TYPE (FOR_COND (for_stmt
)),
996 build_int_cst (integer_type_node
,
997 annot_expr_ivdep_kind
));
998 simplify_loop_decl_cond (&FOR_COND (for_stmt
), FOR_BODY (for_stmt
));
1001 /* Finish the increment-EXPRESSION in a for-statement, which may be
1002 given by FOR_STMT. */
1005 finish_for_expr (tree expr
, tree for_stmt
)
1009 /* If EXPR is an overloaded function, issue an error; there is no
1010 context available to use to perform overload resolution. */
1011 if (type_unknown_p (expr
))
1013 cxx_incomplete_type_error (expr
, TREE_TYPE (expr
));
1014 expr
= error_mark_node
;
1016 if (!processing_template_decl
)
1018 if (warn_sequence_point
)
1019 verify_sequence_points (expr
);
1020 expr
= convert_to_void (expr
, ICV_THIRD_IN_FOR
,
1021 tf_warning_or_error
);
1023 else if (!type_dependent_expression_p (expr
))
1024 convert_to_void (build_non_dependent_expr (expr
), ICV_THIRD_IN_FOR
,
1025 tf_warning_or_error
);
1026 expr
= maybe_cleanup_point_expr_void (expr
);
1027 if (check_for_bare_parameter_packs (expr
))
1028 expr
= error_mark_node
;
1029 FOR_EXPR (for_stmt
) = expr
;
1032 /* Finish the body of a for-statement, which may be given by
1033 FOR_STMT. The increment-EXPR for the loop must be
1035 It can also finish RANGE_FOR_STMT. */
1038 finish_for_stmt (tree for_stmt
)
1040 end_maybe_infinite_loop (boolean_true_node
);
1042 if (TREE_CODE (for_stmt
) == RANGE_FOR_STMT
)
1043 RANGE_FOR_BODY (for_stmt
) = do_poplevel (RANGE_FOR_BODY (for_stmt
));
1045 FOR_BODY (for_stmt
) = do_poplevel (FOR_BODY (for_stmt
));
1047 /* Pop the scope for the body of the loop. */
1048 if (flag_new_for_scope
> 0)
1051 tree
*scope_ptr
= (TREE_CODE (for_stmt
) == RANGE_FOR_STMT
1052 ? &RANGE_FOR_SCOPE (for_stmt
)
1053 : &FOR_SCOPE (for_stmt
));
1056 add_stmt (do_poplevel (scope
));
1060 /* Begin a range-for-statement. Returns a new RANGE_FOR_STMT.
1061 SCOPE and INIT should be the return of begin_for_scope,
1063 To finish it call finish_for_stmt(). */
1066 begin_range_for_stmt (tree scope
, tree init
)
1070 begin_maybe_infinite_loop (boolean_false_node
);
1072 r
= build_stmt (input_location
, RANGE_FOR_STMT
,
1073 NULL_TREE
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
1075 if (scope
== NULL_TREE
)
1077 gcc_assert (!init
|| !(flag_new_for_scope
> 0));
1079 scope
= begin_for_scope (&init
);
1082 /* RANGE_FOR_STMTs do not use nor save the init tree, so we
1085 pop_stmt_list (init
);
1086 RANGE_FOR_SCOPE (r
) = scope
;
1091 /* Finish the head of a range-based for statement, which may
1092 be given by RANGE_FOR_STMT. DECL must be the declaration
1093 and EXPR must be the loop expression. */
1096 finish_range_for_decl (tree range_for_stmt
, tree decl
, tree expr
)
1098 RANGE_FOR_DECL (range_for_stmt
) = decl
;
1099 RANGE_FOR_EXPR (range_for_stmt
) = expr
;
1100 add_stmt (range_for_stmt
);
1101 RANGE_FOR_BODY (range_for_stmt
) = do_pushlevel (sk_block
);
1104 /* Finish a break-statement. */
1107 finish_break_stmt (void)
1109 /* In switch statements break is sometimes stylistically used after
1110 a return statement. This can lead to spurious warnings about
1111 control reaching the end of a non-void function when it is
1112 inlined. Note that we are calling block_may_fallthru with
1113 language specific tree nodes; this works because
1114 block_may_fallthru returns true when given something it does not
1116 if (!block_may_fallthru (cur_stmt_list
))
1118 return add_stmt (build_stmt (input_location
, BREAK_STMT
));
1121 /* Finish a continue-statement. */
1124 finish_continue_stmt (void)
1126 return add_stmt (build_stmt (input_location
, CONTINUE_STMT
));
1129 /* Begin a switch-statement. Returns a new SWITCH_STMT if
1133 begin_switch_stmt (void)
1137 scope
= do_pushlevel (sk_cond
);
1138 r
= build_stmt (input_location
, SWITCH_STMT
, NULL_TREE
, NULL_TREE
, NULL_TREE
, scope
);
1140 begin_cond (&SWITCH_STMT_COND (r
));
1145 /* Finish the cond of a switch-statement. */
1148 finish_switch_cond (tree cond
, tree switch_stmt
)
1150 tree orig_type
= NULL
;
1152 if (check_no_cilk (cond
,
1153 "Cilk array notation cannot be used as a condition for switch statement",
1154 "%<_Cilk_spawn%> statement cannot be used as a condition for switch statement"))
1155 cond
= error_mark_node
;
1157 if (!processing_template_decl
)
1159 /* Convert the condition to an integer or enumeration type. */
1160 cond
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
, cond
, true);
1161 if (cond
== NULL_TREE
)
1163 error ("switch quantity not an integer");
1164 cond
= error_mark_node
;
1166 /* We want unlowered type here to handle enum bit-fields. */
1167 orig_type
= unlowered_expr_type (cond
);
1168 if (cond
!= error_mark_node
)
1170 /* Warn if the condition has boolean value. */
1171 if (TREE_CODE (orig_type
) == BOOLEAN_TYPE
)
1172 warning_at (input_location
, OPT_Wswitch_bool
,
1173 "switch condition has type bool");
1177 Integral promotions are performed. */
1178 cond
= perform_integral_promotions (cond
);
1179 cond
= maybe_cleanup_point_expr (cond
);
1182 if (check_for_bare_parameter_packs (cond
))
1183 cond
= error_mark_node
;
1184 else if (!processing_template_decl
&& warn_sequence_point
)
1185 verify_sequence_points (cond
);
1187 finish_cond (&SWITCH_STMT_COND (switch_stmt
), cond
);
1188 SWITCH_STMT_TYPE (switch_stmt
) = orig_type
;
1189 add_stmt (switch_stmt
);
1190 push_switch (switch_stmt
);
1191 SWITCH_STMT_BODY (switch_stmt
) = push_stmt_list ();
1194 /* Finish the body of a switch-statement, which may be given by
1195 SWITCH_STMT. The COND to switch on is indicated. */
1198 finish_switch_stmt (tree switch_stmt
)
1202 SWITCH_STMT_BODY (switch_stmt
) =
1203 pop_stmt_list (SWITCH_STMT_BODY (switch_stmt
));
1206 scope
= SWITCH_STMT_SCOPE (switch_stmt
);
1207 SWITCH_STMT_SCOPE (switch_stmt
) = NULL
;
1208 add_stmt (do_poplevel (scope
));
1211 /* Begin a try-block. Returns a newly-created TRY_BLOCK if
1215 begin_try_block (void)
1217 tree r
= build_stmt (input_location
, TRY_BLOCK
, NULL_TREE
, NULL_TREE
);
1219 TRY_STMTS (r
) = push_stmt_list ();
1223 /* Likewise, for a function-try-block. The block returned in
1224 *COMPOUND_STMT is an artificial outer scope, containing the
1225 function-try-block. */
1228 begin_function_try_block (tree
*compound_stmt
)
1231 /* This outer scope does not exist in the C++ standard, but we need
1232 a place to put __FUNCTION__ and similar variables. */
1233 *compound_stmt
= begin_compound_stmt (0);
1234 r
= begin_try_block ();
1235 FN_TRY_BLOCK_P (r
) = 1;
1239 /* Finish a try-block, which may be given by TRY_BLOCK. */
1242 finish_try_block (tree try_block
)
1244 TRY_STMTS (try_block
) = pop_stmt_list (TRY_STMTS (try_block
));
1245 TRY_HANDLERS (try_block
) = push_stmt_list ();
1248 /* Finish the body of a cleanup try-block, which may be given by
1252 finish_cleanup_try_block (tree try_block
)
1254 TRY_STMTS (try_block
) = pop_stmt_list (TRY_STMTS (try_block
));
1257 /* Finish an implicitly generated try-block, with a cleanup is given
1261 finish_cleanup (tree cleanup
, tree try_block
)
1263 TRY_HANDLERS (try_block
) = cleanup
;
1264 CLEANUP_P (try_block
) = 1;
1267 /* Likewise, for a function-try-block. */
1270 finish_function_try_block (tree try_block
)
1272 finish_try_block (try_block
);
1273 /* FIXME : something queer about CTOR_INITIALIZER somehow following
1274 the try block, but moving it inside. */
1275 in_function_try_handler
= 1;
1278 /* Finish a handler-sequence for a try-block, which may be given by
1282 finish_handler_sequence (tree try_block
)
1284 TRY_HANDLERS (try_block
) = pop_stmt_list (TRY_HANDLERS (try_block
));
1285 check_handlers (TRY_HANDLERS (try_block
));
1288 /* Finish the handler-seq for a function-try-block, given by
1289 TRY_BLOCK. COMPOUND_STMT is the outer block created by
1290 begin_function_try_block. */
1293 finish_function_handler_sequence (tree try_block
, tree compound_stmt
)
1295 in_function_try_handler
= 0;
1296 finish_handler_sequence (try_block
);
1297 finish_compound_stmt (compound_stmt
);
1300 /* Begin a handler. Returns a HANDLER if appropriate. */
1303 begin_handler (void)
1307 r
= build_stmt (input_location
, HANDLER
, NULL_TREE
, NULL_TREE
);
1310 /* Create a binding level for the eh_info and the exception object
1312 HANDLER_BODY (r
) = do_pushlevel (sk_catch
);
1317 /* Finish the handler-parameters for a handler, which may be given by
1318 HANDLER. DECL is the declaration for the catch parameter, or NULL
1319 if this is a `catch (...)' clause. */
1322 finish_handler_parms (tree decl
, tree handler
)
1324 tree type
= NULL_TREE
;
1325 if (processing_template_decl
)
1329 decl
= pushdecl (decl
);
1330 decl
= push_template_decl (decl
);
1331 HANDLER_PARMS (handler
) = decl
;
1332 type
= TREE_TYPE (decl
);
1336 type
= expand_start_catch_block (decl
);
1337 HANDLER_TYPE (handler
) = type
;
1340 /* Finish a handler, which may be given by HANDLER. The BLOCKs are
1341 the return value from the matching call to finish_handler_parms. */
1344 finish_handler (tree handler
)
1346 if (!processing_template_decl
)
1347 expand_end_catch_block ();
1348 HANDLER_BODY (handler
) = do_poplevel (HANDLER_BODY (handler
));
1351 /* Begin a compound statement. FLAGS contains some bits that control the
1352 behavior and context. If BCS_NO_SCOPE is set, the compound statement
1353 does not define a scope. If BCS_FN_BODY is set, this is the outermost
1354 block of a function. If BCS_TRY_BLOCK is set, this is the block
1355 created on behalf of a TRY statement. Returns a token to be passed to
1356 finish_compound_stmt. */
1359 begin_compound_stmt (unsigned int flags
)
1363 if (flags
& BCS_NO_SCOPE
)
1365 r
= push_stmt_list ();
1366 STATEMENT_LIST_NO_SCOPE (r
) = 1;
1368 /* Normally, we try hard to keep the BLOCK for a statement-expression.
1369 But, if it's a statement-expression with a scopeless block, there's
1370 nothing to keep, and we don't want to accidentally keep a block
1371 *inside* the scopeless block. */
1372 keep_next_level (false);
1375 r
= do_pushlevel (flags
& BCS_TRY_BLOCK
? sk_try
: sk_block
);
1377 /* When processing a template, we need to remember where the braces were,
1378 so that we can set up identical scopes when instantiating the template
1379 later. BIND_EXPR is a handy candidate for this.
1380 Note that do_poplevel won't create a BIND_EXPR itself here (and thus
1381 result in nested BIND_EXPRs), since we don't build BLOCK nodes when
1382 processing templates. */
1383 if (processing_template_decl
)
1385 r
= build3 (BIND_EXPR
, NULL
, NULL
, r
, NULL
);
1386 BIND_EXPR_TRY_BLOCK (r
) = (flags
& BCS_TRY_BLOCK
) != 0;
1387 BIND_EXPR_BODY_BLOCK (r
) = (flags
& BCS_FN_BODY
) != 0;
1388 TREE_SIDE_EFFECTS (r
) = 1;
1394 /* Finish a compound-statement, which is given by STMT. */
1397 finish_compound_stmt (tree stmt
)
1399 if (TREE_CODE (stmt
) == BIND_EXPR
)
1401 tree body
= do_poplevel (BIND_EXPR_BODY (stmt
));
1402 /* If the STATEMENT_LIST is empty and this BIND_EXPR isn't special,
1403 discard the BIND_EXPR so it can be merged with the containing
1405 if (TREE_CODE (body
) == STATEMENT_LIST
1406 && STATEMENT_LIST_HEAD (body
) == NULL
1407 && !BIND_EXPR_BODY_BLOCK (stmt
)
1408 && !BIND_EXPR_TRY_BLOCK (stmt
))
1411 BIND_EXPR_BODY (stmt
) = body
;
1413 else if (STATEMENT_LIST_NO_SCOPE (stmt
))
1414 stmt
= pop_stmt_list (stmt
);
1417 /* Destroy any ObjC "super" receivers that may have been
1419 objc_clear_super_receiver ();
1421 stmt
= do_poplevel (stmt
);
1424 /* ??? See c_end_compound_stmt wrt statement expressions. */
1428 /* Finish an asm-statement, whose components are a STRING, some
1429 OUTPUT_OPERANDS, some INPUT_OPERANDS, some CLOBBERS and some
1430 LABELS. Also note whether the asm-statement should be
1431 considered volatile. */
1434 finish_asm_stmt (int volatile_p
, tree string
, tree output_operands
,
1435 tree input_operands
, tree clobbers
, tree labels
)
1439 int ninputs
= list_length (input_operands
);
1440 int noutputs
= list_length (output_operands
);
1442 if (!processing_template_decl
)
1444 const char *constraint
;
1445 const char **oconstraints
;
1446 bool allows_mem
, allows_reg
, is_inout
;
1450 oconstraints
= XALLOCAVEC (const char *, noutputs
);
1452 string
= resolve_asm_operand_names (string
, output_operands
,
1453 input_operands
, labels
);
1455 for (i
= 0, t
= output_operands
; t
; t
= TREE_CHAIN (t
), ++i
)
1457 operand
= TREE_VALUE (t
);
1459 /* ??? Really, this should not be here. Users should be using a
1460 proper lvalue, dammit. But there's a long history of using
1461 casts in the output operands. In cases like longlong.h, this
1462 becomes a primitive form of typechecking -- if the cast can be
1463 removed, then the output operand had a type of the proper width;
1464 otherwise we'll get an error. Gross, but ... */
1465 STRIP_NOPS (operand
);
1467 operand
= mark_lvalue_use (operand
);
1469 if (!lvalue_or_else (operand
, lv_asm
, tf_warning_or_error
))
1470 operand
= error_mark_node
;
1472 if (operand
!= error_mark_node
1473 && (TREE_READONLY (operand
)
1474 || CP_TYPE_CONST_P (TREE_TYPE (operand
))
1475 /* Functions are not modifiable, even though they are
1477 || TREE_CODE (TREE_TYPE (operand
)) == FUNCTION_TYPE
1478 || TREE_CODE (TREE_TYPE (operand
)) == METHOD_TYPE
1479 /* If it's an aggregate and any field is const, then it is
1480 effectively const. */
1481 || (CLASS_TYPE_P (TREE_TYPE (operand
))
1482 && C_TYPE_FIELDS_READONLY (TREE_TYPE (operand
)))))
1483 cxx_readonly_error (operand
, lv_asm
);
1485 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
1486 oconstraints
[i
] = constraint
;
1488 if (parse_output_constraint (&constraint
, i
, ninputs
, noutputs
,
1489 &allows_mem
, &allows_reg
, &is_inout
))
1491 /* If the operand is going to end up in memory,
1492 mark it addressable. */
1493 if (!allows_reg
&& !cxx_mark_addressable (operand
))
1494 operand
= error_mark_node
;
1497 operand
= error_mark_node
;
1499 TREE_VALUE (t
) = operand
;
1502 for (i
= 0, t
= input_operands
; t
; ++i
, t
= TREE_CHAIN (t
))
1504 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
1505 bool constraint_parsed
1506 = parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, 0,
1507 oconstraints
, &allows_mem
, &allows_reg
);
1508 /* If the operand is going to end up in memory, don't call
1509 decay_conversion. */
1510 if (constraint_parsed
&& !allows_reg
&& allows_mem
)
1511 operand
= mark_lvalue_use (TREE_VALUE (t
));
1513 operand
= decay_conversion (TREE_VALUE (t
), tf_warning_or_error
);
1515 /* If the type of the operand hasn't been determined (e.g.,
1516 because it involves an overloaded function), then issue
1517 an error message. There's no context available to
1518 resolve the overloading. */
1519 if (TREE_TYPE (operand
) == unknown_type_node
)
1521 error ("type of asm operand %qE could not be determined",
1523 operand
= error_mark_node
;
1526 if (constraint_parsed
)
1528 /* If the operand is going to end up in memory,
1529 mark it addressable. */
1530 if (!allows_reg
&& allows_mem
)
1532 /* Strip the nops as we allow this case. FIXME, this really
1533 should be rejected or made deprecated. */
1534 STRIP_NOPS (operand
);
1535 if (!cxx_mark_addressable (operand
))
1536 operand
= error_mark_node
;
1538 else if (!allows_reg
&& !allows_mem
)
1540 /* If constraint allows neither register nor memory,
1541 try harder to get a constant. */
1542 tree constop
= maybe_constant_value (operand
);
1543 if (TREE_CONSTANT (constop
))
1548 operand
= error_mark_node
;
1550 TREE_VALUE (t
) = operand
;
1554 r
= build_stmt (input_location
, ASM_EXPR
, string
,
1555 output_operands
, input_operands
,
1557 ASM_VOLATILE_P (r
) = volatile_p
|| noutputs
== 0;
1558 r
= maybe_cleanup_point_expr_void (r
);
1559 return add_stmt (r
);
1562 /* Finish a label with the indicated NAME. Returns the new label. */
1565 finish_label_stmt (tree name
)
1567 tree decl
= define_label (input_location
, name
);
1569 if (decl
== error_mark_node
)
1570 return error_mark_node
;
1572 add_stmt (build_stmt (input_location
, LABEL_EXPR
, decl
));
1577 /* Finish a series of declarations for local labels. G++ allows users
1578 to declare "local" labels, i.e., labels with scope. This extension
1579 is useful when writing code involving statement-expressions. */
1582 finish_label_decl (tree name
)
1584 if (!at_function_scope_p ())
1586 error ("__label__ declarations are only allowed in function scopes");
1590 add_decl_expr (declare_local_label (name
));
1593 /* When DECL goes out of scope, make sure that CLEANUP is executed. */
1596 finish_decl_cleanup (tree decl
, tree cleanup
)
1598 push_cleanup (decl
, cleanup
, false);
1601 /* If the current scope exits with an exception, run CLEANUP. */
1604 finish_eh_cleanup (tree cleanup
)
1606 push_cleanup (NULL
, cleanup
, true);
1609 /* The MEM_INITS is a list of mem-initializers, in reverse of the
1610 order they were written by the user. Each node is as for
1611 emit_mem_initializers. */
1614 finish_mem_initializers (tree mem_inits
)
1616 /* Reorder the MEM_INITS so that they are in the order they appeared
1617 in the source program. */
1618 mem_inits
= nreverse (mem_inits
);
1620 if (processing_template_decl
)
1624 for (mem
= mem_inits
; mem
; mem
= TREE_CHAIN (mem
))
1626 /* If the TREE_PURPOSE is a TYPE_PACK_EXPANSION, skip the
1627 check for bare parameter packs in the TREE_VALUE, because
1628 any parameter packs in the TREE_VALUE have already been
1629 bound as part of the TREE_PURPOSE. See
1630 make_pack_expansion for more information. */
1631 if (TREE_CODE (TREE_PURPOSE (mem
)) != TYPE_PACK_EXPANSION
1632 && check_for_bare_parameter_packs (TREE_VALUE (mem
)))
1633 TREE_VALUE (mem
) = error_mark_node
;
1636 add_stmt (build_min_nt_loc (UNKNOWN_LOCATION
,
1637 CTOR_INITIALIZER
, mem_inits
));
1640 emit_mem_initializers (mem_inits
);
1643 /* Obfuscate EXPR if it looks like an id-expression or member access so
1644 that the call to finish_decltype in do_auto_deduction will give the
1648 force_paren_expr (tree expr
)
1650 /* This is only needed for decltype(auto) in C++14. */
1651 if (cxx_dialect
< cxx14
)
1654 /* If we're in unevaluated context, we can't be deducing a
1655 return/initializer type, so we don't need to mess with this. */
1656 if (cp_unevaluated_operand
)
1659 if (!DECL_P (expr
) && TREE_CODE (expr
) != COMPONENT_REF
1660 && TREE_CODE (expr
) != SCOPE_REF
)
1663 if (TREE_CODE (expr
) == COMPONENT_REF
)
1664 REF_PARENTHESIZED_P (expr
) = true;
1665 else if (type_dependent_expression_p (expr
))
1666 expr
= build1 (PAREN_EXPR
, TREE_TYPE (expr
), expr
);
1669 cp_lvalue_kind kind
= lvalue_kind (expr
);
1670 if ((kind
& ~clk_class
) != clk_none
)
1672 tree type
= unlowered_expr_type (expr
);
1673 bool rval
= !!(kind
& clk_rvalueref
);
1674 type
= cp_build_reference_type (type
, rval
);
1675 /* This inhibits warnings in, eg, cxx_mark_addressable
1677 warning_sentinel
s (extra_warnings
);
1678 expr
= build_static_cast (type
, expr
, tf_error
);
1679 if (expr
!= error_mark_node
)
1680 REF_PARENTHESIZED_P (expr
) = true;
1687 /* Finish a parenthesized expression EXPR. */
1690 finish_parenthesized_expr (tree expr
)
1693 /* This inhibits warnings in c_common_truthvalue_conversion. */
1694 TREE_NO_WARNING (expr
) = 1;
1696 if (TREE_CODE (expr
) == OFFSET_REF
1697 || TREE_CODE (expr
) == SCOPE_REF
)
1698 /* [expr.unary.op]/3 The qualified id of a pointer-to-member must not be
1699 enclosed in parentheses. */
1700 PTRMEM_OK_P (expr
) = 0;
1702 if (TREE_CODE (expr
) == STRING_CST
)
1703 PAREN_STRING_LITERAL_P (expr
) = 1;
1705 expr
= force_paren_expr (expr
);
1710 /* Finish a reference to a non-static data member (DECL) that is not
1711 preceded by `.' or `->'. */
1714 finish_non_static_data_member (tree decl
, tree object
, tree qualifying_scope
)
1716 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
);
1720 tree scope
= qualifying_scope
;
1721 if (scope
== NULL_TREE
)
1722 scope
= context_for_name_lookup (decl
);
1723 object
= maybe_dummy_object (scope
, NULL
);
1726 object
= maybe_resolve_dummy (object
, true);
1727 if (object
== error_mark_node
)
1728 return error_mark_node
;
1730 /* DR 613/850: Can use non-static data members without an associated
1731 object in sizeof/decltype/alignof. */
1732 if (is_dummy_object (object
) && cp_unevaluated_operand
== 0
1733 && (!processing_template_decl
|| !current_class_ref
))
1735 if (current_function_decl
1736 && DECL_STATIC_FUNCTION_P (current_function_decl
))
1737 error ("invalid use of member %qD in static member function", decl
);
1739 error ("invalid use of non-static data member %qD", decl
);
1740 inform (DECL_SOURCE_LOCATION (decl
), "declared here");
1742 return error_mark_node
;
1745 if (current_class_ptr
)
1746 TREE_USED (current_class_ptr
) = 1;
1747 if (processing_template_decl
&& !qualifying_scope
)
1749 tree type
= TREE_TYPE (decl
);
1751 if (TREE_CODE (type
) == REFERENCE_TYPE
)
1752 /* Quals on the object don't matter. */;
1753 else if (PACK_EXPANSION_P (type
))
1754 /* Don't bother trying to represent this. */
1758 /* Set the cv qualifiers. */
1759 int quals
= cp_type_quals (TREE_TYPE (object
));
1761 if (DECL_MUTABLE_P (decl
))
1762 quals
&= ~TYPE_QUAL_CONST
;
1764 quals
|= cp_type_quals (TREE_TYPE (decl
));
1765 type
= cp_build_qualified_type (type
, quals
);
1768 return (convert_from_reference
1769 (build_min (COMPONENT_REF
, type
, object
, decl
, NULL_TREE
)));
1771 /* If PROCESSING_TEMPLATE_DECL is nonzero here, then
1772 QUALIFYING_SCOPE is also non-null. Wrap this in a SCOPE_REF
1774 else if (processing_template_decl
)
1775 return build_qualified_name (TREE_TYPE (decl
),
1778 /*template_p=*/false);
1781 tree access_type
= TREE_TYPE (object
);
1783 perform_or_defer_access_check (TYPE_BINFO (access_type
), decl
,
1784 decl
, tf_warning_or_error
);
1786 /* If the data member was named `C::M', convert `*this' to `C'
1788 if (qualifying_scope
)
1790 tree binfo
= NULL_TREE
;
1791 object
= build_scoped_ref (object
, qualifying_scope
,
1795 return build_class_member_access_expr (object
, decl
,
1796 /*access_path=*/NULL_TREE
,
1797 /*preserve_reference=*/false,
1798 tf_warning_or_error
);
1802 /* If we are currently parsing a template and we encountered a typedef
1803 TYPEDEF_DECL that is being accessed though CONTEXT, this function
1804 adds the typedef to a list tied to the current template.
1805 At template instantiation time, that list is walked and access check
1806 performed for each typedef.
1807 LOCATION is the location of the usage point of TYPEDEF_DECL. */
1810 add_typedef_to_current_template_for_access_check (tree typedef_decl
,
1812 location_t location
)
1814 tree template_info
= NULL
;
1815 tree cs
= current_scope ();
1817 if (!is_typedef_decl (typedef_decl
)
1819 || !CLASS_TYPE_P (context
)
1823 if (CLASS_TYPE_P (cs
) || TREE_CODE (cs
) == FUNCTION_DECL
)
1824 template_info
= get_template_info (cs
);
1827 && TI_TEMPLATE (template_info
)
1828 && !currently_open_class (context
))
1829 append_type_to_template_for_access_check (cs
, typedef_decl
,
1833 /* DECL was the declaration to which a qualified-id resolved. Issue
1834 an error message if it is not accessible. If OBJECT_TYPE is
1835 non-NULL, we have just seen `x->' or `x.' and OBJECT_TYPE is the
1836 type of `*x', or `x', respectively. If the DECL was named as
1837 `A::B' then NESTED_NAME_SPECIFIER is `A'. */
1840 check_accessibility_of_qualified_id (tree decl
,
1842 tree nested_name_specifier
)
1845 tree qualifying_type
= NULL_TREE
;
1847 /* If we are parsing a template declaration and if decl is a typedef,
1848 add it to a list tied to the template.
1849 At template instantiation time, that list will be walked and
1850 access check performed. */
1851 add_typedef_to_current_template_for_access_check (decl
,
1852 nested_name_specifier
1853 ? nested_name_specifier
1854 : DECL_CONTEXT (decl
),
1857 /* If we're not checking, return immediately. */
1858 if (deferred_access_no_check
)
1861 /* Determine the SCOPE of DECL. */
1862 scope
= context_for_name_lookup (decl
);
1863 /* If the SCOPE is not a type, then DECL is not a member. */
1864 if (!TYPE_P (scope
))
1866 /* Compute the scope through which DECL is being accessed. */
1868 /* OBJECT_TYPE might not be a class type; consider:
1870 class A { typedef int I; };
1874 In this case, we will have "A::I" as the DECL, but "I" as the
1876 && CLASS_TYPE_P (object_type
)
1877 && DERIVED_FROM_P (scope
, object_type
))
1878 /* If we are processing a `->' or `.' expression, use the type of the
1880 qualifying_type
= object_type
;
1881 else if (nested_name_specifier
)
1883 /* If the reference is to a non-static member of the
1884 current class, treat it as if it were referenced through
1887 if (DECL_NONSTATIC_MEMBER_P (decl
)
1888 && current_class_ptr
1889 && DERIVED_FROM_P (scope
, ct
= current_nonlambda_class_type ()))
1890 qualifying_type
= ct
;
1891 /* Otherwise, use the type indicated by the
1892 nested-name-specifier. */
1894 qualifying_type
= nested_name_specifier
;
1897 /* Otherwise, the name must be from the current class or one of
1899 qualifying_type
= currently_open_derived_class (scope
);
1902 /* It is possible for qualifying type to be a TEMPLATE_TYPE_PARM
1903 or similar in a default argument value. */
1904 && CLASS_TYPE_P (qualifying_type
)
1905 && !dependent_type_p (qualifying_type
))
1906 perform_or_defer_access_check (TYPE_BINFO (qualifying_type
), decl
,
1907 decl
, tf_warning_or_error
);
1910 /* EXPR is the result of a qualified-id. The QUALIFYING_CLASS was the
1911 class named to the left of the "::" operator. DONE is true if this
1912 expression is a complete postfix-expression; it is false if this
1913 expression is followed by '->', '[', '(', etc. ADDRESS_P is true
1914 iff this expression is the operand of '&'. TEMPLATE_P is true iff
1915 the qualified-id was of the form "A::template B". TEMPLATE_ARG_P
1916 is true iff this qualified name appears as a template argument. */
1919 finish_qualified_id_expr (tree qualifying_class
,
1924 bool template_arg_p
,
1925 tsubst_flags_t complain
)
1927 gcc_assert (TYPE_P (qualifying_class
));
1929 if (error_operand_p (expr
))
1930 return error_mark_node
;
1932 if ((DECL_P (expr
) || BASELINK_P (expr
))
1933 && !mark_used (expr
, complain
))
1934 return error_mark_node
;
1937 check_template_keyword (expr
);
1939 /* If EXPR occurs as the operand of '&', use special handling that
1940 permits a pointer-to-member. */
1941 if (address_p
&& done
)
1943 if (TREE_CODE (expr
) == SCOPE_REF
)
1944 expr
= TREE_OPERAND (expr
, 1);
1945 expr
= build_offset_ref (qualifying_class
, expr
,
1946 /*address_p=*/true, complain
);
1950 /* No need to check access within an enum. */
1951 if (TREE_CODE (qualifying_class
) == ENUMERAL_TYPE
)
1954 /* Within the scope of a class, turn references to non-static
1955 members into expression of the form "this->...". */
1957 /* But, within a template argument, we do not want make the
1958 transformation, as there is no "this" pointer. */
1960 else if (TREE_CODE (expr
) == FIELD_DECL
)
1962 push_deferring_access_checks (dk_no_check
);
1963 expr
= finish_non_static_data_member (expr
, NULL_TREE
,
1965 pop_deferring_access_checks ();
1967 else if (BASELINK_P (expr
) && !processing_template_decl
)
1969 /* See if any of the functions are non-static members. */
1970 /* If so, the expression may be relative to 'this'. */
1971 if (!shared_member_p (expr
)
1972 && current_class_ptr
1973 && DERIVED_FROM_P (qualifying_class
,
1974 current_nonlambda_class_type ()))
1975 expr
= (build_class_member_access_expr
1976 (maybe_dummy_object (qualifying_class
, NULL
),
1978 BASELINK_ACCESS_BINFO (expr
),
1979 /*preserve_reference=*/false,
1982 /* The expression is a qualified name whose address is not
1984 expr
= build_offset_ref (qualifying_class
, expr
, /*address_p=*/false,
1987 else if (BASELINK_P (expr
))
1991 /* In a template, return a SCOPE_REF for most qualified-ids
1992 so that we can check access at instantiation time. But if
1993 we're looking at a member of the current instantiation, we
1994 know we have access and building up the SCOPE_REF confuses
1995 non-type template argument handling. */
1996 if (processing_template_decl
1997 && !currently_open_class (qualifying_class
))
1998 expr
= build_qualified_name (TREE_TYPE (expr
),
1999 qualifying_class
, expr
,
2002 expr
= convert_from_reference (expr
);
2008 /* Begin a statement-expression. The value returned must be passed to
2009 finish_stmt_expr. */
2012 begin_stmt_expr (void)
2014 return push_stmt_list ();
2017 /* Process the final expression of a statement expression. EXPR can be
2018 NULL, if the final expression is empty. Return a STATEMENT_LIST
2019 containing all the statements in the statement-expression, or
2020 ERROR_MARK_NODE if there was an error. */
2023 finish_stmt_expr_expr (tree expr
, tree stmt_expr
)
2025 if (error_operand_p (expr
))
2027 /* The type of the statement-expression is the type of the last
2029 TREE_TYPE (stmt_expr
) = error_mark_node
;
2030 return error_mark_node
;
2033 /* If the last statement does not have "void" type, then the value
2034 of the last statement is the value of the entire expression. */
2037 tree type
= TREE_TYPE (expr
);
2039 if (processing_template_decl
)
2041 expr
= build_stmt (input_location
, EXPR_STMT
, expr
);
2042 expr
= add_stmt (expr
);
2043 /* Mark the last statement so that we can recognize it as such at
2044 template-instantiation time. */
2045 EXPR_STMT_STMT_EXPR_RESULT (expr
) = 1;
2047 else if (VOID_TYPE_P (type
))
2049 /* Just treat this like an ordinary statement. */
2050 expr
= finish_expr_stmt (expr
);
2054 /* It actually has a value we need to deal with. First, force it
2055 to be an rvalue so that we won't need to build up a copy
2056 constructor call later when we try to assign it to something. */
2057 expr
= force_rvalue (expr
, tf_warning_or_error
);
2058 if (error_operand_p (expr
))
2059 return error_mark_node
;
2061 /* Update for array-to-pointer decay. */
2062 type
= TREE_TYPE (expr
);
2064 /* Wrap it in a CLEANUP_POINT_EXPR and add it to the list like a
2065 normal statement, but don't convert to void or actually add
2067 if (TREE_CODE (expr
) != CLEANUP_POINT_EXPR
)
2068 expr
= maybe_cleanup_point_expr (expr
);
2072 /* The type of the statement-expression is the type of the last
2074 TREE_TYPE (stmt_expr
) = type
;
2080 /* Finish a statement-expression. EXPR should be the value returned
2081 by the previous begin_stmt_expr. Returns an expression
2082 representing the statement-expression. */
2085 finish_stmt_expr (tree stmt_expr
, bool has_no_scope
)
2090 if (error_operand_p (stmt_expr
))
2092 pop_stmt_list (stmt_expr
);
2093 return error_mark_node
;
2096 gcc_assert (TREE_CODE (stmt_expr
) == STATEMENT_LIST
);
2098 type
= TREE_TYPE (stmt_expr
);
2099 result
= pop_stmt_list (stmt_expr
);
2100 TREE_TYPE (result
) = type
;
2102 if (processing_template_decl
)
2104 result
= build_min (STMT_EXPR
, type
, result
);
2105 TREE_SIDE_EFFECTS (result
) = 1;
2106 STMT_EXPR_NO_SCOPE (result
) = has_no_scope
;
2108 else if (CLASS_TYPE_P (type
))
2110 /* Wrap the statement-expression in a TARGET_EXPR so that the
2111 temporary object created by the final expression is destroyed at
2112 the end of the full-expression containing the
2113 statement-expression. */
2114 result
= force_target_expr (type
, result
, tf_warning_or_error
);
2120 /* Returns the expression which provides the value of STMT_EXPR. */
2123 stmt_expr_value_expr (tree stmt_expr
)
2125 tree t
= STMT_EXPR_STMT (stmt_expr
);
2127 if (TREE_CODE (t
) == BIND_EXPR
)
2128 t
= BIND_EXPR_BODY (t
);
2130 if (TREE_CODE (t
) == STATEMENT_LIST
&& STATEMENT_LIST_TAIL (t
))
2131 t
= STATEMENT_LIST_TAIL (t
)->stmt
;
2133 if (TREE_CODE (t
) == EXPR_STMT
)
2134 t
= EXPR_STMT_EXPR (t
);
2139 /* Return TRUE iff EXPR_STMT is an empty list of
2140 expression statements. */
2143 empty_expr_stmt_p (tree expr_stmt
)
2145 tree body
= NULL_TREE
;
2147 if (expr_stmt
== void_node
)
2152 if (TREE_CODE (expr_stmt
) == EXPR_STMT
)
2153 body
= EXPR_STMT_EXPR (expr_stmt
);
2154 else if (TREE_CODE (expr_stmt
) == STATEMENT_LIST
)
2160 if (TREE_CODE (body
) == STATEMENT_LIST
)
2161 return tsi_end_p (tsi_start (body
));
2163 return empty_expr_stmt_p (body
);
2168 /* Perform Koenig lookup. FN is the postfix-expression representing
2169 the function (or functions) to call; ARGS are the arguments to the
2170 call. Returns the functions to be considered by overload resolution. */
2173 perform_koenig_lookup (tree fn
, vec
<tree
, va_gc
> *args
,
2174 tsubst_flags_t complain
)
2176 tree identifier
= NULL_TREE
;
2177 tree functions
= NULL_TREE
;
2178 tree tmpl_args
= NULL_TREE
;
2179 bool template_id
= false;
2181 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
2183 /* Use a separate flag to handle null args. */
2185 tmpl_args
= TREE_OPERAND (fn
, 1);
2186 fn
= TREE_OPERAND (fn
, 0);
2189 /* Find the name of the overloaded function. */
2190 if (identifier_p (fn
))
2192 else if (is_overloaded_fn (fn
))
2195 identifier
= DECL_NAME (get_first_fn (functions
));
2197 else if (DECL_P (fn
))
2200 identifier
= DECL_NAME (fn
);
2203 /* A call to a namespace-scope function using an unqualified name.
2205 Do Koenig lookup -- unless any of the arguments are
2207 if (!any_type_dependent_arguments_p (args
)
2208 && !any_dependent_template_arguments_p (tmpl_args
))
2210 fn
= lookup_arg_dependent (identifier
, functions
, args
);
2213 /* The unqualified name could not be resolved. */
2215 fn
= unqualified_fn_lookup_error (identifier
);
2221 if (fn
&& template_id
)
2222 fn
= build2 (TEMPLATE_ID_EXPR
, unknown_type_node
, fn
, tmpl_args
);
2227 /* Generate an expression for `FN (ARGS)'. This may change the
2230 If DISALLOW_VIRTUAL is true, the call to FN will be not generated
2231 as a virtual call, even if FN is virtual. (This flag is set when
2232 encountering an expression where the function name is explicitly
2233 qualified. For example a call to `X::f' never generates a virtual
2236 Returns code for the call. */
2239 finish_call_expr (tree fn
, vec
<tree
, va_gc
> **args
, bool disallow_virtual
,
2240 bool koenig_p
, tsubst_flags_t complain
)
2244 vec
<tree
, va_gc
> *orig_args
= NULL
;
2246 if (fn
== error_mark_node
)
2247 return error_mark_node
;
2249 gcc_assert (!TYPE_P (fn
));
2253 if (processing_template_decl
)
2255 /* If the call expression is dependent, build a CALL_EXPR node
2256 with no type; type_dependent_expression_p recognizes
2257 expressions with no type as being dependent. */
2258 if (type_dependent_expression_p (fn
)
2259 || any_type_dependent_arguments_p (*args
)
2260 /* For a non-static member function that doesn't have an
2261 explicit object argument, we need to specifically
2262 test the type dependency of the "this" pointer because it
2263 is not included in *ARGS even though it is considered to
2264 be part of the list of arguments. Note that this is
2265 related to CWG issues 515 and 1005. */
2266 || (TREE_CODE (fn
) != COMPONENT_REF
2267 && non_static_member_function_p (fn
)
2268 && current_class_ref
2269 && type_dependent_expression_p (current_class_ref
)))
2271 result
= build_nt_call_vec (fn
, *args
);
2272 SET_EXPR_LOCATION (result
, EXPR_LOC_OR_LOC (fn
, input_location
));
2273 KOENIG_LOOKUP_P (result
) = koenig_p
;
2278 tree fndecl
= OVL_CURRENT (fn
);
2279 if (TREE_CODE (fndecl
) != FUNCTION_DECL
2280 || !TREE_THIS_VOLATILE (fndecl
))
2286 current_function_returns_abnormally
= 1;
2290 orig_args
= make_tree_vector_copy (*args
);
2291 if (!BASELINK_P (fn
)
2292 && TREE_CODE (fn
) != PSEUDO_DTOR_EXPR
2293 && TREE_TYPE (fn
) != unknown_type_node
)
2294 fn
= build_non_dependent_expr (fn
);
2295 make_args_non_dependent (*args
);
2298 if (TREE_CODE (fn
) == COMPONENT_REF
)
2300 tree member
= TREE_OPERAND (fn
, 1);
2301 if (BASELINK_P (member
))
2303 tree object
= TREE_OPERAND (fn
, 0);
2304 return build_new_method_call (object
, member
,
2307 ? LOOKUP_NORMAL
| LOOKUP_NONVIRTUAL
2314 /* Per 13.3.1.1, '(&f)(...)' is the same as '(f)(...)'. */
2315 if (TREE_CODE (fn
) == ADDR_EXPR
2316 && TREE_CODE (TREE_OPERAND (fn
, 0)) == OVERLOAD
)
2317 fn
= TREE_OPERAND (fn
, 0);
2319 if (is_overloaded_fn (fn
))
2320 fn
= baselink_for_fns (fn
);
2323 if (BASELINK_P (fn
))
2327 /* A call to a member function. From [over.call.func]:
2329 If the keyword this is in scope and refers to the class of
2330 that member function, or a derived class thereof, then the
2331 function call is transformed into a qualified function call
2332 using (*this) as the postfix-expression to the left of the
2333 . operator.... [Otherwise] a contrived object of type T
2334 becomes the implied object argument.
2338 struct A { void f(); };
2339 struct B : public A {};
2340 struct C : public A { void g() { B::f(); }};
2342 "the class of that member function" refers to `A'. But 11.2
2343 [class.access.base] says that we need to convert 'this' to B* as
2344 part of the access, so we pass 'B' to maybe_dummy_object. */
2346 object
= maybe_dummy_object (BINFO_TYPE (BASELINK_ACCESS_BINFO (fn
)),
2349 if (processing_template_decl
)
2351 if (type_dependent_expression_p (object
))
2353 tree ret
= build_nt_call_vec (orig_fn
, orig_args
);
2354 release_tree_vector (orig_args
);
2357 object
= build_non_dependent_expr (object
);
2360 result
= build_new_method_call (object
, fn
, args
, NULL_TREE
,
2362 ? LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
2367 else if (is_overloaded_fn (fn
))
2369 /* If the function is an overloaded builtin, resolve it. */
2370 if (TREE_CODE (fn
) == FUNCTION_DECL
2371 && (DECL_BUILT_IN_CLASS (fn
) == BUILT_IN_NORMAL
2372 || DECL_BUILT_IN_CLASS (fn
) == BUILT_IN_MD
))
2373 result
= resolve_overloaded_builtin (input_location
, fn
, *args
);
2377 if (warn_sizeof_pointer_memaccess
2378 && !vec_safe_is_empty (*args
)
2379 && !processing_template_decl
)
2381 location_t sizeof_arg_loc
[3];
2384 for (i
= 0; i
< 3; i
++)
2388 sizeof_arg_loc
[i
] = UNKNOWN_LOCATION
;
2389 sizeof_arg
[i
] = NULL_TREE
;
2390 if (i
>= (*args
)->length ())
2393 if (TREE_CODE (t
) != SIZEOF_EXPR
)
2395 if (SIZEOF_EXPR_TYPE_P (t
))
2396 sizeof_arg
[i
] = TREE_TYPE (TREE_OPERAND (t
, 0));
2398 sizeof_arg
[i
] = TREE_OPERAND (t
, 0);
2399 sizeof_arg_loc
[i
] = EXPR_LOCATION (t
);
2401 sizeof_pointer_memaccess_warning
2402 (sizeof_arg_loc
, fn
, *args
,
2403 sizeof_arg
, same_type_ignoring_top_level_qualifiers_p
);
2406 /* A call to a namespace-scope function. */
2407 result
= build_new_function_call (fn
, args
, koenig_p
, complain
);
2410 else if (TREE_CODE (fn
) == PSEUDO_DTOR_EXPR
)
2412 if (!vec_safe_is_empty (*args
))
2413 error ("arguments to destructor are not allowed");
2414 /* Mark the pseudo-destructor call as having side-effects so
2415 that we do not issue warnings about its use. */
2416 result
= build1 (NOP_EXPR
,
2418 TREE_OPERAND (fn
, 0));
2419 TREE_SIDE_EFFECTS (result
) = 1;
2421 else if (CLASS_TYPE_P (TREE_TYPE (fn
)))
2422 /* If the "function" is really an object of class type, it might
2423 have an overloaded `operator ()'. */
2424 result
= build_op_call (fn
, args
, complain
);
2427 /* A call where the function is unknown. */
2428 result
= cp_build_function_call_vec (fn
, args
, complain
);
2430 if (processing_template_decl
&& result
!= error_mark_node
)
2432 if (INDIRECT_REF_P (result
))
2433 result
= TREE_OPERAND (result
, 0);
2434 result
= build_call_vec (TREE_TYPE (result
), orig_fn
, orig_args
);
2435 SET_EXPR_LOCATION (result
, input_location
);
2436 KOENIG_LOOKUP_P (result
) = koenig_p
;
2437 release_tree_vector (orig_args
);
2438 result
= convert_from_reference (result
);
2443 /* Free garbage OVERLOADs from arg-dependent lookup. */
2444 tree next
= NULL_TREE
;
2446 fn
&& TREE_CODE (fn
) == OVERLOAD
&& OVL_ARG_DEPENDENT (fn
);
2449 if (processing_template_decl
)
2450 /* In a template, we'll re-use them at instantiation time. */
2451 OVL_ARG_DEPENDENT (fn
) = false;
2454 next
= OVL_CHAIN (fn
);
2463 /* Finish a call to a postfix increment or decrement or EXPR. (Which
2464 is indicated by CODE, which should be POSTINCREMENT_EXPR or
2465 POSTDECREMENT_EXPR.) */
2468 finish_increment_expr (tree expr
, enum tree_code code
)
2470 return build_x_unary_op (input_location
, code
, expr
, tf_warning_or_error
);
2473 /* Finish a use of `this'. Returns an expression for `this'. */
2476 finish_this_expr (void)
2478 tree result
= NULL_TREE
;
2480 if (current_class_ptr
)
2482 tree type
= TREE_TYPE (current_class_ref
);
2484 /* In a lambda expression, 'this' refers to the captured 'this'. */
2485 if (LAMBDA_TYPE_P (type
))
2486 result
= lambda_expr_this_capture (CLASSTYPE_LAMBDA_EXPR (type
), true);
2488 result
= current_class_ptr
;
2492 /* The keyword 'this' is a prvalue expression. */
2493 return rvalue (result
);
2495 tree fn
= current_nonlambda_function ();
2496 if (fn
&& DECL_STATIC_FUNCTION_P (fn
))
2497 error ("%<this%> is unavailable for static member functions");
2499 error ("invalid use of %<this%> in non-member function");
2501 error ("invalid use of %<this%> at top level");
2502 return error_mark_node
;
2505 /* Finish a pseudo-destructor expression. If SCOPE is NULL, the
2506 expression was of the form `OBJECT.~DESTRUCTOR' where DESTRUCTOR is
2507 the TYPE for the type given. If SCOPE is non-NULL, the expression
2508 was of the form `OBJECT.SCOPE::~DESTRUCTOR'. */
2511 finish_pseudo_destructor_expr (tree object
, tree scope
, tree destructor
,
2514 if (object
== error_mark_node
|| destructor
== error_mark_node
)
2515 return error_mark_node
;
2517 gcc_assert (TYPE_P (destructor
));
2519 if (!processing_template_decl
)
2521 if (scope
== error_mark_node
)
2523 error_at (loc
, "invalid qualifying scope in pseudo-destructor name");
2524 return error_mark_node
;
2526 if (is_auto (destructor
))
2527 destructor
= TREE_TYPE (object
);
2528 if (scope
&& TYPE_P (scope
) && !check_dtor_name (scope
, destructor
))
2531 "qualified type %qT does not match destructor name ~%qT",
2533 return error_mark_node
;
2537 /* [expr.pseudo] says both:
2539 The type designated by the pseudo-destructor-name shall be
2540 the same as the object type.
2544 The cv-unqualified versions of the object type and of the
2545 type designated by the pseudo-destructor-name shall be the
2548 We implement the more generous second sentence, since that is
2549 what most other compilers do. */
2550 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (object
),
2553 error_at (loc
, "%qE is not of type %qT", object
, destructor
);
2554 return error_mark_node
;
2558 return build3_loc (loc
, PSEUDO_DTOR_EXPR
, void_type_node
, object
,
2562 /* Finish an expression of the form CODE EXPR. */
2565 finish_unary_op_expr (location_t loc
, enum tree_code code
, tree expr
,
2566 tsubst_flags_t complain
)
2568 tree result
= build_x_unary_op (loc
, code
, expr
, complain
);
2569 if ((complain
& tf_warning
)
2570 && TREE_OVERFLOW_P (result
) && !TREE_OVERFLOW_P (expr
))
2571 overflow_warning (input_location
, result
);
2576 /* Finish a compound-literal expression. TYPE is the type to which
2577 the CONSTRUCTOR in COMPOUND_LITERAL is being cast. */
2580 finish_compound_literal (tree type
, tree compound_literal
,
2581 tsubst_flags_t complain
)
2583 if (type
== error_mark_node
)
2584 return error_mark_node
;
2586 if (TREE_CODE (type
) == REFERENCE_TYPE
)
2589 = finish_compound_literal (TREE_TYPE (type
), compound_literal
,
2591 return cp_build_c_cast (type
, compound_literal
, complain
);
2594 if (!TYPE_OBJ_P (type
))
2596 if (complain
& tf_error
)
2597 error ("compound literal of non-object type %qT", type
);
2598 return error_mark_node
;
2601 if (processing_template_decl
)
2603 TREE_TYPE (compound_literal
) = type
;
2604 /* Mark the expression as a compound literal. */
2605 TREE_HAS_CONSTRUCTOR (compound_literal
) = 1;
2606 return compound_literal
;
2609 type
= complete_type (type
);
2611 if (TYPE_NON_AGGREGATE_CLASS (type
))
2613 /* Trying to deal with a CONSTRUCTOR instead of a TREE_LIST
2614 everywhere that deals with function arguments would be a pain, so
2615 just wrap it in a TREE_LIST. The parser set a flag so we know
2616 that it came from T{} rather than T({}). */
2617 CONSTRUCTOR_IS_DIRECT_INIT (compound_literal
) = 1;
2618 compound_literal
= build_tree_list (NULL_TREE
, compound_literal
);
2619 return build_functional_cast (type
, compound_literal
, complain
);
2622 if (TREE_CODE (type
) == ARRAY_TYPE
2623 && check_array_initializer (NULL_TREE
, type
, compound_literal
))
2624 return error_mark_node
;
2625 compound_literal
= reshape_init (type
, compound_literal
, complain
);
2626 if (SCALAR_TYPE_P (type
)
2627 && !BRACE_ENCLOSED_INITIALIZER_P (compound_literal
)
2628 && !check_narrowing (type
, compound_literal
, complain
))
2629 return error_mark_node
;
2630 if (TREE_CODE (type
) == ARRAY_TYPE
2631 && TYPE_DOMAIN (type
) == NULL_TREE
)
2633 cp_complete_array_type_or_error (&type
, compound_literal
,
2635 if (type
== error_mark_node
)
2636 return error_mark_node
;
2638 compound_literal
= digest_init (type
, compound_literal
, complain
);
2639 if (TREE_CODE (compound_literal
) == CONSTRUCTOR
)
2640 TREE_HAS_CONSTRUCTOR (compound_literal
) = true;
2641 /* Put static/constant array temporaries in static variables, but always
2642 represent class temporaries with TARGET_EXPR so we elide copies. */
2643 if ((!at_function_scope_p () || CP_TYPE_CONST_P (type
))
2644 && TREE_CODE (type
) == ARRAY_TYPE
2645 && !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
2646 && initializer_constant_valid_p (compound_literal
, type
))
2648 tree decl
= create_temporary_var (type
);
2649 DECL_INITIAL (decl
) = compound_literal
;
2650 TREE_STATIC (decl
) = 1;
2651 if (literal_type_p (type
) && CP_TYPE_CONST_NON_VOLATILE_P (type
))
2653 /* 5.19 says that a constant expression can include an
2654 lvalue-rvalue conversion applied to "a glvalue of literal type
2655 that refers to a non-volatile temporary object initialized
2656 with a constant expression". Rather than try to communicate
2657 that this VAR_DECL is a temporary, just mark it constexpr. */
2658 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
2659 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = true;
2660 TREE_CONSTANT (decl
) = true;
2662 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
2663 decl
= pushdecl_top_level (decl
);
2664 DECL_NAME (decl
) = make_anon_name ();
2665 SET_DECL_ASSEMBLER_NAME (decl
, DECL_NAME (decl
));
2666 /* Make sure the destructor is callable. */
2667 tree clean
= cxx_maybe_build_cleanup (decl
, complain
);
2668 if (clean
== error_mark_node
)
2669 return error_mark_node
;
2673 return get_target_expr_sfinae (compound_literal
, complain
);
2676 /* Return the declaration for the function-name variable indicated by
2680 finish_fname (tree id
)
2684 decl
= fname_decl (input_location
, C_RID_CODE (id
), id
);
2685 if (processing_template_decl
&& current_function_decl
2686 && decl
!= error_mark_node
)
2687 decl
= DECL_NAME (decl
);
2691 /* Finish a translation unit. */
2694 finish_translation_unit (void)
2696 /* In case there were missing closebraces,
2697 get us back to the global binding level. */
2699 while (current_namespace
!= global_namespace
)
2702 /* Do file scope __FUNCTION__ et al. */
2703 finish_fname_decls ();
2706 /* Finish a template type parameter, specified as AGGR IDENTIFIER.
2707 Returns the parameter. */
2710 finish_template_type_parm (tree aggr
, tree identifier
)
2712 if (aggr
!= class_type_node
)
2714 permerror (input_location
, "template type parameters must use the keyword %<class%> or %<typename%>");
2715 aggr
= class_type_node
;
2718 return build_tree_list (aggr
, identifier
);
2721 /* Finish a template template parameter, specified as AGGR IDENTIFIER.
2722 Returns the parameter. */
2725 finish_template_template_parm (tree aggr
, tree identifier
)
2727 tree decl
= build_decl (input_location
,
2728 TYPE_DECL
, identifier
, NULL_TREE
);
2729 tree tmpl
= build_lang_decl (TEMPLATE_DECL
, identifier
, NULL_TREE
);
2730 DECL_TEMPLATE_PARMS (tmpl
) = current_template_parms
;
2731 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
2732 DECL_ARTIFICIAL (decl
) = 1;
2733 end_template_decl ();
2735 gcc_assert (DECL_TEMPLATE_PARMS (tmpl
));
2737 check_default_tmpl_args (decl
, DECL_TEMPLATE_PARMS (tmpl
),
2738 /*is_primary=*/true, /*is_partial=*/false,
2741 return finish_template_type_parm (aggr
, tmpl
);
2744 /* ARGUMENT is the default-argument value for a template template
2745 parameter. If ARGUMENT is invalid, issue error messages and return
2746 the ERROR_MARK_NODE. Otherwise, ARGUMENT itself is returned. */
2749 check_template_template_default_arg (tree argument
)
2751 if (TREE_CODE (argument
) != TEMPLATE_DECL
2752 && TREE_CODE (argument
) != TEMPLATE_TEMPLATE_PARM
2753 && TREE_CODE (argument
) != UNBOUND_CLASS_TEMPLATE
)
2755 if (TREE_CODE (argument
) == TYPE_DECL
)
2756 error ("invalid use of type %qT as a default value for a template "
2757 "template-parameter", TREE_TYPE (argument
));
2759 error ("invalid default argument for a template template parameter");
2760 return error_mark_node
;
2766 /* Begin a class definition, as indicated by T. */
2769 begin_class_definition (tree t
)
2771 if (error_operand_p (t
) || error_operand_p (TYPE_MAIN_DECL (t
)))
2772 return error_mark_node
;
2774 if (processing_template_parmlist
)
2776 error ("definition of %q#T inside template parameter list", t
);
2777 return error_mark_node
;
2780 /* According to the C++ ABI, decimal classes defined in ISO/IEC TR 24733
2781 are passed the same as decimal scalar types. */
2782 if (TREE_CODE (t
) == RECORD_TYPE
2783 && !processing_template_decl
)
2785 tree ns
= TYPE_CONTEXT (t
);
2786 if (ns
&& TREE_CODE (ns
) == NAMESPACE_DECL
2787 && DECL_CONTEXT (ns
) == std_node
2789 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (ns
)), "decimal"))
2791 const char *n
= TYPE_NAME_STRING (t
);
2792 if ((strcmp (n
, "decimal32") == 0)
2793 || (strcmp (n
, "decimal64") == 0)
2794 || (strcmp (n
, "decimal128") == 0))
2795 TYPE_TRANSPARENT_AGGR (t
) = 1;
2799 /* A non-implicit typename comes from code like:
2801 template <typename T> struct A {
2802 template <typename U> struct A<T>::B ...
2804 This is erroneous. */
2805 else if (TREE_CODE (t
) == TYPENAME_TYPE
)
2807 error ("invalid definition of qualified type %qT", t
);
2808 t
= error_mark_node
;
2811 if (t
== error_mark_node
|| ! MAYBE_CLASS_TYPE_P (t
))
2813 t
= make_class_type (RECORD_TYPE
);
2814 pushtag (make_anon_name (), t
, /*tag_scope=*/ts_current
);
2817 if (TYPE_BEING_DEFINED (t
))
2819 t
= make_class_type (TREE_CODE (t
));
2820 pushtag (TYPE_IDENTIFIER (t
), t
, /*tag_scope=*/ts_current
);
2822 maybe_process_partial_specialization (t
);
2824 TYPE_BEING_DEFINED (t
) = 1;
2825 class_binding_level
->defining_class_p
= 1;
2827 if (flag_pack_struct
)
2830 TYPE_PACKED (t
) = 1;
2831 /* Even though the type is being defined for the first time
2832 here, there might have been a forward declaration, so there
2833 might be cv-qualified variants of T. */
2834 for (v
= TYPE_NEXT_VARIANT (t
); v
; v
= TYPE_NEXT_VARIANT (v
))
2835 TYPE_PACKED (v
) = 1;
2837 /* Reset the interface data, at the earliest possible
2838 moment, as it might have been set via a class foo;
2840 if (! TYPE_ANONYMOUS_P (t
))
2842 struct c_fileinfo
*finfo
= \
2843 get_fileinfo (LOCATION_FILE (input_location
));
2844 CLASSTYPE_INTERFACE_ONLY (t
) = finfo
->interface_only
;
2845 SET_CLASSTYPE_INTERFACE_UNKNOWN_X
2846 (t
, finfo
->interface_unknown
);
2848 reset_specialization();
2850 /* Make a declaration for this class in its own scope. */
2851 build_self_reference ();
2856 /* Finish the member declaration given by DECL. */
2859 finish_member_declaration (tree decl
)
2861 if (decl
== error_mark_node
|| decl
== NULL_TREE
)
2864 if (decl
== void_type_node
)
2865 /* The COMPONENT was a friend, not a member, and so there's
2866 nothing for us to do. */
2869 /* We should see only one DECL at a time. */
2870 gcc_assert (DECL_CHAIN (decl
) == NULL_TREE
);
2872 /* Set up access control for DECL. */
2874 = (current_access_specifier
== access_private_node
);
2875 TREE_PROTECTED (decl
)
2876 = (current_access_specifier
== access_protected_node
);
2877 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
2879 TREE_PRIVATE (DECL_TEMPLATE_RESULT (decl
)) = TREE_PRIVATE (decl
);
2880 TREE_PROTECTED (DECL_TEMPLATE_RESULT (decl
)) = TREE_PROTECTED (decl
);
2883 /* Mark the DECL as a member of the current class, unless it's
2884 a member of an enumeration. */
2885 if (TREE_CODE (decl
) != CONST_DECL
)
2886 DECL_CONTEXT (decl
) = current_class_type
;
2888 /* Check for bare parameter packs in the member variable declaration. */
2889 if (TREE_CODE (decl
) == FIELD_DECL
)
2891 if (check_for_bare_parameter_packs (TREE_TYPE (decl
)))
2892 TREE_TYPE (decl
) = error_mark_node
;
2893 if (check_for_bare_parameter_packs (DECL_ATTRIBUTES (decl
)))
2894 DECL_ATTRIBUTES (decl
) = NULL_TREE
;
2899 A C language linkage is ignored for the names of class members
2900 and the member function type of class member functions. */
2901 if (DECL_LANG_SPECIFIC (decl
) && DECL_LANGUAGE (decl
) == lang_c
)
2902 SET_DECL_LANGUAGE (decl
, lang_cplusplus
);
2904 /* Put functions on the TYPE_METHODS list and everything else on the
2905 TYPE_FIELDS list. Note that these are built up in reverse order.
2906 We reverse them (to obtain declaration order) in finish_struct. */
2907 if (DECL_DECLARES_FUNCTION_P (decl
))
2909 /* We also need to add this function to the
2910 CLASSTYPE_METHOD_VEC. */
2911 if (add_method (current_class_type
, decl
, NULL_TREE
))
2913 DECL_CHAIN (decl
) = TYPE_METHODS (current_class_type
);
2914 TYPE_METHODS (current_class_type
) = decl
;
2916 maybe_add_class_template_decl_list (current_class_type
, decl
,
2920 /* Enter the DECL into the scope of the class, if the class
2921 isn't a closure (whose fields are supposed to be unnamed). */
2922 else if (CLASSTYPE_LAMBDA_EXPR (current_class_type
)
2923 || pushdecl_class_level (decl
))
2925 if (TREE_CODE (decl
) == USING_DECL
)
2927 /* For now, ignore class-scope USING_DECLS, so that
2928 debugging backends do not see them. */
2929 DECL_IGNORED_P (decl
) = 1;
2932 /* All TYPE_DECLs go at the end of TYPE_FIELDS. Ordinary fields
2933 go at the beginning. The reason is that lookup_field_1
2934 searches the list in order, and we want a field name to
2935 override a type name so that the "struct stat hack" will
2936 work. In particular:
2938 struct S { enum E { }; int E } s;
2941 is valid. In addition, the FIELD_DECLs must be maintained in
2942 declaration order so that class layout works as expected.
2943 However, we don't need that order until class layout, so we
2944 save a little time by putting FIELD_DECLs on in reverse order
2945 here, and then reversing them in finish_struct_1. (We could
2946 also keep a pointer to the correct insertion points in the
2949 if (TREE_CODE (decl
) == TYPE_DECL
)
2950 TYPE_FIELDS (current_class_type
)
2951 = chainon (TYPE_FIELDS (current_class_type
), decl
);
2954 DECL_CHAIN (decl
) = TYPE_FIELDS (current_class_type
);
2955 TYPE_FIELDS (current_class_type
) = decl
;
2958 maybe_add_class_template_decl_list (current_class_type
, decl
,
2963 note_decl_for_pch (decl
);
2966 /* DECL has been declared while we are building a PCH file. Perform
2967 actions that we might normally undertake lazily, but which can be
2968 performed now so that they do not have to be performed in
2969 translation units which include the PCH file. */
2972 note_decl_for_pch (tree decl
)
2974 gcc_assert (pch_file
);
2976 /* There's a good chance that we'll have to mangle names at some
2977 point, even if only for emission in debugging information. */
2978 if (VAR_OR_FUNCTION_DECL_P (decl
)
2979 && !processing_template_decl
)
2983 /* Finish processing a complete template declaration. The PARMS are
2984 the template parameters. */
2987 finish_template_decl (tree parms
)
2990 end_template_decl ();
2992 end_specialization ();
2995 /* Finish processing a template-id (which names a type) of the form
2996 NAME < ARGS >. Return the TYPE_DECL for the type named by the
2997 template-id. If ENTERING_SCOPE is nonzero we are about to enter
2998 the scope of template-id indicated. */
3001 finish_template_type (tree name
, tree args
, int entering_scope
)
3005 type
= lookup_template_class (name
, args
,
3006 NULL_TREE
, NULL_TREE
, entering_scope
,
3007 tf_warning_or_error
| tf_user
);
3008 if (type
== error_mark_node
)
3010 else if (CLASS_TYPE_P (type
) && !alias_type_or_template_p (type
))
3011 return TYPE_STUB_DECL (type
);
3013 return TYPE_NAME (type
);
3016 /* Finish processing a BASE_CLASS with the indicated ACCESS_SPECIFIER.
3017 Return a TREE_LIST containing the ACCESS_SPECIFIER and the
3018 BASE_CLASS, or NULL_TREE if an error occurred. The
3019 ACCESS_SPECIFIER is one of
3020 access_{default,public,protected_private}_node. For a virtual base
3021 we set TREE_TYPE. */
3024 finish_base_specifier (tree base
, tree access
, bool virtual_p
)
3028 if (base
== error_mark_node
)
3030 error ("invalid base-class specification");
3033 else if (! MAYBE_CLASS_TYPE_P (base
))
3035 error ("%qT is not a class type", base
);
3040 if (cp_type_quals (base
) != 0)
3042 /* DR 484: Can a base-specifier name a cv-qualified
3044 base
= TYPE_MAIN_VARIANT (base
);
3046 result
= build_tree_list (access
, base
);
3048 TREE_TYPE (result
) = integer_type_node
;
3054 /* If FNS is a member function, a set of member functions, or a
3055 template-id referring to one or more member functions, return a
3056 BASELINK for FNS, incorporating the current access context.
3057 Otherwise, return FNS unchanged. */
3060 baselink_for_fns (tree fns
)
3065 if (BASELINK_P (fns
)
3066 || error_operand_p (fns
))
3069 scope
= ovl_scope (fns
);
3070 if (!CLASS_TYPE_P (scope
))
3073 cl
= currently_open_derived_class (scope
);
3076 cl
= TYPE_BINFO (cl
);
3077 return build_baselink (cl
, cl
, fns
, /*optype=*/NULL_TREE
);
3080 /* Returns true iff DECL is a variable from a function outside
3084 outer_var_p (tree decl
)
3086 return ((VAR_P (decl
) || TREE_CODE (decl
) == PARM_DECL
)
3087 && DECL_FUNCTION_SCOPE_P (decl
)
3088 && (DECL_CONTEXT (decl
) != current_function_decl
3089 || parsing_nsdmi ()));
3092 /* As above, but also checks that DECL is automatic. */
3095 outer_automatic_var_p (tree decl
)
3097 return (outer_var_p (decl
)
3098 && !TREE_STATIC (decl
));
3101 /* DECL satisfies outer_automatic_var_p. Possibly complain about it or
3102 rewrite it for lambda capture. */
3105 process_outer_var_ref (tree decl
, tsubst_flags_t complain
)
3107 if (cp_unevaluated_operand
)
3108 /* It's not a use (3.2) if we're in an unevaluated context. */
3111 tree context
= DECL_CONTEXT (decl
);
3112 tree containing_function
= current_function_decl
;
3113 tree lambda_stack
= NULL_TREE
;
3114 tree lambda_expr
= NULL_TREE
;
3115 tree initializer
= convert_from_reference (decl
);
3117 /* Mark it as used now even if the use is ill-formed. */
3120 /* Core issue 696: "[At the July 2009 meeting] the CWG expressed
3121 support for an approach in which a reference to a local
3122 [constant] automatic variable in a nested class or lambda body
3123 would enter the expression as an rvalue, which would reduce
3124 the complexity of the problem"
3126 FIXME update for final resolution of core issue 696. */
3127 if (decl_maybe_constant_var_p (decl
))
3129 if (processing_template_decl
)
3130 /* In a template, the constant value may not be in a usable
3131 form, so wait until instantiation time. */
3133 else if (decl_constant_var_p (decl
))
3134 return scalar_constant_value (decl
);
3137 if (parsing_nsdmi ())
3138 containing_function
= NULL_TREE
;
3140 /* If we are in a lambda function, we can move out until we hit
3142 2. a non-lambda function, or
3143 3. a non-default capturing lambda function. */
3144 while (context
!= containing_function
3145 && LAMBDA_FUNCTION_P (containing_function
))
3147 tree closure
= DECL_CONTEXT (containing_function
);
3148 lambda_expr
= CLASSTYPE_LAMBDA_EXPR (closure
);
3150 if (TYPE_CLASS_SCOPE_P (closure
))
3151 /* A lambda in an NSDMI (c++/64496). */
3154 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr
)
3158 lambda_stack
= tree_cons (NULL_TREE
,
3163 = decl_function_context (containing_function
);
3166 if (lambda_expr
&& TREE_CODE (decl
) == VAR_DECL
3167 && DECL_ANON_UNION_VAR_P (decl
))
3169 if (complain
& tf_error
)
3170 error ("cannot capture member %qD of anonymous union", decl
);
3171 return error_mark_node
;
3173 if (context
== containing_function
)
3175 decl
= add_default_capture (lambda_stack
,
3176 /*id=*/DECL_NAME (decl
),
3179 else if (lambda_expr
)
3181 if (complain
& tf_error
)
3183 error ("%qD is not captured", decl
);
3184 tree closure
= LAMBDA_EXPR_CLOSURE (lambda_expr
);
3185 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr
)
3187 inform (location_of (closure
),
3188 "the lambda has no capture-default");
3189 else if (TYPE_CLASS_SCOPE_P (closure
))
3190 inform (0, "lambda in local class %q+T cannot "
3191 "capture variables from the enclosing context",
3192 TYPE_CONTEXT (closure
));
3193 inform (input_location
, "%q+#D declared here", decl
);
3195 return error_mark_node
;
3199 if (complain
& tf_error
)
3201 ? G_("use of local variable with automatic storage from containing function")
3202 : G_("use of parameter from containing function"));
3203 inform (input_location
, "%q+#D declared here", decl
);
3204 return error_mark_node
;
3209 /* ID_EXPRESSION is a representation of parsed, but unprocessed,
3210 id-expression. (See cp_parser_id_expression for details.) SCOPE,
3211 if non-NULL, is the type or namespace used to explicitly qualify
3212 ID_EXPRESSION. DECL is the entity to which that name has been
3215 *CONSTANT_EXPRESSION_P is true if we are presently parsing a
3216 constant-expression. In that case, *NON_CONSTANT_EXPRESSION_P will
3217 be set to true if this expression isn't permitted in a
3218 constant-expression, but it is otherwise not set by this function.
3219 *ALLOW_NON_CONSTANT_EXPRESSION_P is true if we are parsing a
3220 constant-expression, but a non-constant expression is also
3223 DONE is true if this expression is a complete postfix-expression;
3224 it is false if this expression is followed by '->', '[', '(', etc.
3225 ADDRESS_P is true iff this expression is the operand of '&'.
3226 TEMPLATE_P is true iff the qualified-id was of the form
3227 "A::template B". TEMPLATE_ARG_P is true iff this qualified name
3228 appears as a template argument.
3230 If an error occurs, and it is the kind of error that might cause
3231 the parser to abort a tentative parse, *ERROR_MSG is filled in. It
3232 is the caller's responsibility to issue the message. *ERROR_MSG
3233 will be a string with static storage duration, so the caller need
3236 Return an expression for the entity, after issuing appropriate
3237 diagnostics. This function is also responsible for transforming a
3238 reference to a non-static member into a COMPONENT_REF that makes
3239 the use of "this" explicit.
3241 Upon return, *IDK will be filled in appropriately. */
3243 finish_id_expression (tree id_expression
,
3247 bool integral_constant_expression_p
,
3248 bool allow_non_integral_constant_expression_p
,
3249 bool *non_integral_constant_expression_p
,
3253 bool template_arg_p
,
3254 const char **error_msg
,
3255 location_t location
)
3257 decl
= strip_using_decl (decl
);
3259 /* Initialize the output parameters. */
3260 *idk
= CP_ID_KIND_NONE
;
3263 if (id_expression
== error_mark_node
)
3264 return error_mark_node
;
3265 /* If we have a template-id, then no further lookup is
3266 required. If the template-id was for a template-class, we
3267 will sometimes have a TYPE_DECL at this point. */
3268 else if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
3269 || TREE_CODE (decl
) == TYPE_DECL
)
3271 /* Look up the name. */
3274 if (decl
== error_mark_node
)
3276 /* Name lookup failed. */
3279 || (!dependent_type_p (scope
)
3280 && !(identifier_p (id_expression
)
3281 && IDENTIFIER_TYPENAME_P (id_expression
)
3282 && dependent_type_p (TREE_TYPE (id_expression
))))))
3284 /* If the qualifying type is non-dependent (and the name
3285 does not name a conversion operator to a dependent
3286 type), issue an error. */
3287 qualified_name_lookup_error (scope
, id_expression
, decl
, location
);
3288 return error_mark_node
;
3292 /* It may be resolved via Koenig lookup. */
3293 *idk
= CP_ID_KIND_UNQUALIFIED
;
3294 return id_expression
;
3297 decl
= id_expression
;
3299 /* If DECL is a variable that would be out of scope under
3300 ANSI/ISO rules, but in scope in the ARM, name lookup
3301 will succeed. Issue a diagnostic here. */
3303 decl
= check_for_out_of_scope_variable (decl
);
3305 /* Remember that the name was used in the definition of
3306 the current class so that we can check later to see if
3307 the meaning would have been different after the class
3308 was entirely defined. */
3309 if (!scope
&& decl
!= error_mark_node
&& identifier_p (id_expression
))
3310 maybe_note_name_used_in_class (id_expression
, decl
);
3312 /* Disallow uses of local variables from containing functions, except
3313 within lambda-expressions. */
3314 if (outer_automatic_var_p (decl
))
3316 decl
= process_outer_var_ref (decl
, tf_warning_or_error
);
3317 if (decl
== error_mark_node
)
3318 return error_mark_node
;
3321 /* Also disallow uses of function parameters outside the function
3322 body, except inside an unevaluated context (i.e. decltype). */
3323 if (TREE_CODE (decl
) == PARM_DECL
3324 && DECL_CONTEXT (decl
) == NULL_TREE
3325 && !cp_unevaluated_operand
)
3327 *error_msg
= "use of parameter outside function body";
3328 return error_mark_node
;
3332 /* If we didn't find anything, or what we found was a type,
3333 then this wasn't really an id-expression. */
3334 if (TREE_CODE (decl
) == TEMPLATE_DECL
3335 && !DECL_FUNCTION_TEMPLATE_P (decl
))
3337 *error_msg
= "missing template arguments";
3338 return error_mark_node
;
3340 else if (TREE_CODE (decl
) == TYPE_DECL
3341 || TREE_CODE (decl
) == NAMESPACE_DECL
)
3343 *error_msg
= "expected primary-expression";
3344 return error_mark_node
;
3347 /* If the name resolved to a template parameter, there is no
3348 need to look it up again later. */
3349 if ((TREE_CODE (decl
) == CONST_DECL
&& DECL_TEMPLATE_PARM_P (decl
))
3350 || TREE_CODE (decl
) == TEMPLATE_PARM_INDEX
)
3354 *idk
= CP_ID_KIND_NONE
;
3355 if (TREE_CODE (decl
) == TEMPLATE_PARM_INDEX
)
3356 decl
= TEMPLATE_PARM_DECL (decl
);
3357 r
= convert_from_reference (DECL_INITIAL (decl
));
3359 if (integral_constant_expression_p
3360 && !dependent_type_p (TREE_TYPE (decl
))
3361 && !(INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (r
))))
3363 if (!allow_non_integral_constant_expression_p
)
3364 error ("template parameter %qD of type %qT is not allowed in "
3365 "an integral constant expression because it is not of "
3366 "integral or enumeration type", decl
, TREE_TYPE (decl
));
3367 *non_integral_constant_expression_p
= true;
3375 /* If the declaration was explicitly qualified indicate
3376 that. The semantics of `A::f(3)' are different than
3377 `f(3)' if `f' is virtual. */
3379 ? CP_ID_KIND_QUALIFIED
3380 : (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
3381 ? CP_ID_KIND_TEMPLATE_ID
3382 : CP_ID_KIND_UNQUALIFIED
));
3387 An id-expression is type-dependent if it contains an
3388 identifier that was declared with a dependent type.
3390 The standard is not very specific about an id-expression that
3391 names a set of overloaded functions. What if some of them
3392 have dependent types and some of them do not? Presumably,
3393 such a name should be treated as a dependent name. */
3394 /* Assume the name is not dependent. */
3395 dependent_p
= false;
3396 if (!processing_template_decl
)
3397 /* No names are dependent outside a template. */
3399 else if (TREE_CODE (decl
) == CONST_DECL
)
3400 /* We don't want to treat enumerators as dependent. */
3402 /* A template-id where the name of the template was not resolved
3403 is definitely dependent. */
3404 else if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
3405 && (identifier_p (TREE_OPERAND (decl
, 0))))
3407 /* For anything except an overloaded function, just check its
3409 else if (!is_overloaded_fn (decl
))
3411 = dependent_type_p (TREE_TYPE (decl
));
3412 /* For a set of overloaded functions, check each of the
3418 if (BASELINK_P (fns
))
3419 fns
= BASELINK_FUNCTIONS (fns
);
3421 /* For a template-id, check to see if the template
3422 arguments are dependent. */
3423 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
3425 tree args
= TREE_OPERAND (fns
, 1);
3426 dependent_p
= any_dependent_template_arguments_p (args
);
3427 /* The functions are those referred to by the
3429 fns
= TREE_OPERAND (fns
, 0);
3432 /* If there are no dependent template arguments, go through
3433 the overloaded functions. */
3434 while (fns
&& !dependent_p
)
3436 tree fn
= OVL_CURRENT (fns
);
3438 /* Member functions of dependent classes are
3440 if (TREE_CODE (fn
) == FUNCTION_DECL
3441 && type_dependent_expression_p (fn
))
3443 else if (TREE_CODE (fn
) == TEMPLATE_DECL
3444 && dependent_template_p (fn
))
3447 fns
= OVL_NEXT (fns
);
3451 /* If the name was dependent on a template parameter, we will
3452 resolve the name at instantiation time. */
3455 /* Create a SCOPE_REF for qualified names, if the scope is
3461 if (address_p
&& done
)
3462 decl
= finish_qualified_id_expr (scope
, decl
,
3466 tf_warning_or_error
);
3469 tree type
= NULL_TREE
;
3470 if (DECL_P (decl
) && !dependent_scope_p (scope
))
3471 type
= TREE_TYPE (decl
);
3472 decl
= build_qualified_name (type
,
3478 if (TREE_TYPE (decl
))
3479 decl
= convert_from_reference (decl
);
3482 /* A TEMPLATE_ID already contains all the information we
3484 if (TREE_CODE (id_expression
) == TEMPLATE_ID_EXPR
)
3485 return id_expression
;
3486 *idk
= CP_ID_KIND_UNQUALIFIED_DEPENDENT
;
3487 /* If we found a variable, then name lookup during the
3488 instantiation will always resolve to the same VAR_DECL
3489 (or an instantiation thereof). */
3491 || TREE_CODE (decl
) == PARM_DECL
)
3494 return convert_from_reference (decl
);
3496 /* The same is true for FIELD_DECL, but we also need to
3497 make sure that the syntax is correct. */
3498 else if (TREE_CODE (decl
) == FIELD_DECL
)
3500 /* Since SCOPE is NULL here, this is an unqualified name.
3501 Access checking has been performed during name lookup
3502 already. Turn off checking to avoid duplicate errors. */
3503 push_deferring_access_checks (dk_no_check
);
3504 decl
= finish_non_static_data_member
3506 /*qualifying_scope=*/NULL_TREE
);
3507 pop_deferring_access_checks ();
3510 return id_expression
;
3513 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
3515 error ("use of namespace %qD as expression", decl
);
3516 return error_mark_node
;
3518 else if (DECL_CLASS_TEMPLATE_P (decl
))
3520 error ("use of class template %qT as expression", decl
);
3521 return error_mark_node
;
3523 else if (TREE_CODE (decl
) == TREE_LIST
)
3525 /* Ambiguous reference to base members. */
3526 error ("request for member %qD is ambiguous in "
3527 "multiple inheritance lattice", id_expression
);
3528 print_candidates (decl
);
3529 return error_mark_node
;
3532 /* Mark variable-like entities as used. Functions are similarly
3533 marked either below or after overload resolution. */
3535 || TREE_CODE (decl
) == PARM_DECL
3536 || TREE_CODE (decl
) == CONST_DECL
3537 || TREE_CODE (decl
) == RESULT_DECL
)
3538 && !mark_used (decl
))
3539 return error_mark_node
;
3541 /* Only certain kinds of names are allowed in constant
3542 expression. Template parameters have already
3543 been handled above. */
3544 if (! error_operand_p (decl
)
3545 && integral_constant_expression_p
3546 && ! decl_constant_var_p (decl
)
3547 && TREE_CODE (decl
) != CONST_DECL
3548 && ! builtin_valid_in_constant_expr_p (decl
))
3550 if (!allow_non_integral_constant_expression_p
)
3552 error ("%qD cannot appear in a constant-expression", decl
);
3553 return error_mark_node
;
3555 *non_integral_constant_expression_p
= true;
3560 && !cp_unevaluated_operand
3561 && !processing_template_decl
3562 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
))
3563 && DECL_THREAD_LOCAL_P (decl
)
3564 && (wrap
= get_tls_wrapper_fn (decl
)))
3566 /* Replace an evaluated use of the thread_local variable with
3567 a call to its wrapper. */
3568 decl
= build_cxx_call (wrap
, 0, NULL
, tf_warning_or_error
);
3570 else if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
3571 && variable_template_p (TREE_OPERAND (decl
, 0)))
3573 decl
= finish_template_variable (decl
);
3578 decl
= (adjust_result_of_qualified_name_lookup
3579 (decl
, scope
, current_nonlambda_class_type()));
3581 if (TREE_CODE (decl
) == FUNCTION_DECL
)
3585 decl
= finish_qualified_id_expr (scope
,
3591 tf_warning_or_error
);
3593 decl
= convert_from_reference (decl
);
3595 else if (TREE_CODE (decl
) == FIELD_DECL
)
3597 /* Since SCOPE is NULL here, this is an unqualified name.
3598 Access checking has been performed during name lookup
3599 already. Turn off checking to avoid duplicate errors. */
3600 push_deferring_access_checks (dk_no_check
);
3601 decl
= finish_non_static_data_member (decl
, NULL_TREE
,
3602 /*qualifying_scope=*/NULL_TREE
);
3603 pop_deferring_access_checks ();
3605 else if (is_overloaded_fn (decl
))
3609 first_fn
= get_first_fn (decl
);
3610 if (TREE_CODE (first_fn
) == TEMPLATE_DECL
)
3611 first_fn
= DECL_TEMPLATE_RESULT (first_fn
);
3613 if (!really_overloaded_fn (decl
)
3614 && !mark_used (first_fn
))
3615 return error_mark_node
;
3618 && TREE_CODE (first_fn
) == FUNCTION_DECL
3619 && DECL_FUNCTION_MEMBER_P (first_fn
)
3620 && !shared_member_p (decl
))
3622 /* A set of member functions. */
3623 decl
= maybe_dummy_object (DECL_CONTEXT (first_fn
), 0);
3624 return finish_class_member_access_expr (decl
, id_expression
,
3625 /*template_p=*/false,
3626 tf_warning_or_error
);
3629 decl
= baselink_for_fns (decl
);
3633 if (DECL_P (decl
) && DECL_NONLOCAL (decl
)
3634 && DECL_CLASS_SCOPE_P (decl
))
3636 tree context
= context_for_name_lookup (decl
);
3637 if (context
!= current_class_type
)
3639 tree path
= currently_open_derived_class (context
);
3640 perform_or_defer_access_check (TYPE_BINFO (path
),
3642 tf_warning_or_error
);
3646 decl
= convert_from_reference (decl
);
3650 /* Handle references (c++/56130). */
3651 tree t
= REFERENCE_REF_P (decl
) ? TREE_OPERAND (decl
, 0) : decl
;
3652 if (TREE_DEPRECATED (t
))
3653 warn_deprecated_use (t
, NULL_TREE
);
3658 /* Implement the __typeof keyword: Return the type of EXPR, suitable for
3659 use as a type-specifier. */
3662 finish_typeof (tree expr
)
3666 if (type_dependent_expression_p (expr
))
3668 type
= cxx_make_type (TYPEOF_TYPE
);
3669 TYPEOF_TYPE_EXPR (type
) = expr
;
3670 SET_TYPE_STRUCTURAL_EQUALITY (type
);
3675 expr
= mark_type_use (expr
);
3677 type
= unlowered_expr_type (expr
);
3679 if (!type
|| type
== unknown_type_node
)
3681 error ("type of %qE is unknown", expr
);
3682 return error_mark_node
;
3688 /* Implement the __underlying_type keyword: Return the underlying
3689 type of TYPE, suitable for use as a type-specifier. */
3692 finish_underlying_type (tree type
)
3694 tree underlying_type
;
3696 if (processing_template_decl
)
3698 underlying_type
= cxx_make_type (UNDERLYING_TYPE
);
3699 UNDERLYING_TYPE_TYPE (underlying_type
) = type
;
3700 SET_TYPE_STRUCTURAL_EQUALITY (underlying_type
);
3702 return underlying_type
;
3705 complete_type (type
);
3707 if (TREE_CODE (type
) != ENUMERAL_TYPE
)
3709 error ("%qT is not an enumeration type", type
);
3710 return error_mark_node
;
3713 underlying_type
= ENUM_UNDERLYING_TYPE (type
);
3715 /* Fixup necessary in this case because ENUM_UNDERLYING_TYPE
3716 includes TYPE_MIN_VALUE and TYPE_MAX_VALUE information.
3717 See finish_enum_value_list for details. */
3718 if (!ENUM_FIXED_UNDERLYING_TYPE_P (type
))
3720 = c_common_type_for_mode (TYPE_MODE (underlying_type
),
3721 TYPE_UNSIGNED (underlying_type
));
3723 return underlying_type
;
3726 /* Implement the __direct_bases keyword: Return the direct base classes
3730 calculate_direct_bases (tree type
)
3732 vec
<tree
, va_gc
> *vector
= make_tree_vector();
3733 tree bases_vec
= NULL_TREE
;
3734 vec
<tree
, va_gc
> *base_binfos
;
3738 complete_type (type
);
3740 if (!NON_UNION_CLASS_TYPE_P (type
))
3741 return make_tree_vec (0);
3743 base_binfos
= BINFO_BASE_BINFOS (TYPE_BINFO (type
));
3745 /* Virtual bases are initialized first */
3746 for (i
= 0; base_binfos
->iterate (i
, &binfo
); i
++)
3748 if (BINFO_VIRTUAL_P (binfo
))
3750 vec_safe_push (vector
, binfo
);
3754 /* Now non-virtuals */
3755 for (i
= 0; base_binfos
->iterate (i
, &binfo
); i
++)
3757 if (!BINFO_VIRTUAL_P (binfo
))
3759 vec_safe_push (vector
, binfo
);
3764 bases_vec
= make_tree_vec (vector
->length ());
3766 for (i
= 0; i
< vector
->length (); ++i
)
3768 TREE_VEC_ELT (bases_vec
, i
) = BINFO_TYPE ((*vector
)[i
]);
3773 /* Implement the __bases keyword: Return the base classes
3776 /* Find morally non-virtual base classes by walking binfo hierarchy */
3777 /* Virtual base classes are handled separately in finish_bases */
3780 dfs_calculate_bases_pre (tree binfo
, void * /*data_*/)
3782 /* Don't walk bases of virtual bases */
3783 return BINFO_VIRTUAL_P (binfo
) ? dfs_skip_bases
: NULL_TREE
;
3787 dfs_calculate_bases_post (tree binfo
, void *data_
)
3789 vec
<tree
, va_gc
> **data
= ((vec
<tree
, va_gc
> **) data_
);
3790 if (!BINFO_VIRTUAL_P (binfo
))
3792 vec_safe_push (*data
, BINFO_TYPE (binfo
));
3797 /* Calculates the morally non-virtual base classes of a class */
3798 static vec
<tree
, va_gc
> *
3799 calculate_bases_helper (tree type
)
3801 vec
<tree
, va_gc
> *vector
= make_tree_vector();
3803 /* Now add non-virtual base classes in order of construction */
3804 dfs_walk_all (TYPE_BINFO (type
),
3805 dfs_calculate_bases_pre
, dfs_calculate_bases_post
, &vector
);
3810 calculate_bases (tree type
)
3812 vec
<tree
, va_gc
> *vector
= make_tree_vector();
3813 tree bases_vec
= NULL_TREE
;
3815 vec
<tree
, va_gc
> *vbases
;
3816 vec
<tree
, va_gc
> *nonvbases
;
3819 complete_type (type
);
3821 if (!NON_UNION_CLASS_TYPE_P (type
))
3822 return make_tree_vec (0);
3824 /* First go through virtual base classes */
3825 for (vbases
= CLASSTYPE_VBASECLASSES (type
), i
= 0;
3826 vec_safe_iterate (vbases
, i
, &binfo
); i
++)
3828 vec
<tree
, va_gc
> *vbase_bases
;
3829 vbase_bases
= calculate_bases_helper (BINFO_TYPE (binfo
));
3830 vec_safe_splice (vector
, vbase_bases
);
3831 release_tree_vector (vbase_bases
);
3834 /* Now for the non-virtual bases */
3835 nonvbases
= calculate_bases_helper (type
);
3836 vec_safe_splice (vector
, nonvbases
);
3837 release_tree_vector (nonvbases
);
3839 /* Last element is entire class, so don't copy */
3840 bases_vec
= make_tree_vec (vector
->length () - 1);
3842 for (i
= 0; i
< vector
->length () - 1; ++i
)
3844 TREE_VEC_ELT (bases_vec
, i
) = (*vector
)[i
];
3846 release_tree_vector (vector
);
3851 finish_bases (tree type
, bool direct
)
3853 tree bases
= NULL_TREE
;
3855 if (!processing_template_decl
)
3857 /* Parameter packs can only be used in templates */
3858 error ("Parameter pack __bases only valid in template declaration");
3859 return error_mark_node
;
3862 bases
= cxx_make_type (BASES
);
3863 BASES_TYPE (bases
) = type
;
3864 BASES_DIRECT (bases
) = direct
;
3865 SET_TYPE_STRUCTURAL_EQUALITY (bases
);
3870 /* Perform C++-specific checks for __builtin_offsetof before calling
3874 finish_offsetof (tree expr
, location_t loc
)
3876 /* If we're processing a template, we can't finish the semantics yet.
3877 Otherwise we can fold the entire expression now. */
3878 if (processing_template_decl
)
3880 expr
= build1 (OFFSETOF_EXPR
, size_type_node
, expr
);
3881 SET_EXPR_LOCATION (expr
, loc
);
3885 if (TREE_CODE (expr
) == PSEUDO_DTOR_EXPR
)
3887 error ("cannot apply %<offsetof%> to destructor %<~%T%>",
3888 TREE_OPERAND (expr
, 2));
3889 return error_mark_node
;
3891 if (TREE_CODE (TREE_TYPE (expr
)) == FUNCTION_TYPE
3892 || TREE_CODE (TREE_TYPE (expr
)) == METHOD_TYPE
3893 || TREE_TYPE (expr
) == unknown_type_node
)
3895 if (INDIRECT_REF_P (expr
))
3896 error ("second operand of %<offsetof%> is neither a single "
3897 "identifier nor a sequence of member accesses and "
3898 "array references");
3901 if (TREE_CODE (expr
) == COMPONENT_REF
3902 || TREE_CODE (expr
) == COMPOUND_EXPR
)
3903 expr
= TREE_OPERAND (expr
, 1);
3904 error ("cannot apply %<offsetof%> to member function %qD", expr
);
3906 return error_mark_node
;
3908 if (REFERENCE_REF_P (expr
))
3909 expr
= TREE_OPERAND (expr
, 0);
3910 if (TREE_CODE (expr
) == COMPONENT_REF
)
3912 tree object
= TREE_OPERAND (expr
, 0);
3913 if (!complete_type_or_else (TREE_TYPE (object
), object
))
3914 return error_mark_node
;
3915 if (warn_invalid_offsetof
3916 && CLASS_TYPE_P (TREE_TYPE (object
))
3917 && CLASSTYPE_NON_STD_LAYOUT (TREE_TYPE (object
))
3918 && cp_unevaluated_operand
== 0)
3919 pedwarn (loc
, OPT_Winvalid_offsetof
,
3920 "offsetof within non-standard-layout type %qT is undefined",
3921 TREE_TYPE (object
));
3923 return fold_offsetof (expr
);
3926 /* Replace the AGGR_INIT_EXPR at *TP with an equivalent CALL_EXPR. This
3927 function is broken out from the above for the benefit of the tree-ssa
3931 simplify_aggr_init_expr (tree
*tp
)
3933 tree aggr_init_expr
= *tp
;
3935 /* Form an appropriate CALL_EXPR. */
3936 tree fn
= AGGR_INIT_EXPR_FN (aggr_init_expr
);
3937 tree slot
= AGGR_INIT_EXPR_SLOT (aggr_init_expr
);
3938 tree type
= TREE_TYPE (slot
);
3941 enum style_t
{ ctor
, arg
, pcc
} style
;
3943 if (AGGR_INIT_VIA_CTOR_P (aggr_init_expr
))
3945 #ifdef PCC_STATIC_STRUCT_RETURN
3951 gcc_assert (TREE_ADDRESSABLE (type
));
3955 call_expr
= build_call_array_loc (input_location
,
3956 TREE_TYPE (TREE_TYPE (TREE_TYPE (fn
))),
3958 aggr_init_expr_nargs (aggr_init_expr
),
3959 AGGR_INIT_EXPR_ARGP (aggr_init_expr
));
3960 TREE_NOTHROW (call_expr
) = TREE_NOTHROW (aggr_init_expr
);
3961 CALL_EXPR_LIST_INIT_P (call_expr
) = CALL_EXPR_LIST_INIT_P (aggr_init_expr
);
3965 /* Replace the first argument to the ctor with the address of the
3967 cxx_mark_addressable (slot
);
3968 CALL_EXPR_ARG (call_expr
, 0) =
3969 build1 (ADDR_EXPR
, build_pointer_type (type
), slot
);
3971 else if (style
== arg
)
3973 /* Just mark it addressable here, and leave the rest to
3974 expand_call{,_inline}. */
3975 cxx_mark_addressable (slot
);
3976 CALL_EXPR_RETURN_SLOT_OPT (call_expr
) = true;
3977 call_expr
= build2 (INIT_EXPR
, TREE_TYPE (call_expr
), slot
, call_expr
);
3979 else if (style
== pcc
)
3981 /* If we're using the non-reentrant PCC calling convention, then we
3982 need to copy the returned value out of the static buffer into the
3984 push_deferring_access_checks (dk_no_check
);
3985 call_expr
= build_aggr_init (slot
, call_expr
,
3986 DIRECT_BIND
| LOOKUP_ONLYCONVERTING
,
3987 tf_warning_or_error
);
3988 pop_deferring_access_checks ();
3989 call_expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (slot
), call_expr
, slot
);
3992 if (AGGR_INIT_ZERO_FIRST (aggr_init_expr
))
3994 tree init
= build_zero_init (type
, NULL_TREE
,
3995 /*static_storage_p=*/false);
3996 init
= build2 (INIT_EXPR
, void_type_node
, slot
, init
);
3997 call_expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (call_expr
),
4004 /* Emit all thunks to FN that should be emitted when FN is emitted. */
4007 emit_associated_thunks (tree fn
)
4009 /* When we use vcall offsets, we emit thunks with the virtual
4010 functions to which they thunk. The whole point of vcall offsets
4011 is so that you can know statically the entire set of thunks that
4012 will ever be needed for a given virtual function, thereby
4013 enabling you to output all the thunks with the function itself. */
4014 if (DECL_VIRTUAL_P (fn
)
4015 /* Do not emit thunks for extern template instantiations. */
4016 && ! DECL_REALLY_EXTERN (fn
))
4020 for (thunk
= DECL_THUNKS (fn
); thunk
; thunk
= DECL_CHAIN (thunk
))
4022 if (!THUNK_ALIAS (thunk
))
4024 use_thunk (thunk
, /*emit_p=*/1);
4025 if (DECL_RESULT_THUNK_P (thunk
))
4029 for (probe
= DECL_THUNKS (thunk
);
4030 probe
; probe
= DECL_CHAIN (probe
))
4031 use_thunk (probe
, /*emit_p=*/1);
4035 gcc_assert (!DECL_THUNKS (thunk
));
4040 /* Generate RTL for FN. */
4043 expand_or_defer_fn_1 (tree fn
)
4045 /* When the parser calls us after finishing the body of a template
4046 function, we don't really want to expand the body. */
4047 if (processing_template_decl
)
4049 /* Normally, collection only occurs in rest_of_compilation. So,
4050 if we don't collect here, we never collect junk generated
4051 during the processing of templates until we hit a
4052 non-template function. It's not safe to do this inside a
4053 nested class, though, as the parser may have local state that
4054 is not a GC root. */
4055 if (!function_depth
)
4060 gcc_assert (DECL_SAVED_TREE (fn
));
4062 /* We make a decision about linkage for these functions at the end
4063 of the compilation. Until that point, we do not want the back
4064 end to output them -- but we do want it to see the bodies of
4065 these functions so that it can inline them as appropriate. */
4066 if (DECL_DECLARED_INLINE_P (fn
) || DECL_IMPLICIT_INSTANTIATION (fn
))
4068 if (DECL_INTERFACE_KNOWN (fn
))
4069 /* We've already made a decision as to how this function will
4072 tentative_decl_linkage (fn
);
4074 import_export_decl (fn
);
4076 /* If the user wants us to keep all inline functions, then mark
4077 this function as needed so that finish_file will make sure to
4078 output it later. Similarly, all dllexport'd functions must
4079 be emitted; there may be callers in other DLLs. */
4080 if (DECL_DECLARED_INLINE_P (fn
)
4081 && !DECL_REALLY_EXTERN (fn
)
4082 && (flag_keep_inline_functions
4083 || (flag_keep_inline_dllexport
4084 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (fn
)))))
4087 DECL_EXTERNAL (fn
) = 0;
4091 /* If this is a constructor or destructor body, we have to clone
4093 if (maybe_clone_body (fn
))
4095 /* We don't want to process FN again, so pretend we've written
4096 it out, even though we haven't. */
4097 TREE_ASM_WRITTEN (fn
) = 1;
4098 /* If this is an instantiation of a constexpr function, keep
4099 DECL_SAVED_TREE for explain_invalid_constexpr_fn. */
4100 if (!is_instantiation_of_constexpr (fn
))
4101 DECL_SAVED_TREE (fn
) = NULL_TREE
;
4105 /* There's no reason to do any of the work here if we're only doing
4106 semantic analysis; this code just generates RTL. */
4107 if (flag_syntax_only
)
4114 expand_or_defer_fn (tree fn
)
4116 if (expand_or_defer_fn_1 (fn
))
4120 /* Expand or defer, at the whim of the compilation unit manager. */
4121 cgraph_node::finalize_function (fn
, function_depth
> 1);
4122 emit_associated_thunks (fn
);
4130 nrv_data () : visited (37) {}
4134 hash_table
<pointer_hash
<tree_node
> > visited
;
4137 /* Helper function for walk_tree, used by finalize_nrv below. */
4140 finalize_nrv_r (tree
* tp
, int* walk_subtrees
, void* data
)
4142 struct nrv_data
*dp
= (struct nrv_data
*)data
;
4145 /* No need to walk into types. There wouldn't be any need to walk into
4146 non-statements, except that we have to consider STMT_EXPRs. */
4149 /* Change all returns to just refer to the RESULT_DECL; this is a nop,
4150 but differs from using NULL_TREE in that it indicates that we care
4151 about the value of the RESULT_DECL. */
4152 else if (TREE_CODE (*tp
) == RETURN_EXPR
)
4153 TREE_OPERAND (*tp
, 0) = dp
->result
;
4154 /* Change all cleanups for the NRV to only run when an exception is
4156 else if (TREE_CODE (*tp
) == CLEANUP_STMT
4157 && CLEANUP_DECL (*tp
) == dp
->var
)
4158 CLEANUP_EH_ONLY (*tp
) = 1;
4159 /* Replace the DECL_EXPR for the NRV with an initialization of the
4160 RESULT_DECL, if needed. */
4161 else if (TREE_CODE (*tp
) == DECL_EXPR
4162 && DECL_EXPR_DECL (*tp
) == dp
->var
)
4165 if (DECL_INITIAL (dp
->var
)
4166 && DECL_INITIAL (dp
->var
) != error_mark_node
)
4167 init
= build2 (INIT_EXPR
, void_type_node
, dp
->result
,
4168 DECL_INITIAL (dp
->var
));
4170 init
= build_empty_stmt (EXPR_LOCATION (*tp
));
4171 DECL_INITIAL (dp
->var
) = NULL_TREE
;
4172 SET_EXPR_LOCATION (init
, EXPR_LOCATION (*tp
));
4175 /* And replace all uses of the NRV with the RESULT_DECL. */
4176 else if (*tp
== dp
->var
)
4179 /* Avoid walking into the same tree more than once. Unfortunately, we
4180 can't just use walk_tree_without duplicates because it would only call
4181 us for the first occurrence of dp->var in the function body. */
4182 slot
= dp
->visited
.find_slot (*tp
, INSERT
);
4188 /* Keep iterating. */
4192 /* Called from finish_function to implement the named return value
4193 optimization by overriding all the RETURN_EXPRs and pertinent
4194 CLEANUP_STMTs and replacing all occurrences of VAR with RESULT, the
4195 RESULT_DECL for the function. */
4198 finalize_nrv (tree
*tp
, tree var
, tree result
)
4200 struct nrv_data data
;
4202 /* Copy name from VAR to RESULT. */
4203 DECL_NAME (result
) = DECL_NAME (var
);
4204 /* Don't forget that we take its address. */
4205 TREE_ADDRESSABLE (result
) = TREE_ADDRESSABLE (var
);
4206 /* Finally set DECL_VALUE_EXPR to avoid assigning
4207 a stack slot at -O0 for the original var and debug info
4208 uses RESULT location for VAR. */
4209 SET_DECL_VALUE_EXPR (var
, result
);
4210 DECL_HAS_VALUE_EXPR_P (var
) = 1;
4213 data
.result
= result
;
4214 cp_walk_tree (tp
, finalize_nrv_r
, &data
, 0);
4217 /* Create CP_OMP_CLAUSE_INFO for clause C. Returns true if it is invalid. */
4220 cxx_omp_create_clause_info (tree c
, tree type
, bool need_default_ctor
,
4221 bool need_copy_ctor
, bool need_copy_assignment
,
4224 int save_errorcount
= errorcount
;
4227 /* Always allocate 3 elements for simplicity. These are the
4228 function decls for the ctor, dtor, and assignment op.
4229 This layout is known to the three lang hooks,
4230 cxx_omp_clause_default_init, cxx_omp_clause_copy_init,
4231 and cxx_omp_clause_assign_op. */
4232 info
= make_tree_vec (3);
4233 CP_OMP_CLAUSE_INFO (c
) = info
;
4235 if (need_default_ctor
|| need_copy_ctor
)
4237 if (need_default_ctor
)
4238 t
= get_default_ctor (type
);
4240 t
= get_copy_ctor (type
, tf_warning_or_error
);
4242 if (t
&& !trivial_fn_p (t
))
4243 TREE_VEC_ELT (info
, 0) = t
;
4246 if (need_dtor
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
4247 TREE_VEC_ELT (info
, 1) = get_dtor (type
, tf_warning_or_error
);
4249 if (need_copy_assignment
)
4251 t
= get_copy_assign (type
);
4253 if (t
&& !trivial_fn_p (t
))
4254 TREE_VEC_ELT (info
, 2) = t
;
4257 return errorcount
!= save_errorcount
;
4260 /* Helper function for handle_omp_array_sections. Called recursively
4261 to handle multiple array-section-subscripts. C is the clause,
4262 T current expression (initially OMP_CLAUSE_DECL), which is either
4263 a TREE_LIST for array-section-subscript (TREE_PURPOSE is low-bound
4264 expression if specified, TREE_VALUE length expression if specified,
4265 TREE_CHAIN is what it has been specified after, or some decl.
4266 TYPES vector is populated with array section types, MAYBE_ZERO_LEN
4267 set to true if any of the array-section-subscript could have length
4268 of zero (explicit or implicit), FIRST_NON_ONE is the index of the
4269 first array-section-subscript which is known not to have length
4271 map(a[:b][2:1][:c][:2][:d][e:f][2:5])
4272 FIRST_NON_ONE will be 3, array-section-subscript [:b], [2:1] and [:c]
4273 all are or may have length of 1, array-section-subscript [:2] is the
4274 first one knonwn not to have length 1. For array-section-subscript
4275 <= FIRST_NON_ONE we diagnose non-contiguous arrays if low bound isn't
4276 0 or length isn't the array domain max + 1, for > FIRST_NON_ONE we
4277 can if MAYBE_ZERO_LEN is false. MAYBE_ZERO_LEN will be true in the above
4278 case though, as some lengths could be zero. */
4281 handle_omp_array_sections_1 (tree c
, tree t
, vec
<tree
> &types
,
4282 bool &maybe_zero_len
, unsigned int &first_non_one
)
4284 tree ret
, low_bound
, length
, type
;
4285 if (TREE_CODE (t
) != TREE_LIST
)
4287 if (error_operand_p (t
))
4288 return error_mark_node
;
4289 if (type_dependent_expression_p (t
))
4291 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
4293 if (processing_template_decl
)
4296 error_at (OMP_CLAUSE_LOCATION (c
),
4297 "%qD is not a variable in %qs clause", t
,
4298 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
4300 error_at (OMP_CLAUSE_LOCATION (c
),
4301 "%qE is not a variable in %qs clause", t
,
4302 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
4303 return error_mark_node
;
4305 else if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_DEPEND
4306 && TREE_CODE (t
) == VAR_DECL
&& DECL_THREAD_LOCAL_P (t
))
4308 error_at (OMP_CLAUSE_LOCATION (c
),
4309 "%qD is threadprivate variable in %qs clause", t
,
4310 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
4311 return error_mark_node
;
4313 t
= convert_from_reference (t
);
4317 ret
= handle_omp_array_sections_1 (c
, TREE_CHAIN (t
), types
,
4318 maybe_zero_len
, first_non_one
);
4319 if (ret
== error_mark_node
|| ret
== NULL_TREE
)
4322 type
= TREE_TYPE (ret
);
4323 low_bound
= TREE_PURPOSE (t
);
4324 length
= TREE_VALUE (t
);
4325 if ((low_bound
&& type_dependent_expression_p (low_bound
))
4326 || (length
&& type_dependent_expression_p (length
)))
4329 if (low_bound
== error_mark_node
|| length
== error_mark_node
)
4330 return error_mark_node
;
4332 if (low_bound
&& !INTEGRAL_TYPE_P (TREE_TYPE (low_bound
)))
4334 error_at (OMP_CLAUSE_LOCATION (c
),
4335 "low bound %qE of array section does not have integral type",
4337 return error_mark_node
;
4339 if (length
&& !INTEGRAL_TYPE_P (TREE_TYPE (length
)))
4341 error_at (OMP_CLAUSE_LOCATION (c
),
4342 "length %qE of array section does not have integral type",
4344 return error_mark_node
;
4347 low_bound
= mark_rvalue_use (low_bound
);
4349 length
= mark_rvalue_use (length
);
4351 && TREE_CODE (low_bound
) == INTEGER_CST
4352 && TYPE_PRECISION (TREE_TYPE (low_bound
))
4353 > TYPE_PRECISION (sizetype
))
4354 low_bound
= fold_convert (sizetype
, low_bound
);
4356 && TREE_CODE (length
) == INTEGER_CST
4357 && TYPE_PRECISION (TREE_TYPE (length
))
4358 > TYPE_PRECISION (sizetype
))
4359 length
= fold_convert (sizetype
, length
);
4360 if (low_bound
== NULL_TREE
)
4361 low_bound
= integer_zero_node
;
4363 if (length
!= NULL_TREE
)
4365 if (!integer_nonzerop (length
))
4366 maybe_zero_len
= true;
4367 if (first_non_one
== types
.length ()
4368 && (TREE_CODE (length
) != INTEGER_CST
|| integer_onep (length
)))
4371 if (TREE_CODE (type
) == ARRAY_TYPE
)
4373 if (length
== NULL_TREE
4374 && (TYPE_DOMAIN (type
) == NULL_TREE
4375 || TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) == NULL_TREE
))
4377 error_at (OMP_CLAUSE_LOCATION (c
),
4378 "for unknown bound array type length expression must "
4380 return error_mark_node
;
4382 if (TREE_CODE (low_bound
) == INTEGER_CST
4383 && tree_int_cst_sgn (low_bound
) == -1)
4385 error_at (OMP_CLAUSE_LOCATION (c
),
4386 "negative low bound in array section in %qs clause",
4387 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
4388 return error_mark_node
;
4390 if (length
!= NULL_TREE
4391 && TREE_CODE (length
) == INTEGER_CST
4392 && tree_int_cst_sgn (length
) == -1)
4394 error_at (OMP_CLAUSE_LOCATION (c
),
4395 "negative length in array section in %qs clause",
4396 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
4397 return error_mark_node
;
4399 if (TYPE_DOMAIN (type
)
4400 && TYPE_MAX_VALUE (TYPE_DOMAIN (type
))
4401 && TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)))
4404 tree size
= size_binop (PLUS_EXPR
,
4405 TYPE_MAX_VALUE (TYPE_DOMAIN (type
)),
4407 if (TREE_CODE (low_bound
) == INTEGER_CST
)
4409 if (tree_int_cst_lt (size
, low_bound
))
4411 error_at (OMP_CLAUSE_LOCATION (c
),
4412 "low bound %qE above array section size "
4413 "in %qs clause", low_bound
,
4414 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
4415 return error_mark_node
;
4417 if (tree_int_cst_equal (size
, low_bound
))
4418 maybe_zero_len
= true;
4419 else if (length
== NULL_TREE
4420 && first_non_one
== types
.length ()
4421 && tree_int_cst_equal
4422 (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)),
4426 else if (length
== NULL_TREE
)
4428 maybe_zero_len
= true;
4429 if (first_non_one
== types
.length ())
4432 if (length
&& TREE_CODE (length
) == INTEGER_CST
)
4434 if (tree_int_cst_lt (size
, length
))
4436 error_at (OMP_CLAUSE_LOCATION (c
),
4437 "length %qE above array section size "
4438 "in %qs clause", length
,
4439 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
4440 return error_mark_node
;
4442 if (TREE_CODE (low_bound
) == INTEGER_CST
)
4445 = size_binop (PLUS_EXPR
,
4446 fold_convert (sizetype
, low_bound
),
4447 fold_convert (sizetype
, length
));
4448 if (TREE_CODE (lbpluslen
) == INTEGER_CST
4449 && tree_int_cst_lt (size
, lbpluslen
))
4451 error_at (OMP_CLAUSE_LOCATION (c
),
4452 "high bound %qE above array section size "
4453 "in %qs clause", lbpluslen
,
4454 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
4455 return error_mark_node
;
4460 else if (length
== NULL_TREE
)
4462 maybe_zero_len
= true;
4463 if (first_non_one
== types
.length ())
4467 /* For [lb:] we will need to evaluate lb more than once. */
4468 if (length
== NULL_TREE
&& OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_DEPEND
)
4470 tree lb
= cp_save_expr (low_bound
);
4471 if (lb
!= low_bound
)
4473 TREE_PURPOSE (t
) = lb
;
4478 else if (TREE_CODE (type
) == POINTER_TYPE
)
4480 if (length
== NULL_TREE
)
4482 error_at (OMP_CLAUSE_LOCATION (c
),
4483 "for pointer type length expression must be specified");
4484 return error_mark_node
;
4486 /* If there is a pointer type anywhere but in the very first
4487 array-section-subscript, the array section can't be contiguous. */
4488 if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_DEPEND
4489 && TREE_CODE (TREE_CHAIN (t
)) == TREE_LIST
)
4491 error_at (OMP_CLAUSE_LOCATION (c
),
4492 "array section is not contiguous in %qs clause",
4493 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
4494 return error_mark_node
;
4499 error_at (OMP_CLAUSE_LOCATION (c
),
4500 "%qE does not have pointer or array type", ret
);
4501 return error_mark_node
;
4503 if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_DEPEND
)
4504 types
.safe_push (TREE_TYPE (ret
));
4505 /* We will need to evaluate lb more than once. */
4506 tree lb
= cp_save_expr (low_bound
);
4507 if (lb
!= low_bound
)
4509 TREE_PURPOSE (t
) = lb
;
4512 ret
= grok_array_decl (OMP_CLAUSE_LOCATION (c
), ret
, low_bound
, false);
4516 /* Handle array sections for clause C. */
4519 handle_omp_array_sections (tree c
)
4521 bool maybe_zero_len
= false;
4522 unsigned int first_non_one
= 0;
4523 auto_vec
<tree
> types
;
4524 tree first
= handle_omp_array_sections_1 (c
, OMP_CLAUSE_DECL (c
), types
,
4525 maybe_zero_len
, first_non_one
);
4526 if (first
== error_mark_node
)
4528 if (first
== NULL_TREE
)
4530 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_DEPEND
)
4532 tree t
= OMP_CLAUSE_DECL (c
);
4533 tree tem
= NULL_TREE
;
4534 if (processing_template_decl
)
4536 /* Need to evaluate side effects in the length expressions
4538 while (TREE_CODE (t
) == TREE_LIST
)
4540 if (TREE_VALUE (t
) && TREE_SIDE_EFFECTS (TREE_VALUE (t
)))
4542 if (tem
== NULL_TREE
)
4543 tem
= TREE_VALUE (t
);
4545 tem
= build2 (COMPOUND_EXPR
, TREE_TYPE (tem
),
4546 TREE_VALUE (t
), tem
);
4551 first
= build2 (COMPOUND_EXPR
, TREE_TYPE (first
), tem
, first
);
4552 OMP_CLAUSE_DECL (c
) = first
;
4556 unsigned int num
= types
.length (), i
;
4557 tree t
, side_effects
= NULL_TREE
, size
= NULL_TREE
;
4558 tree condition
= NULL_TREE
;
4560 if (int_size_in_bytes (TREE_TYPE (first
)) <= 0)
4561 maybe_zero_len
= true;
4562 if (processing_template_decl
&& maybe_zero_len
)
4565 for (i
= num
, t
= OMP_CLAUSE_DECL (c
); i
> 0;
4568 tree low_bound
= TREE_PURPOSE (t
);
4569 tree length
= TREE_VALUE (t
);
4573 && TREE_CODE (low_bound
) == INTEGER_CST
4574 && TYPE_PRECISION (TREE_TYPE (low_bound
))
4575 > TYPE_PRECISION (sizetype
))
4576 low_bound
= fold_convert (sizetype
, low_bound
);
4578 && TREE_CODE (length
) == INTEGER_CST
4579 && TYPE_PRECISION (TREE_TYPE (length
))
4580 > TYPE_PRECISION (sizetype
))
4581 length
= fold_convert (sizetype
, length
);
4582 if (low_bound
== NULL_TREE
)
4583 low_bound
= integer_zero_node
;
4584 if (!maybe_zero_len
&& i
> first_non_one
)
4586 if (integer_nonzerop (low_bound
))
4587 goto do_warn_noncontiguous
;
4588 if (length
!= NULL_TREE
4589 && TREE_CODE (length
) == INTEGER_CST
4590 && TYPE_DOMAIN (types
[i
])
4591 && TYPE_MAX_VALUE (TYPE_DOMAIN (types
[i
]))
4592 && TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (types
[i
])))
4596 size
= size_binop (PLUS_EXPR
,
4597 TYPE_MAX_VALUE (TYPE_DOMAIN (types
[i
])),
4599 if (!tree_int_cst_equal (length
, size
))
4601 do_warn_noncontiguous
:
4602 error_at (OMP_CLAUSE_LOCATION (c
),
4603 "array section is not contiguous in %qs "
4605 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
4609 if (!processing_template_decl
4610 && length
!= NULL_TREE
4611 && TREE_SIDE_EFFECTS (length
))
4613 if (side_effects
== NULL_TREE
)
4614 side_effects
= length
;
4616 side_effects
= build2 (COMPOUND_EXPR
,
4617 TREE_TYPE (side_effects
),
4618 length
, side_effects
);
4621 else if (processing_template_decl
)
4627 if (i
> first_non_one
&& length
&& integer_nonzerop (length
))
4630 l
= fold_convert (sizetype
, length
);
4633 l
= size_binop (PLUS_EXPR
,
4634 TYPE_MAX_VALUE (TYPE_DOMAIN (types
[i
])),
4636 l
= size_binop (MINUS_EXPR
, l
,
4637 fold_convert (sizetype
, low_bound
));
4639 if (i
> first_non_one
)
4641 l
= fold_build2 (NE_EXPR
, boolean_type_node
, l
,
4643 if (condition
== NULL_TREE
)
4646 condition
= fold_build2 (BIT_AND_EXPR
, boolean_type_node
,
4649 else if (size
== NULL_TREE
)
4651 size
= size_in_bytes (TREE_TYPE (types
[i
]));
4652 size
= size_binop (MULT_EXPR
, size
, l
);
4654 size
= fold_build3 (COND_EXPR
, sizetype
, condition
,
4655 size
, size_zero_node
);
4658 size
= size_binop (MULT_EXPR
, size
, l
);
4661 if (!processing_template_decl
)
4664 size
= build2 (COMPOUND_EXPR
, sizetype
, side_effects
, size
);
4665 OMP_CLAUSE_DECL (c
) = first
;
4666 OMP_CLAUSE_SIZE (c
) = size
;
4667 if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_MAP
)
4669 tree c2
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
4671 OMP_CLAUSE_SET_MAP_KIND (c2
, GOMP_MAP_POINTER
);
4672 if (!cxx_mark_addressable (t
))
4674 OMP_CLAUSE_DECL (c2
) = t
;
4675 t
= build_fold_addr_expr (first
);
4676 t
= fold_convert_loc (OMP_CLAUSE_LOCATION (c
),
4677 ptrdiff_type_node
, t
);
4678 tree ptr
= OMP_CLAUSE_DECL (c2
);
4679 ptr
= convert_from_reference (ptr
);
4680 if (!POINTER_TYPE_P (TREE_TYPE (ptr
)))
4681 ptr
= build_fold_addr_expr (ptr
);
4682 t
= fold_build2_loc (OMP_CLAUSE_LOCATION (c
), MINUS_EXPR
,
4683 ptrdiff_type_node
, t
,
4684 fold_convert_loc (OMP_CLAUSE_LOCATION (c
),
4685 ptrdiff_type_node
, ptr
));
4686 OMP_CLAUSE_SIZE (c2
) = t
;
4687 OMP_CLAUSE_CHAIN (c2
) = OMP_CLAUSE_CHAIN (c
);
4688 OMP_CLAUSE_CHAIN (c
) = c2
;
4689 ptr
= OMP_CLAUSE_DECL (c2
);
4690 if (TREE_CODE (TREE_TYPE (ptr
)) == REFERENCE_TYPE
4691 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (ptr
))))
4693 tree c3
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
4695 OMP_CLAUSE_SET_MAP_KIND (c3
, GOMP_MAP_POINTER
);
4696 OMP_CLAUSE_DECL (c3
) = ptr
;
4697 OMP_CLAUSE_DECL (c2
) = convert_from_reference (ptr
);
4698 OMP_CLAUSE_SIZE (c3
) = size_zero_node
;
4699 OMP_CLAUSE_CHAIN (c3
) = OMP_CLAUSE_CHAIN (c2
);
4700 OMP_CLAUSE_CHAIN (c2
) = c3
;
4707 /* Return identifier to look up for omp declare reduction. */
4710 omp_reduction_id (enum tree_code reduction_code
, tree reduction_id
, tree type
)
4712 const char *p
= NULL
;
4713 const char *m
= NULL
;
4714 switch (reduction_code
)
4722 case TRUTH_ANDIF_EXPR
:
4723 case TRUTH_ORIF_EXPR
:
4724 reduction_id
= ansi_opname (reduction_code
);
4738 if (TREE_CODE (reduction_id
) != IDENTIFIER_NODE
)
4739 return error_mark_node
;
4740 p
= IDENTIFIER_POINTER (reduction_id
);
4743 if (type
!= NULL_TREE
)
4744 m
= mangle_type_string (TYPE_MAIN_VARIANT (type
));
4746 const char prefix
[] = "omp declare reduction ";
4747 size_t lenp
= sizeof (prefix
);
4748 if (strncmp (p
, prefix
, lenp
- 1) == 0)
4750 size_t len
= strlen (p
);
4751 size_t lenm
= m
? strlen (m
) + 1 : 0;
4752 char *name
= XALLOCAVEC (char, lenp
+ len
+ lenm
);
4754 memcpy (name
, prefix
, lenp
- 1);
4755 memcpy (name
+ lenp
- 1, p
, len
+ 1);
4758 name
[lenp
+ len
- 1] = '~';
4759 memcpy (name
+ lenp
+ len
, m
, lenm
);
4761 return get_identifier (name
);
4764 /* Lookup OpenMP UDR ID for TYPE, return the corresponding artificial
4765 FUNCTION_DECL or NULL_TREE if not found. */
4768 omp_reduction_lookup (location_t loc
, tree id
, tree type
, tree
*baselinkp
,
4769 vec
<tree
> *ambiguousp
)
4772 tree baselink
= NULL_TREE
;
4773 if (identifier_p (id
))
4776 bool nonint_cst_expression_p
;
4777 const char *error_msg
;
4778 id
= omp_reduction_id (ERROR_MARK
, id
, type
);
4779 tree decl
= lookup_name (id
);
4780 if (decl
== NULL_TREE
)
4781 decl
= error_mark_node
;
4782 id
= finish_id_expression (id
, decl
, NULL_TREE
, &idk
, false, true,
4783 &nonint_cst_expression_p
, false, true, false,
4784 false, &error_msg
, loc
);
4785 if (idk
== CP_ID_KIND_UNQUALIFIED
4786 && identifier_p (id
))
4788 vec
<tree
, va_gc
> *args
= NULL
;
4789 vec_safe_push (args
, build_reference_type (type
));
4790 id
= perform_koenig_lookup (id
, args
, tf_none
);
4793 else if (TREE_CODE (id
) == SCOPE_REF
)
4794 id
= lookup_qualified_name (TREE_OPERAND (id
, 0),
4795 omp_reduction_id (ERROR_MARK
,
4796 TREE_OPERAND (id
, 1),
4800 if (id
&& is_overloaded_fn (id
))
4802 for (; id
; id
= OVL_NEXT (id
))
4804 tree fndecl
= OVL_CURRENT (id
);
4805 if (TREE_CODE (fndecl
) == FUNCTION_DECL
)
4807 tree argtype
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (fndecl
)));
4808 if (same_type_p (TREE_TYPE (argtype
), type
))
4812 if (id
&& BASELINK_P (fns
))
4819 if (id
== NULL_TREE
&& CLASS_TYPE_P (type
) && TYPE_BINFO (type
))
4821 vec
<tree
> ambiguous
= vNULL
;
4822 tree binfo
= TYPE_BINFO (type
), base_binfo
, ret
= NULL_TREE
;
4824 if (ambiguousp
== NULL
)
4825 ambiguousp
= &ambiguous
;
4826 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
4828 id
= omp_reduction_lookup (loc
, orig_id
, BINFO_TYPE (base_binfo
),
4829 baselinkp
? baselinkp
: &baselink
,
4831 if (id
== NULL_TREE
)
4833 if (!ambiguousp
->is_empty ())
4834 ambiguousp
->safe_push (id
);
4835 else if (ret
!= NULL_TREE
)
4837 ambiguousp
->safe_push (ret
);
4838 ambiguousp
->safe_push (id
);
4844 if (ambiguousp
!= &ambiguous
)
4846 if (!ambiguous
.is_empty ())
4848 const char *str
= _("candidates are:");
4851 error_at (loc
, "user defined reduction lookup is ambiguous");
4852 FOR_EACH_VEC_ELT (ambiguous
, idx
, udr
)
4854 inform (DECL_SOURCE_LOCATION (udr
), "%s %#D", str
, udr
);
4856 str
= get_spaces (str
);
4858 ambiguous
.release ();
4859 ret
= error_mark_node
;
4860 baselink
= NULL_TREE
;
4865 perform_or_defer_access_check (BASELINK_BINFO (baselink
),
4866 id
, id
, tf_warning_or_error
);
4870 /* Helper function for cp_parser_omp_declare_reduction_exprs
4872 Remove CLEANUP_STMT for data (omp_priv variable).
4873 Also append INIT_EXPR for DECL_INITIAL of omp_priv after its
4877 cp_remove_omp_priv_cleanup_stmt (tree
*tp
, int *walk_subtrees
, void *data
)
4881 else if (TREE_CODE (*tp
) == CLEANUP_STMT
&& CLEANUP_DECL (*tp
) == (tree
) data
)
4882 *tp
= CLEANUP_BODY (*tp
);
4883 else if (TREE_CODE (*tp
) == DECL_EXPR
)
4885 tree decl
= DECL_EXPR_DECL (*tp
);
4886 if (!processing_template_decl
4887 && decl
== (tree
) data
4888 && DECL_INITIAL (decl
)
4889 && DECL_INITIAL (decl
) != error_mark_node
)
4891 tree list
= NULL_TREE
;
4892 append_to_statement_list_force (*tp
, &list
);
4893 tree init_expr
= build2 (INIT_EXPR
, void_type_node
,
4894 decl
, DECL_INITIAL (decl
));
4895 DECL_INITIAL (decl
) = NULL_TREE
;
4896 append_to_statement_list_force (init_expr
, &list
);
4903 /* Data passed from cp_check_omp_declare_reduction to
4904 cp_check_omp_declare_reduction_r. */
4906 struct cp_check_omp_declare_reduction_data
4913 /* Helper function for cp_check_omp_declare_reduction, called via
4917 cp_check_omp_declare_reduction_r (tree
*tp
, int *, void *data
)
4919 struct cp_check_omp_declare_reduction_data
*udr_data
4920 = (struct cp_check_omp_declare_reduction_data
*) data
;
4922 && !DECL_ARTIFICIAL (*tp
)
4923 && *tp
!= DECL_EXPR_DECL (udr_data
->stmts
[udr_data
->combiner_p
? 0 : 3])
4924 && *tp
!= DECL_EXPR_DECL (udr_data
->stmts
[udr_data
->combiner_p
? 1 : 4]))
4926 location_t loc
= udr_data
->loc
;
4927 if (udr_data
->combiner_p
)
4928 error_at (loc
, "%<#pragma omp declare reduction%> combiner refers to "
4929 "variable %qD which is not %<omp_out%> nor %<omp_in%>",
4932 error_at (loc
, "%<#pragma omp declare reduction%> initializer refers "
4933 "to variable %qD which is not %<omp_priv%> nor "
4941 /* Diagnose violation of OpenMP #pragma omp declare reduction restrictions. */
4944 cp_check_omp_declare_reduction (tree udr
)
4946 tree type
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (udr
)));
4947 gcc_assert (TREE_CODE (type
) == REFERENCE_TYPE
);
4948 type
= TREE_TYPE (type
);
4950 location_t loc
= DECL_SOURCE_LOCATION (udr
);
4952 if (type
== error_mark_node
)
4954 if (ARITHMETIC_TYPE_P (type
))
4956 static enum tree_code predef_codes
[]
4957 = { PLUS_EXPR
, MULT_EXPR
, MINUS_EXPR
, BIT_AND_EXPR
, BIT_XOR_EXPR
,
4958 BIT_IOR_EXPR
, TRUTH_ANDIF_EXPR
, TRUTH_ORIF_EXPR
};
4959 for (i
= 0; i
< 8; i
++)
4961 tree id
= omp_reduction_id (predef_codes
[i
], NULL_TREE
, NULL_TREE
);
4962 const char *n1
= IDENTIFIER_POINTER (DECL_NAME (udr
));
4963 const char *n2
= IDENTIFIER_POINTER (id
);
4964 if (strncmp (n1
, n2
, IDENTIFIER_LENGTH (id
)) == 0
4965 && (n1
[IDENTIFIER_LENGTH (id
)] == '~'
4966 || n1
[IDENTIFIER_LENGTH (id
)] == '\0'))
4971 && TREE_CODE (type
) != COMPLEX_EXPR
)
4973 const char prefix_minmax
[] = "omp declare reduction m";
4974 size_t prefix_size
= sizeof (prefix_minmax
) - 1;
4975 const char *n
= IDENTIFIER_POINTER (DECL_NAME (udr
));
4976 if (strncmp (IDENTIFIER_POINTER (DECL_NAME (udr
)),
4977 prefix_minmax
, prefix_size
) == 0
4978 && ((n
[prefix_size
] == 'i' && n
[prefix_size
+ 1] == 'n')
4979 || (n
[prefix_size
] == 'a' && n
[prefix_size
+ 1] == 'x'))
4980 && (n
[prefix_size
+ 2] == '~' || n
[prefix_size
+ 2] == '\0'))
4985 error_at (loc
, "predeclared arithmetic type %qT in "
4986 "%<#pragma omp declare reduction%>", type
);
4990 else if (TREE_CODE (type
) == FUNCTION_TYPE
4991 || TREE_CODE (type
) == METHOD_TYPE
4992 || TREE_CODE (type
) == ARRAY_TYPE
)
4994 error_at (loc
, "function or array type %qT in "
4995 "%<#pragma omp declare reduction%>", type
);
4998 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
5000 error_at (loc
, "reference type %qT in %<#pragma omp declare reduction%>",
5004 else if (TYPE_QUALS_NO_ADDR_SPACE (type
))
5006 error_at (loc
, "const, volatile or __restrict qualified type %qT in "
5007 "%<#pragma omp declare reduction%>", type
);
5011 tree body
= DECL_SAVED_TREE (udr
);
5012 if (body
== NULL_TREE
|| TREE_CODE (body
) != STATEMENT_LIST
)
5015 tree_stmt_iterator tsi
;
5016 struct cp_check_omp_declare_reduction_data data
;
5017 memset (data
.stmts
, 0, sizeof data
.stmts
);
5018 for (i
= 0, tsi
= tsi_start (body
);
5019 i
< 7 && !tsi_end_p (tsi
);
5020 i
++, tsi_next (&tsi
))
5021 data
.stmts
[i
] = tsi_stmt (tsi
);
5023 gcc_assert (tsi_end_p (tsi
));
5026 gcc_assert (TREE_CODE (data
.stmts
[0]) == DECL_EXPR
5027 && TREE_CODE (data
.stmts
[1]) == DECL_EXPR
);
5028 if (TREE_NO_WARNING (DECL_EXPR_DECL (data
.stmts
[0])))
5030 data
.combiner_p
= true;
5031 if (cp_walk_tree (&data
.stmts
[2], cp_check_omp_declare_reduction_r
,
5033 TREE_NO_WARNING (DECL_EXPR_DECL (data
.stmts
[0])) = 1;
5037 gcc_assert (TREE_CODE (data
.stmts
[3]) == DECL_EXPR
5038 && TREE_CODE (data
.stmts
[4]) == DECL_EXPR
);
5039 data
.combiner_p
= false;
5040 if (cp_walk_tree (&data
.stmts
[5], cp_check_omp_declare_reduction_r
,
5042 || cp_walk_tree (&DECL_INITIAL (DECL_EXPR_DECL (data
.stmts
[3])),
5043 cp_check_omp_declare_reduction_r
, &data
, NULL
))
5044 TREE_NO_WARNING (DECL_EXPR_DECL (data
.stmts
[0])) = 1;
5046 gcc_assert (TREE_CODE (data
.stmts
[6]) == DECL_EXPR
);
5050 /* Helper function of finish_omp_clauses. Clone STMT as if we were making
5051 an inline call. But, remap
5052 the OMP_DECL1 VAR_DECL (omp_out resp. omp_orig) to PLACEHOLDER
5053 and OMP_DECL2 VAR_DECL (omp_in resp. omp_priv) to DECL. */
5056 clone_omp_udr (tree stmt
, tree omp_decl1
, tree omp_decl2
,
5057 tree decl
, tree placeholder
)
5060 hash_map
<tree
, tree
> decl_map
;
5062 decl_map
.put (omp_decl1
, placeholder
);
5063 decl_map
.put (omp_decl2
, decl
);
5064 memset (&id
, 0, sizeof (id
));
5065 id
.src_fn
= DECL_CONTEXT (omp_decl1
);
5066 id
.dst_fn
= current_function_decl
;
5067 id
.src_cfun
= DECL_STRUCT_FUNCTION (id
.src_fn
);
5068 id
.decl_map
= &decl_map
;
5070 id
.copy_decl
= copy_decl_no_change
;
5071 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
5072 id
.transform_new_cfg
= true;
5073 id
.transform_return_to_modify
= false;
5074 id
.transform_lang_insert_block
= NULL
;
5076 walk_tree (&stmt
, copy_tree_body_r
, &id
, NULL
);
5080 /* Helper function of finish_omp_clauses, called via cp_walk_tree.
5081 Find OMP_CLAUSE_PLACEHOLDER (passed in DATA) in *TP. */
5084 find_omp_placeholder_r (tree
*tp
, int *, void *data
)
5086 if (*tp
== (tree
) data
)
5091 /* Helper function of finish_omp_clauses. Handle OMP_CLAUSE_REDUCTION C.
5092 Return true if there is some error and the clause should be removed. */
5095 finish_omp_reduction_clause (tree c
, bool *need_default_ctor
, bool *need_dtor
)
5097 tree t
= OMP_CLAUSE_DECL (c
);
5098 bool predefined
= false;
5099 tree type
= TREE_TYPE (t
);
5100 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5101 type
= TREE_TYPE (type
);
5102 if (type
== error_mark_node
)
5104 else if (ARITHMETIC_TYPE_P (type
))
5105 switch (OMP_CLAUSE_REDUCTION_CODE (c
))
5114 if (TREE_CODE (type
) == COMPLEX_TYPE
)
5121 if (FLOAT_TYPE_P (type
) || TREE_CODE (type
) == COMPLEX_TYPE
)
5125 case TRUTH_ANDIF_EXPR
:
5126 case TRUTH_ORIF_EXPR
:
5127 if (FLOAT_TYPE_P (type
))
5134 else if (TREE_CODE (type
) == ARRAY_TYPE
|| TYPE_READONLY (type
))
5136 error ("%qE has invalid type for %<reduction%>", t
);
5139 else if (!processing_template_decl
)
5141 t
= require_complete_type (t
);
5142 if (t
== error_mark_node
)
5144 OMP_CLAUSE_DECL (c
) = t
;
5149 OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
) = NULL_TREE
;
5152 else if (processing_template_decl
)
5155 tree id
= OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
);
5157 type
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
5158 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5159 type
= TREE_TYPE (type
);
5160 OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
) = NULL_TREE
;
5161 if (id
== NULL_TREE
)
5162 id
= omp_reduction_id (OMP_CLAUSE_REDUCTION_CODE (c
),
5163 NULL_TREE
, NULL_TREE
);
5164 id
= omp_reduction_lookup (OMP_CLAUSE_LOCATION (c
), id
, type
, NULL
, NULL
);
5167 if (id
== error_mark_node
)
5169 id
= OVL_CURRENT (id
);
5171 tree body
= DECL_SAVED_TREE (id
);
5174 if (TREE_CODE (body
) == STATEMENT_LIST
)
5176 tree_stmt_iterator tsi
;
5177 tree placeholder
= NULL_TREE
;
5180 tree atype
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (id
)));
5181 atype
= TREE_TYPE (atype
);
5182 bool need_static_cast
= !same_type_p (type
, atype
);
5183 memset (stmts
, 0, sizeof stmts
);
5184 for (i
= 0, tsi
= tsi_start (body
);
5185 i
< 7 && !tsi_end_p (tsi
);
5186 i
++, tsi_next (&tsi
))
5187 stmts
[i
] = tsi_stmt (tsi
);
5188 gcc_assert (tsi_end_p (tsi
));
5192 gcc_assert (TREE_CODE (stmts
[0]) == DECL_EXPR
5193 && TREE_CODE (stmts
[1]) == DECL_EXPR
);
5194 placeholder
= build_lang_decl (VAR_DECL
, NULL_TREE
, type
);
5195 DECL_ARTIFICIAL (placeholder
) = 1;
5196 DECL_IGNORED_P (placeholder
) = 1;
5197 OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
) = placeholder
;
5198 if (TREE_ADDRESSABLE (DECL_EXPR_DECL (stmts
[0])))
5199 cxx_mark_addressable (placeholder
);
5200 if (TREE_ADDRESSABLE (DECL_EXPR_DECL (stmts
[1]))
5201 && TREE_CODE (TREE_TYPE (OMP_CLAUSE_DECL (c
)))
5203 cxx_mark_addressable (OMP_CLAUSE_DECL (c
));
5204 tree omp_out
= placeholder
;
5205 tree omp_in
= convert_from_reference (OMP_CLAUSE_DECL (c
));
5206 if (need_static_cast
)
5208 tree rtype
= build_reference_type (atype
);
5209 omp_out
= build_static_cast (rtype
, omp_out
,
5210 tf_warning_or_error
);
5211 omp_in
= build_static_cast (rtype
, omp_in
,
5212 tf_warning_or_error
);
5213 if (omp_out
== error_mark_node
|| omp_in
== error_mark_node
)
5215 omp_out
= convert_from_reference (omp_out
);
5216 omp_in
= convert_from_reference (omp_in
);
5218 OMP_CLAUSE_REDUCTION_MERGE (c
)
5219 = clone_omp_udr (stmts
[2], DECL_EXPR_DECL (stmts
[0]),
5220 DECL_EXPR_DECL (stmts
[1]), omp_in
, omp_out
);
5224 gcc_assert (TREE_CODE (stmts
[3]) == DECL_EXPR
5225 && TREE_CODE (stmts
[4]) == DECL_EXPR
);
5226 if (TREE_ADDRESSABLE (DECL_EXPR_DECL (stmts
[3])))
5227 cxx_mark_addressable (OMP_CLAUSE_DECL (c
));
5228 if (TREE_ADDRESSABLE (DECL_EXPR_DECL (stmts
[4])))
5229 cxx_mark_addressable (placeholder
);
5230 tree omp_priv
= convert_from_reference (OMP_CLAUSE_DECL (c
));
5231 tree omp_orig
= placeholder
;
5232 if (need_static_cast
)
5236 error_at (OMP_CLAUSE_LOCATION (c
),
5237 "user defined reduction with constructor "
5238 "initializer for base class %qT", atype
);
5241 tree rtype
= build_reference_type (atype
);
5242 omp_priv
= build_static_cast (rtype
, omp_priv
,
5243 tf_warning_or_error
);
5244 omp_orig
= build_static_cast (rtype
, omp_orig
,
5245 tf_warning_or_error
);
5246 if (omp_priv
== error_mark_node
5247 || omp_orig
== error_mark_node
)
5249 omp_priv
= convert_from_reference (omp_priv
);
5250 omp_orig
= convert_from_reference (omp_orig
);
5253 *need_default_ctor
= true;
5254 OMP_CLAUSE_REDUCTION_INIT (c
)
5255 = clone_omp_udr (stmts
[5], DECL_EXPR_DECL (stmts
[4]),
5256 DECL_EXPR_DECL (stmts
[3]),
5257 omp_priv
, omp_orig
);
5258 if (cp_walk_tree (&OMP_CLAUSE_REDUCTION_INIT (c
),
5259 find_omp_placeholder_r
, placeholder
, NULL
))
5260 OMP_CLAUSE_REDUCTION_OMP_ORIG_REF (c
) = 1;
5264 if (CLASS_TYPE_P (type
) && !pod_type_p (type
))
5265 *need_default_ctor
= true;
5269 tree v
= convert_from_reference (t
);
5270 if (AGGREGATE_TYPE_P (TREE_TYPE (v
)))
5271 init
= build_constructor (TREE_TYPE (v
), NULL
);
5273 init
= fold_convert (TREE_TYPE (v
), integer_zero_node
);
5274 OMP_CLAUSE_REDUCTION_INIT (c
)
5275 = build2 (INIT_EXPR
, TREE_TYPE (v
), v
, init
);
5280 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
))
5284 error ("user defined reduction not found for %qD", t
);
5290 /* For all elements of CLAUSES, validate them vs OpenMP constraints.
5291 Remove any elements from the list that are invalid. */
5294 finish_omp_clauses (tree clauses
)
5296 bitmap_head generic_head
, firstprivate_head
, lastprivate_head
;
5297 bitmap_head aligned_head
;
5299 bool branch_seen
= false;
5300 bool copyprivate_seen
= false;
5302 bitmap_obstack_initialize (NULL
);
5303 bitmap_initialize (&generic_head
, &bitmap_default_obstack
);
5304 bitmap_initialize (&firstprivate_head
, &bitmap_default_obstack
);
5305 bitmap_initialize (&lastprivate_head
, &bitmap_default_obstack
);
5306 bitmap_initialize (&aligned_head
, &bitmap_default_obstack
);
5308 for (pc
= &clauses
, c
= clauses
; c
; c
= *pc
)
5310 bool remove
= false;
5312 switch (OMP_CLAUSE_CODE (c
))
5314 case OMP_CLAUSE_SHARED
:
5315 goto check_dup_generic
;
5316 case OMP_CLAUSE_PRIVATE
:
5317 goto check_dup_generic
;
5318 case OMP_CLAUSE_REDUCTION
:
5319 goto check_dup_generic
;
5320 case OMP_CLAUSE_COPYPRIVATE
:
5321 copyprivate_seen
= true;
5322 goto check_dup_generic
;
5323 case OMP_CLAUSE_COPYIN
:
5324 goto check_dup_generic
;
5325 case OMP_CLAUSE_LINEAR
:
5326 t
= OMP_CLAUSE_DECL (c
);
5327 if (!type_dependent_expression_p (t
)
5328 && !INTEGRAL_TYPE_P (TREE_TYPE (t
))
5329 && TREE_CODE (TREE_TYPE (t
)) != POINTER_TYPE
)
5331 error ("linear clause applied to non-integral non-pointer "
5332 "variable with %qT type", TREE_TYPE (t
));
5336 t
= OMP_CLAUSE_LINEAR_STEP (c
);
5338 t
= integer_one_node
;
5339 if (t
== error_mark_node
)
5344 else if (!type_dependent_expression_p (t
)
5345 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
5347 error ("linear step expression must be integral");
5353 t
= mark_rvalue_use (t
);
5354 if (!processing_template_decl
)
5356 if (TREE_CODE (OMP_CLAUSE_DECL (c
)) == PARM_DECL
)
5357 t
= maybe_constant_value (t
);
5358 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
5359 if (TREE_CODE (TREE_TYPE (OMP_CLAUSE_DECL (c
)))
5362 t
= pointer_int_sum (OMP_CLAUSE_LOCATION (c
), PLUS_EXPR
,
5363 OMP_CLAUSE_DECL (c
), t
);
5364 t
= fold_build2_loc (OMP_CLAUSE_LOCATION (c
),
5365 MINUS_EXPR
, sizetype
, t
,
5366 OMP_CLAUSE_DECL (c
));
5367 if (t
== error_mark_node
)
5374 t
= fold_convert (TREE_TYPE (OMP_CLAUSE_DECL (c
)), t
);
5376 OMP_CLAUSE_LINEAR_STEP (c
) = t
;
5378 goto check_dup_generic
;
5380 t
= OMP_CLAUSE_DECL (c
);
5381 if (!VAR_P (t
) && TREE_CODE (t
) != PARM_DECL
)
5383 if (processing_template_decl
)
5386 error ("%qD is not a variable in clause %qs", t
,
5387 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
5389 error ("%qE is not a variable in clause %qs", t
,
5390 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
5393 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
5394 || bitmap_bit_p (&firstprivate_head
, DECL_UID (t
))
5395 || bitmap_bit_p (&lastprivate_head
, DECL_UID (t
)))
5397 error ("%qD appears more than once in data clauses", t
);
5401 bitmap_set_bit (&generic_head
, DECL_UID (t
));
5404 case OMP_CLAUSE_FIRSTPRIVATE
:
5405 t
= OMP_CLAUSE_DECL (c
);
5406 if (!VAR_P (t
) && TREE_CODE (t
) != PARM_DECL
)
5408 if (processing_template_decl
)
5411 error ("%qD is not a variable in clause %<firstprivate%>", t
);
5413 error ("%qE is not a variable in clause %<firstprivate%>", t
);
5416 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
5417 || bitmap_bit_p (&firstprivate_head
, DECL_UID (t
)))
5419 error ("%qD appears more than once in data clauses", t
);
5423 bitmap_set_bit (&firstprivate_head
, DECL_UID (t
));
5426 case OMP_CLAUSE_LASTPRIVATE
:
5427 t
= OMP_CLAUSE_DECL (c
);
5428 if (!VAR_P (t
) && TREE_CODE (t
) != PARM_DECL
)
5430 if (processing_template_decl
)
5433 error ("%qD is not a variable in clause %<lastprivate%>", t
);
5435 error ("%qE is not a variable in clause %<lastprivate%>", t
);
5438 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
5439 || bitmap_bit_p (&lastprivate_head
, DECL_UID (t
)))
5441 error ("%qD appears more than once in data clauses", t
);
5445 bitmap_set_bit (&lastprivate_head
, DECL_UID (t
));
5449 t
= OMP_CLAUSE_IF_EXPR (c
);
5450 t
= maybe_convert_cond (t
);
5451 if (t
== error_mark_node
)
5453 else if (!processing_template_decl
)
5454 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
5455 OMP_CLAUSE_IF_EXPR (c
) = t
;
5458 case OMP_CLAUSE_FINAL
:
5459 t
= OMP_CLAUSE_FINAL_EXPR (c
);
5460 t
= maybe_convert_cond (t
);
5461 if (t
== error_mark_node
)
5463 else if (!processing_template_decl
)
5464 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
5465 OMP_CLAUSE_FINAL_EXPR (c
) = t
;
5468 case OMP_CLAUSE_NUM_THREADS
:
5469 t
= OMP_CLAUSE_NUM_THREADS_EXPR (c
);
5470 if (t
== error_mark_node
)
5472 else if (!type_dependent_expression_p (t
)
5473 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
5475 error ("num_threads expression must be integral");
5480 t
= mark_rvalue_use (t
);
5481 if (!processing_template_decl
)
5482 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
5483 OMP_CLAUSE_NUM_THREADS_EXPR (c
) = t
;
5487 case OMP_CLAUSE_SCHEDULE
:
5488 t
= OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c
);
5491 else if (t
== error_mark_node
)
5493 else if (!type_dependent_expression_p (t
)
5494 && (OMP_CLAUSE_SCHEDULE_KIND (c
)
5495 != OMP_CLAUSE_SCHEDULE_CILKFOR
)
5496 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
5498 error ("schedule chunk size expression must be integral");
5503 t
= mark_rvalue_use (t
);
5504 if (!processing_template_decl
)
5506 if (OMP_CLAUSE_SCHEDULE_KIND (c
)
5507 == OMP_CLAUSE_SCHEDULE_CILKFOR
)
5509 t
= convert_to_integer (long_integer_type_node
, t
);
5510 if (t
== error_mark_node
)
5516 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
5518 OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c
) = t
;
5522 case OMP_CLAUSE_SIMDLEN
:
5523 case OMP_CLAUSE_SAFELEN
:
5524 t
= OMP_CLAUSE_OPERAND (c
, 0);
5525 if (t
== error_mark_node
)
5527 else if (!type_dependent_expression_p (t
)
5528 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
5530 error ("%qs length expression must be integral",
5531 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
5536 t
= mark_rvalue_use (t
);
5537 t
= maybe_constant_value (t
);
5538 if (!processing_template_decl
)
5540 if (TREE_CODE (t
) != INTEGER_CST
5541 || tree_int_cst_sgn (t
) != 1)
5543 error ("%qs length expression must be positive constant"
5544 " integer expression",
5545 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
5549 OMP_CLAUSE_OPERAND (c
, 0) = t
;
5553 case OMP_CLAUSE_NUM_TEAMS
:
5554 t
= OMP_CLAUSE_NUM_TEAMS_EXPR (c
);
5555 if (t
== error_mark_node
)
5557 else if (!type_dependent_expression_p (t
)
5558 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
5560 error ("%<num_teams%> expression must be integral");
5565 t
= mark_rvalue_use (t
);
5566 if (!processing_template_decl
)
5567 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
5568 OMP_CLAUSE_NUM_TEAMS_EXPR (c
) = t
;
5572 case OMP_CLAUSE_ASYNC
:
5573 t
= OMP_CLAUSE_ASYNC_EXPR (c
);
5574 if (t
== error_mark_node
)
5576 else if (!type_dependent_expression_p (t
)
5577 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
5579 error ("%<async%> expression must be integral");
5584 t
= mark_rvalue_use (t
);
5585 if (!processing_template_decl
)
5586 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
5587 OMP_CLAUSE_ASYNC_EXPR (c
) = t
;
5591 case OMP_CLAUSE_VECTOR_LENGTH
:
5592 t
= OMP_CLAUSE_VECTOR_LENGTH_EXPR (c
);
5593 t
= maybe_convert_cond (t
);
5594 if (t
== error_mark_node
)
5596 else if (!processing_template_decl
)
5597 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
5598 OMP_CLAUSE_VECTOR_LENGTH_EXPR (c
) = t
;
5601 case OMP_CLAUSE_WAIT
:
5602 t
= OMP_CLAUSE_WAIT_EXPR (c
);
5603 if (t
== error_mark_node
)
5605 else if (!processing_template_decl
)
5606 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
5607 OMP_CLAUSE_WAIT_EXPR (c
) = t
;
5610 case OMP_CLAUSE_THREAD_LIMIT
:
5611 t
= OMP_CLAUSE_THREAD_LIMIT_EXPR (c
);
5612 if (t
== error_mark_node
)
5614 else if (!type_dependent_expression_p (t
)
5615 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
5617 error ("%<thread_limit%> expression must be integral");
5622 t
= mark_rvalue_use (t
);
5623 if (!processing_template_decl
)
5624 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
5625 OMP_CLAUSE_THREAD_LIMIT_EXPR (c
) = t
;
5629 case OMP_CLAUSE_DEVICE
:
5630 t
= OMP_CLAUSE_DEVICE_ID (c
);
5631 if (t
== error_mark_node
)
5633 else if (!type_dependent_expression_p (t
)
5634 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
5636 error ("%<device%> id must be integral");
5641 t
= mark_rvalue_use (t
);
5642 if (!processing_template_decl
)
5643 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
5644 OMP_CLAUSE_DEVICE_ID (c
) = t
;
5648 case OMP_CLAUSE_DIST_SCHEDULE
:
5649 t
= OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (c
);
5652 else if (t
== error_mark_node
)
5654 else if (!type_dependent_expression_p (t
)
5655 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
5657 error ("%<dist_schedule%> chunk size expression must be "
5663 t
= mark_rvalue_use (t
);
5664 if (!processing_template_decl
)
5665 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
5666 OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (c
) = t
;
5670 case OMP_CLAUSE_ALIGNED
:
5671 t
= OMP_CLAUSE_DECL (c
);
5672 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
5674 if (processing_template_decl
)
5677 error ("%qD is not a variable in %<aligned%> clause", t
);
5679 error ("%qE is not a variable in %<aligned%> clause", t
);
5682 else if (!type_dependent_expression_p (t
)
5683 && TREE_CODE (TREE_TYPE (t
)) != POINTER_TYPE
5684 && TREE_CODE (TREE_TYPE (t
)) != ARRAY_TYPE
5685 && (TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
5686 || (!POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (t
)))
5687 && (TREE_CODE (TREE_TYPE (TREE_TYPE (t
)))
5690 error_at (OMP_CLAUSE_LOCATION (c
),
5691 "%qE in %<aligned%> clause is neither a pointer nor "
5692 "an array nor a reference to pointer or array", t
);
5695 else if (bitmap_bit_p (&aligned_head
, DECL_UID (t
)))
5697 error ("%qD appears more than once in %<aligned%> clauses", t
);
5701 bitmap_set_bit (&aligned_head
, DECL_UID (t
));
5702 t
= OMP_CLAUSE_ALIGNED_ALIGNMENT (c
);
5703 if (t
== error_mark_node
)
5705 else if (t
== NULL_TREE
)
5707 else if (!type_dependent_expression_p (t
)
5708 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
5710 error ("%<aligned%> clause alignment expression must "
5716 t
= mark_rvalue_use (t
);
5717 t
= maybe_constant_value (t
);
5718 if (!processing_template_decl
)
5720 if (TREE_CODE (t
) != INTEGER_CST
5721 || tree_int_cst_sgn (t
) != 1)
5723 error ("%<aligned%> clause alignment expression must be "
5724 "positive constant integer expression");
5728 OMP_CLAUSE_ALIGNED_ALIGNMENT (c
) = t
;
5732 case OMP_CLAUSE_DEPEND
:
5733 t
= OMP_CLAUSE_DECL (c
);
5734 if (TREE_CODE (t
) == TREE_LIST
)
5736 if (handle_omp_array_sections (c
))
5740 if (t
== error_mark_node
)
5742 else if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
5744 if (processing_template_decl
)
5747 error ("%qD is not a variable in %<depend%> clause", t
);
5749 error ("%qE is not a variable in %<depend%> clause", t
);
5752 else if (!processing_template_decl
5753 && !cxx_mark_addressable (t
))
5757 case OMP_CLAUSE_MAP
:
5759 case OMP_CLAUSE_FROM
:
5760 case OMP_CLAUSE__CACHE_
:
5761 t
= OMP_CLAUSE_DECL (c
);
5762 if (TREE_CODE (t
) == TREE_LIST
)
5764 if (handle_omp_array_sections (c
))
5768 t
= OMP_CLAUSE_DECL (c
);
5769 if (TREE_CODE (t
) != TREE_LIST
5770 && !type_dependent_expression_p (t
)
5771 && !cp_omp_mappable_type (TREE_TYPE (t
)))
5773 error_at (OMP_CLAUSE_LOCATION (c
),
5774 "array section does not have mappable type "
5776 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
5782 if (t
== error_mark_node
)
5784 else if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
5786 if (processing_template_decl
)
5788 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_MAP
5789 && OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_POINTER
)
5792 error ("%qD is not a variable in %qs clause", t
,
5793 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
5795 error ("%qE is not a variable in %qs clause", t
,
5796 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
5799 else if (TREE_CODE (t
) == VAR_DECL
&& DECL_THREAD_LOCAL_P (t
))
5801 error ("%qD is threadprivate variable in %qs clause", t
,
5802 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
5805 else if (!processing_template_decl
5806 && TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
5807 && !cxx_mark_addressable (t
))
5809 else if (!(OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_MAP
5810 && OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_POINTER
)
5811 && !type_dependent_expression_p (t
)
5812 && !cp_omp_mappable_type ((TREE_CODE (TREE_TYPE (t
))
5814 ? TREE_TYPE (TREE_TYPE (t
))
5817 error_at (OMP_CLAUSE_LOCATION (c
),
5818 "%qD does not have a mappable type in %qs clause", t
,
5819 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
5822 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
)))
5824 if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_MAP
)
5825 error ("%qD appears more than once in motion clauses", t
);
5827 error ("%qD appears more than once in map clauses", t
);
5831 bitmap_set_bit (&generic_head
, DECL_UID (t
));
5834 case OMP_CLAUSE_UNIFORM
:
5835 t
= OMP_CLAUSE_DECL (c
);
5836 if (TREE_CODE (t
) != PARM_DECL
)
5838 if (processing_template_decl
)
5841 error ("%qD is not an argument in %<uniform%> clause", t
);
5843 error ("%qE is not an argument in %<uniform%> clause", t
);
5847 goto check_dup_generic
;
5849 case OMP_CLAUSE_NOWAIT
:
5850 case OMP_CLAUSE_ORDERED
:
5851 case OMP_CLAUSE_DEFAULT
:
5852 case OMP_CLAUSE_UNTIED
:
5853 case OMP_CLAUSE_COLLAPSE
:
5854 case OMP_CLAUSE_MERGEABLE
:
5855 case OMP_CLAUSE_PARALLEL
:
5856 case OMP_CLAUSE_FOR
:
5857 case OMP_CLAUSE_SECTIONS
:
5858 case OMP_CLAUSE_TASKGROUP
:
5859 case OMP_CLAUSE_PROC_BIND
:
5860 case OMP_CLAUSE__CILK_FOR_COUNT_
:
5863 case OMP_CLAUSE_INBRANCH
:
5864 case OMP_CLAUSE_NOTINBRANCH
:
5867 error ("%<inbranch%> clause is incompatible with "
5879 *pc
= OMP_CLAUSE_CHAIN (c
);
5881 pc
= &OMP_CLAUSE_CHAIN (c
);
5884 for (pc
= &clauses
, c
= clauses
; c
; c
= *pc
)
5886 enum omp_clause_code c_kind
= OMP_CLAUSE_CODE (c
);
5887 bool remove
= false;
5888 bool need_complete_non_reference
= false;
5889 bool need_default_ctor
= false;
5890 bool need_copy_ctor
= false;
5891 bool need_copy_assignment
= false;
5892 bool need_implicitly_determined
= false;
5893 bool need_dtor
= false;
5894 tree type
, inner_type
;
5898 case OMP_CLAUSE_SHARED
:
5899 need_implicitly_determined
= true;
5901 case OMP_CLAUSE_PRIVATE
:
5902 need_complete_non_reference
= true;
5903 need_default_ctor
= true;
5905 need_implicitly_determined
= true;
5907 case OMP_CLAUSE_FIRSTPRIVATE
:
5908 need_complete_non_reference
= true;
5909 need_copy_ctor
= true;
5911 need_implicitly_determined
= true;
5913 case OMP_CLAUSE_LASTPRIVATE
:
5914 need_complete_non_reference
= true;
5915 need_copy_assignment
= true;
5916 need_implicitly_determined
= true;
5918 case OMP_CLAUSE_REDUCTION
:
5919 need_implicitly_determined
= true;
5921 case OMP_CLAUSE_COPYPRIVATE
:
5922 need_copy_assignment
= true;
5924 case OMP_CLAUSE_COPYIN
:
5925 need_copy_assignment
= true;
5927 case OMP_CLAUSE_NOWAIT
:
5928 if (copyprivate_seen
)
5930 error_at (OMP_CLAUSE_LOCATION (c
),
5931 "%<nowait%> clause must not be used together "
5932 "with %<copyprivate%>");
5933 *pc
= OMP_CLAUSE_CHAIN (c
);
5938 pc
= &OMP_CLAUSE_CHAIN (c
);
5942 t
= OMP_CLAUSE_DECL (c
);
5943 if (processing_template_decl
5944 && !VAR_P (t
) && TREE_CODE (t
) != PARM_DECL
)
5946 pc
= &OMP_CLAUSE_CHAIN (c
);
5952 case OMP_CLAUSE_LASTPRIVATE
:
5953 if (!bitmap_bit_p (&firstprivate_head
, DECL_UID (t
)))
5955 need_default_ctor
= true;
5960 case OMP_CLAUSE_REDUCTION
:
5961 if (finish_omp_reduction_clause (c
, &need_default_ctor
,
5965 t
= OMP_CLAUSE_DECL (c
);
5968 case OMP_CLAUSE_COPYIN
:
5969 if (!VAR_P (t
) || !DECL_THREAD_LOCAL_P (t
))
5971 error ("%qE must be %<threadprivate%> for %<copyin%>", t
);
5980 if (need_complete_non_reference
|| need_copy_assignment
)
5982 t
= require_complete_type (t
);
5983 if (t
== error_mark_node
)
5985 else if (TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
5986 && need_complete_non_reference
)
5988 error ("%qE has reference type for %qs", t
,
5989 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
5993 if (need_implicitly_determined
)
5995 const char *share_name
= NULL
;
5997 if (VAR_P (t
) && DECL_THREAD_LOCAL_P (t
))
5998 share_name
= "threadprivate";
5999 else switch (cxx_omp_predetermined_sharing (t
))
6001 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
6003 case OMP_CLAUSE_DEFAULT_SHARED
:
6004 /* const vars may be specified in firstprivate clause. */
6005 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
6006 && cxx_omp_const_qual_no_mutable (t
))
6008 share_name
= "shared";
6010 case OMP_CLAUSE_DEFAULT_PRIVATE
:
6011 share_name
= "private";
6018 error ("%qE is predetermined %qs for %qs",
6019 t
, share_name
, omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
6024 /* We're interested in the base element, not arrays. */
6025 inner_type
= type
= TREE_TYPE (t
);
6026 while (TREE_CODE (inner_type
) == ARRAY_TYPE
)
6027 inner_type
= TREE_TYPE (inner_type
);
6029 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
6030 && TREE_CODE (inner_type
) == REFERENCE_TYPE
)
6031 inner_type
= TREE_TYPE (inner_type
);
6033 /* Check for special function availability by building a call to one.
6034 Save the results, because later we won't be in the right context
6035 for making these queries. */
6036 if (CLASS_TYPE_P (inner_type
)
6037 && COMPLETE_TYPE_P (inner_type
)
6038 && (need_default_ctor
|| need_copy_ctor
6039 || need_copy_assignment
|| need_dtor
)
6040 && !type_dependent_expression_p (t
)
6041 && cxx_omp_create_clause_info (c
, inner_type
, need_default_ctor
,
6042 need_copy_ctor
, need_copy_assignment
,
6047 *pc
= OMP_CLAUSE_CHAIN (c
);
6049 pc
= &OMP_CLAUSE_CHAIN (c
);
6052 bitmap_obstack_release (NULL
);
6056 /* For all variables in the tree_list VARS, mark them as thread local. */
6059 finish_omp_threadprivate (tree vars
)
6063 /* Mark every variable in VARS to be assigned thread local storage. */
6064 for (t
= vars
; t
; t
= TREE_CHAIN (t
))
6066 tree v
= TREE_PURPOSE (t
);
6068 if (error_operand_p (v
))
6070 else if (!VAR_P (v
))
6071 error ("%<threadprivate%> %qD is not file, namespace "
6072 "or block scope variable", v
);
6073 /* If V had already been marked threadprivate, it doesn't matter
6074 whether it had been used prior to this point. */
6075 else if (TREE_USED (v
)
6076 && (DECL_LANG_SPECIFIC (v
) == NULL
6077 || !CP_DECL_THREADPRIVATE_P (v
)))
6078 error ("%qE declared %<threadprivate%> after first use", v
);
6079 else if (! TREE_STATIC (v
) && ! DECL_EXTERNAL (v
))
6080 error ("automatic variable %qE cannot be %<threadprivate%>", v
);
6081 else if (! COMPLETE_TYPE_P (complete_type (TREE_TYPE (v
))))
6082 error ("%<threadprivate%> %qE has incomplete type", v
);
6083 else if (TREE_STATIC (v
) && TYPE_P (CP_DECL_CONTEXT (v
))
6084 && CP_DECL_CONTEXT (v
) != current_class_type
)
6085 error ("%<threadprivate%> %qE directive not "
6086 "in %qT definition", v
, CP_DECL_CONTEXT (v
));
6089 /* Allocate a LANG_SPECIFIC structure for V, if needed. */
6090 if (DECL_LANG_SPECIFIC (v
) == NULL
)
6092 retrofit_lang_decl (v
);
6094 /* Make sure that DECL_DISCRIMINATOR_P continues to be true
6095 after the allocation of the lang_decl structure. */
6096 if (DECL_DISCRIMINATOR_P (v
))
6097 DECL_LANG_SPECIFIC (v
)->u
.base
.u2sel
= 1;
6100 if (! DECL_THREAD_LOCAL_P (v
))
6102 set_decl_tls_model (v
, decl_default_tls_model (v
));
6103 /* If rtl has been already set for this var, call
6104 make_decl_rtl once again, so that encode_section_info
6105 has a chance to look at the new decl flags. */
6106 if (DECL_RTL_SET_P (v
))
6109 CP_DECL_THREADPRIVATE_P (v
) = 1;
6114 /* Build an OpenMP structured block. */
6117 begin_omp_structured_block (void)
6119 return do_pushlevel (sk_omp
);
6123 finish_omp_structured_block (tree block
)
6125 return do_poplevel (block
);
6128 /* Generate OACC_DATA, with CLAUSES and BLOCK as its compound
6129 statement. LOC is the location of the OACC_DATA. */
6132 finish_oacc_data (tree clauses
, tree block
)
6136 block
= finish_omp_structured_block (block
);
6138 stmt
= make_node (OACC_DATA
);
6139 TREE_TYPE (stmt
) = void_type_node
;
6140 OACC_DATA_CLAUSES (stmt
) = clauses
;
6141 OACC_DATA_BODY (stmt
) = block
;
6143 return add_stmt (stmt
);
6146 /* Generate OACC_KERNELS, with CLAUSES and BLOCK as its compound
6147 statement. LOC is the location of the OACC_KERNELS. */
6150 finish_oacc_kernels (tree clauses
, tree block
)
6154 block
= finish_omp_structured_block (block
);
6156 stmt
= make_node (OACC_KERNELS
);
6157 TREE_TYPE (stmt
) = void_type_node
;
6158 OACC_KERNELS_CLAUSES (stmt
) = clauses
;
6159 OACC_KERNELS_BODY (stmt
) = block
;
6161 return add_stmt (stmt
);
6164 /* Generate OACC_PARALLEL, with CLAUSES and BLOCK as its compound
6165 statement. LOC is the location of the OACC_PARALLEL. */
6168 finish_oacc_parallel (tree clauses
, tree block
)
6172 block
= finish_omp_structured_block (block
);
6174 stmt
= make_node (OACC_PARALLEL
);
6175 TREE_TYPE (stmt
) = void_type_node
;
6176 OACC_PARALLEL_CLAUSES (stmt
) = clauses
;
6177 OACC_PARALLEL_BODY (stmt
) = block
;
6179 return add_stmt (stmt
);
6182 /* Similarly, except force the retention of the BLOCK. */
6185 begin_omp_parallel (void)
6187 keep_next_level (true);
6188 return begin_omp_structured_block ();
6192 finish_omp_parallel (tree clauses
, tree body
)
6196 body
= finish_omp_structured_block (body
);
6198 stmt
= make_node (OMP_PARALLEL
);
6199 TREE_TYPE (stmt
) = void_type_node
;
6200 OMP_PARALLEL_CLAUSES (stmt
) = clauses
;
6201 OMP_PARALLEL_BODY (stmt
) = body
;
6203 return add_stmt (stmt
);
6207 begin_omp_task (void)
6209 keep_next_level (true);
6210 return begin_omp_structured_block ();
6214 finish_omp_task (tree clauses
, tree body
)
6218 body
= finish_omp_structured_block (body
);
6220 stmt
= make_node (OMP_TASK
);
6221 TREE_TYPE (stmt
) = void_type_node
;
6222 OMP_TASK_CLAUSES (stmt
) = clauses
;
6223 OMP_TASK_BODY (stmt
) = body
;
6225 return add_stmt (stmt
);
6228 /* Helper function for finish_omp_for. Convert Ith random access iterator
6229 into integral iterator. Return FALSE if successful. */
6232 handle_omp_for_class_iterator (int i
, location_t locus
, tree declv
, tree initv
,
6233 tree condv
, tree incrv
, tree
*body
,
6234 tree
*pre_body
, tree clauses
, tree
*lastp
)
6236 tree diff
, iter_init
, iter_incr
= NULL
, last
;
6237 tree incr_var
= NULL
, orig_pre_body
, orig_body
, c
;
6238 tree decl
= TREE_VEC_ELT (declv
, i
);
6239 tree init
= TREE_VEC_ELT (initv
, i
);
6240 tree cond
= TREE_VEC_ELT (condv
, i
);
6241 tree incr
= TREE_VEC_ELT (incrv
, i
);
6243 location_t elocus
= locus
;
6245 if (init
&& EXPR_HAS_LOCATION (init
))
6246 elocus
= EXPR_LOCATION (init
);
6248 switch (TREE_CODE (cond
))
6255 if (TREE_OPERAND (cond
, 1) == iter
)
6256 cond
= build2 (swap_tree_comparison (TREE_CODE (cond
)),
6257 TREE_TYPE (cond
), iter
, TREE_OPERAND (cond
, 0));
6258 if (TREE_OPERAND (cond
, 0) != iter
)
6259 cond
= error_mark_node
;
6262 tree tem
= build_x_binary_op (EXPR_LOCATION (cond
),
6265 TREE_OPERAND (cond
, 1), ERROR_MARK
,
6266 NULL
, tf_warning_or_error
);
6267 if (error_operand_p (tem
))
6272 cond
= error_mark_node
;
6275 if (cond
== error_mark_node
)
6277 error_at (elocus
, "invalid controlling predicate");
6280 diff
= build_x_binary_op (elocus
, MINUS_EXPR
, TREE_OPERAND (cond
, 1),
6281 ERROR_MARK
, iter
, ERROR_MARK
, NULL
,
6282 tf_warning_or_error
);
6283 if (error_operand_p (diff
))
6285 if (TREE_CODE (TREE_TYPE (diff
)) != INTEGER_TYPE
)
6287 error_at (elocus
, "difference between %qE and %qD does not have integer type",
6288 TREE_OPERAND (cond
, 1), iter
);
6292 switch (TREE_CODE (incr
))
6294 case PREINCREMENT_EXPR
:
6295 case PREDECREMENT_EXPR
:
6296 case POSTINCREMENT_EXPR
:
6297 case POSTDECREMENT_EXPR
:
6298 if (TREE_OPERAND (incr
, 0) != iter
)
6300 incr
= error_mark_node
;
6303 iter_incr
= build_x_unary_op (EXPR_LOCATION (incr
),
6304 TREE_CODE (incr
), iter
,
6305 tf_warning_or_error
);
6306 if (error_operand_p (iter_incr
))
6308 else if (TREE_CODE (incr
) == PREINCREMENT_EXPR
6309 || TREE_CODE (incr
) == POSTINCREMENT_EXPR
)
6310 incr
= integer_one_node
;
6312 incr
= integer_minus_one_node
;
6315 if (TREE_OPERAND (incr
, 0) != iter
)
6316 incr
= error_mark_node
;
6317 else if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
6318 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
6320 tree rhs
= TREE_OPERAND (incr
, 1);
6321 if (TREE_OPERAND (rhs
, 0) == iter
)
6323 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs
, 1)))
6325 incr
= error_mark_node
;
6328 iter_incr
= build_x_modify_expr (EXPR_LOCATION (rhs
),
6329 iter
, TREE_CODE (rhs
),
6330 TREE_OPERAND (rhs
, 1),
6331 tf_warning_or_error
);
6332 if (error_operand_p (iter_incr
))
6334 incr
= TREE_OPERAND (rhs
, 1);
6335 incr
= cp_convert (TREE_TYPE (diff
), incr
,
6336 tf_warning_or_error
);
6337 if (TREE_CODE (rhs
) == MINUS_EXPR
)
6339 incr
= build1 (NEGATE_EXPR
, TREE_TYPE (diff
), incr
);
6340 incr
= fold_if_not_in_template (incr
);
6342 if (TREE_CODE (incr
) != INTEGER_CST
6343 && (TREE_CODE (incr
) != NOP_EXPR
6344 || (TREE_CODE (TREE_OPERAND (incr
, 0))
6349 else if (TREE_OPERAND (rhs
, 1) == iter
)
6351 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs
, 0))) != INTEGER_TYPE
6352 || TREE_CODE (rhs
) != PLUS_EXPR
)
6353 incr
= error_mark_node
;
6356 iter_incr
= build_x_binary_op (EXPR_LOCATION (rhs
),
6358 TREE_OPERAND (rhs
, 0),
6361 tf_warning_or_error
);
6362 if (error_operand_p (iter_incr
))
6364 iter_incr
= build_x_modify_expr (EXPR_LOCATION (rhs
),
6367 tf_warning_or_error
);
6368 if (error_operand_p (iter_incr
))
6370 incr
= TREE_OPERAND (rhs
, 0);
6375 incr
= error_mark_node
;
6378 incr
= error_mark_node
;
6381 incr
= error_mark_node
;
6385 if (incr
== error_mark_node
)
6387 error_at (elocus
, "invalid increment expression");
6391 incr
= cp_convert (TREE_TYPE (diff
), incr
, tf_warning_or_error
);
6392 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
6393 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
6394 && OMP_CLAUSE_DECL (c
) == iter
)
6397 decl
= create_temporary_var (TREE_TYPE (diff
));
6399 add_decl_expr (decl
);
6400 last
= create_temporary_var (TREE_TYPE (diff
));
6402 add_decl_expr (last
);
6403 if (c
&& iter_incr
== NULL
)
6405 incr_var
= create_temporary_var (TREE_TYPE (diff
));
6406 pushdecl (incr_var
);
6407 add_decl_expr (incr_var
);
6409 gcc_assert (stmts_are_full_exprs_p ());
6411 orig_pre_body
= *pre_body
;
6412 *pre_body
= push_stmt_list ();
6414 add_stmt (orig_pre_body
);
6416 finish_expr_stmt (build_x_modify_expr (elocus
,
6417 iter
, NOP_EXPR
, init
,
6418 tf_warning_or_error
));
6419 init
= build_int_cst (TREE_TYPE (diff
), 0);
6420 if (c
&& iter_incr
== NULL
)
6422 finish_expr_stmt (build_x_modify_expr (elocus
,
6424 incr
, tf_warning_or_error
));
6426 iter_incr
= build_x_modify_expr (elocus
,
6427 iter
, PLUS_EXPR
, incr
,
6428 tf_warning_or_error
);
6430 finish_expr_stmt (build_x_modify_expr (elocus
,
6431 last
, NOP_EXPR
, init
,
6432 tf_warning_or_error
));
6433 *pre_body
= pop_stmt_list (*pre_body
);
6435 cond
= cp_build_binary_op (elocus
,
6436 TREE_CODE (cond
), decl
, diff
,
6437 tf_warning_or_error
);
6438 incr
= build_modify_expr (elocus
, decl
, NULL_TREE
, PLUS_EXPR
,
6439 elocus
, incr
, NULL_TREE
);
6442 *body
= push_stmt_list ();
6443 iter_init
= build2 (MINUS_EXPR
, TREE_TYPE (diff
), decl
, last
);
6444 iter_init
= build_x_modify_expr (elocus
,
6445 iter
, PLUS_EXPR
, iter_init
,
6446 tf_warning_or_error
);
6447 iter_init
= build1 (NOP_EXPR
, void_type_node
, iter_init
);
6448 finish_expr_stmt (iter_init
);
6449 finish_expr_stmt (build_x_modify_expr (elocus
,
6450 last
, NOP_EXPR
, decl
,
6451 tf_warning_or_error
));
6452 add_stmt (orig_body
);
6453 *body
= pop_stmt_list (*body
);
6457 OMP_CLAUSE_LASTPRIVATE_STMT (c
) = push_stmt_list ();
6458 finish_expr_stmt (iter_incr
);
6459 OMP_CLAUSE_LASTPRIVATE_STMT (c
)
6460 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (c
));
6463 TREE_VEC_ELT (declv
, i
) = decl
;
6464 TREE_VEC_ELT (initv
, i
) = init
;
6465 TREE_VEC_ELT (condv
, i
) = cond
;
6466 TREE_VEC_ELT (incrv
, i
) = incr
;
6472 /* Build and validate an OMP_FOR statement. CLAUSES, BODY, COND, INCR
6473 are directly for their associated operands in the statement. DECL
6474 and INIT are a combo; if DECL is NULL then INIT ought to be a
6475 MODIFY_EXPR, and the DECL should be extracted. PRE_BODY are
6476 optional statements that need to go before the loop into its
6480 finish_omp_for (location_t locus
, enum tree_code code
, tree declv
, tree initv
,
6481 tree condv
, tree incrv
, tree body
, tree pre_body
, tree clauses
)
6483 tree omp_for
= NULL
, orig_incr
= NULL
;
6484 tree decl
= NULL
, init
, cond
, incr
, orig_decl
= NULL_TREE
, block
= NULL_TREE
;
6485 tree last
= NULL_TREE
;
6489 gcc_assert (TREE_VEC_LENGTH (declv
) == TREE_VEC_LENGTH (initv
));
6490 gcc_assert (TREE_VEC_LENGTH (declv
) == TREE_VEC_LENGTH (condv
));
6491 gcc_assert (TREE_VEC_LENGTH (declv
) == TREE_VEC_LENGTH (incrv
));
6492 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
6494 decl
= TREE_VEC_ELT (declv
, i
);
6495 init
= TREE_VEC_ELT (initv
, i
);
6496 cond
= TREE_VEC_ELT (condv
, i
);
6497 incr
= TREE_VEC_ELT (incrv
, i
);
6503 switch (TREE_CODE (init
))
6506 decl
= TREE_OPERAND (init
, 0);
6507 init
= TREE_OPERAND (init
, 1);
6510 if (TREE_CODE (TREE_OPERAND (init
, 1)) == NOP_EXPR
)
6512 decl
= TREE_OPERAND (init
, 0);
6513 init
= TREE_OPERAND (init
, 2);
6523 "expected iteration declaration or initialization");
6528 if (init
&& EXPR_HAS_LOCATION (init
))
6529 elocus
= EXPR_LOCATION (init
);
6533 error_at (elocus
, "missing controlling predicate");
6539 error_at (elocus
, "missing increment expression");
6543 TREE_VEC_ELT (declv
, i
) = decl
;
6544 TREE_VEC_ELT (initv
, i
) = init
;
6547 if (dependent_omp_for_p (declv
, initv
, condv
, incrv
))
6551 stmt
= make_node (code
);
6553 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
6555 /* This is really just a place-holder. We'll be decomposing this
6556 again and going through the cp_build_modify_expr path below when
6557 we instantiate the thing. */
6558 TREE_VEC_ELT (initv
, i
)
6559 = build2 (MODIFY_EXPR
, void_type_node
, TREE_VEC_ELT (declv
, i
),
6560 TREE_VEC_ELT (initv
, i
));
6563 TREE_TYPE (stmt
) = void_type_node
;
6564 OMP_FOR_INIT (stmt
) = initv
;
6565 OMP_FOR_COND (stmt
) = condv
;
6566 OMP_FOR_INCR (stmt
) = incrv
;
6567 OMP_FOR_BODY (stmt
) = body
;
6568 OMP_FOR_PRE_BODY (stmt
) = pre_body
;
6569 OMP_FOR_CLAUSES (stmt
) = clauses
;
6571 SET_EXPR_LOCATION (stmt
, locus
);
6572 return add_stmt (stmt
);
6575 if (processing_template_decl
)
6576 orig_incr
= make_tree_vec (TREE_VEC_LENGTH (incrv
));
6578 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); )
6580 decl
= TREE_VEC_ELT (declv
, i
);
6581 init
= TREE_VEC_ELT (initv
, i
);
6582 cond
= TREE_VEC_ELT (condv
, i
);
6583 incr
= TREE_VEC_ELT (incrv
, i
);
6585 TREE_VEC_ELT (orig_incr
, i
) = incr
;
6588 if (init
&& EXPR_HAS_LOCATION (init
))
6589 elocus
= EXPR_LOCATION (init
);
6593 error_at (elocus
, "expected iteration declaration or initialization");
6597 if (incr
&& TREE_CODE (incr
) == MODOP_EXPR
)
6600 TREE_VEC_ELT (orig_incr
, i
) = incr
;
6601 incr
= cp_build_modify_expr (TREE_OPERAND (incr
, 0),
6602 TREE_CODE (TREE_OPERAND (incr
, 1)),
6603 TREE_OPERAND (incr
, 2),
6604 tf_warning_or_error
);
6607 if (CLASS_TYPE_P (TREE_TYPE (decl
)))
6609 if (code
== OMP_SIMD
)
6611 error_at (elocus
, "%<#pragma omp simd%> used with class "
6612 "iteration variable %qE", decl
);
6615 if (code
== CILK_FOR
&& i
== 0)
6617 if (handle_omp_for_class_iterator (i
, locus
, declv
, initv
, condv
,
6618 incrv
, &body
, &pre_body
,
6624 if (!INTEGRAL_TYPE_P (TREE_TYPE (decl
))
6625 && !TYPE_PTR_P (TREE_TYPE (decl
)))
6627 error_at (elocus
, "invalid type for iteration variable %qE", decl
);
6631 if (!processing_template_decl
)
6633 init
= fold_build_cleanup_point_expr (TREE_TYPE (init
), init
);
6634 init
= cp_build_modify_expr (decl
, NOP_EXPR
, init
, tf_warning_or_error
);
6637 init
= build2 (MODIFY_EXPR
, void_type_node
, decl
, init
);
6639 && TREE_SIDE_EFFECTS (cond
)
6640 && COMPARISON_CLASS_P (cond
)
6641 && !processing_template_decl
)
6643 tree t
= TREE_OPERAND (cond
, 0);
6644 if (TREE_SIDE_EFFECTS (t
)
6646 && (TREE_CODE (t
) != NOP_EXPR
6647 || TREE_OPERAND (t
, 0) != decl
))
6648 TREE_OPERAND (cond
, 0)
6649 = fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
6651 t
= TREE_OPERAND (cond
, 1);
6652 if (TREE_SIDE_EFFECTS (t
)
6654 && (TREE_CODE (t
) != NOP_EXPR
6655 || TREE_OPERAND (t
, 0) != decl
))
6656 TREE_OPERAND (cond
, 1)
6657 = fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
6659 if (decl
== error_mark_node
|| init
== error_mark_node
)
6662 TREE_VEC_ELT (declv
, i
) = decl
;
6663 TREE_VEC_ELT (initv
, i
) = init
;
6664 TREE_VEC_ELT (condv
, i
) = cond
;
6665 TREE_VEC_ELT (incrv
, i
) = incr
;
6669 if (IS_EMPTY_STMT (pre_body
))
6672 if (code
== CILK_FOR
&& !processing_template_decl
)
6673 block
= push_stmt_list ();
6675 omp_for
= c_finish_omp_for (locus
, code
, declv
, initv
, condv
, incrv
,
6678 if (omp_for
== NULL
)
6681 pop_stmt_list (block
);
6685 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INCR (omp_for
)); i
++)
6687 decl
= TREE_OPERAND (TREE_VEC_ELT (OMP_FOR_INIT (omp_for
), i
), 0);
6688 incr
= TREE_VEC_ELT (OMP_FOR_INCR (omp_for
), i
);
6690 if (TREE_CODE (incr
) != MODIFY_EXPR
)
6693 if (TREE_SIDE_EFFECTS (TREE_OPERAND (incr
, 1))
6694 && BINARY_CLASS_P (TREE_OPERAND (incr
, 1))
6695 && !processing_template_decl
)
6697 tree t
= TREE_OPERAND (TREE_OPERAND (incr
, 1), 0);
6698 if (TREE_SIDE_EFFECTS (t
)
6700 && (TREE_CODE (t
) != NOP_EXPR
6701 || TREE_OPERAND (t
, 0) != decl
))
6702 TREE_OPERAND (TREE_OPERAND (incr
, 1), 0)
6703 = fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
6705 t
= TREE_OPERAND (TREE_OPERAND (incr
, 1), 1);
6706 if (TREE_SIDE_EFFECTS (t
)
6708 && (TREE_CODE (t
) != NOP_EXPR
6709 || TREE_OPERAND (t
, 0) != decl
))
6710 TREE_OPERAND (TREE_OPERAND (incr
, 1), 1)
6711 = fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
6715 TREE_VEC_ELT (OMP_FOR_INCR (omp_for
), i
) = TREE_VEC_ELT (orig_incr
, i
);
6717 OMP_FOR_CLAUSES (omp_for
) = clauses
;
6721 tree omp_par
= make_node (OMP_PARALLEL
);
6722 TREE_TYPE (omp_par
) = void_type_node
;
6723 OMP_PARALLEL_CLAUSES (omp_par
) = NULL_TREE
;
6724 tree bind
= build3 (BIND_EXPR
, void_type_node
, NULL
, NULL
, NULL
);
6725 TREE_SIDE_EFFECTS (bind
) = 1;
6726 BIND_EXPR_BODY (bind
) = pop_stmt_list (block
);
6727 OMP_PARALLEL_BODY (omp_par
) = bind
;
6728 if (OMP_FOR_PRE_BODY (omp_for
))
6730 add_stmt (OMP_FOR_PRE_BODY (omp_for
));
6731 OMP_FOR_PRE_BODY (omp_for
) = NULL_TREE
;
6733 init
= TREE_VEC_ELT (OMP_FOR_INIT (omp_for
), 0);
6734 decl
= TREE_OPERAND (init
, 0);
6735 cond
= TREE_VEC_ELT (OMP_FOR_COND (omp_for
), 0);
6736 incr
= TREE_VEC_ELT (OMP_FOR_INCR (omp_for
), 0);
6737 tree t
= TREE_OPERAND (cond
, 1), c
, clauses
, *pc
;
6738 clauses
= OMP_FOR_CLAUSES (omp_for
);
6739 OMP_FOR_CLAUSES (omp_for
) = NULL_TREE
;
6740 for (pc
= &clauses
; *pc
; )
6741 if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_SCHEDULE
)
6743 gcc_assert (OMP_FOR_CLAUSES (omp_for
) == NULL_TREE
);
6744 OMP_FOR_CLAUSES (omp_for
) = *pc
;
6745 *pc
= OMP_CLAUSE_CHAIN (*pc
);
6746 OMP_CLAUSE_CHAIN (OMP_FOR_CLAUSES (omp_for
)) = NULL_TREE
;
6750 gcc_assert (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_FIRSTPRIVATE
);
6751 pc
= &OMP_CLAUSE_CHAIN (*pc
);
6753 if (TREE_CODE (t
) != INTEGER_CST
)
6755 TREE_OPERAND (cond
, 1) = get_temp_regvar (TREE_TYPE (t
), t
);
6756 c
= build_omp_clause (input_location
, OMP_CLAUSE_FIRSTPRIVATE
);
6757 OMP_CLAUSE_DECL (c
) = TREE_OPERAND (cond
, 1);
6758 OMP_CLAUSE_CHAIN (c
) = clauses
;
6761 if (TREE_CODE (incr
) == MODIFY_EXPR
)
6763 t
= TREE_OPERAND (TREE_OPERAND (incr
, 1), 1);
6764 if (TREE_CODE (t
) != INTEGER_CST
)
6766 TREE_OPERAND (TREE_OPERAND (incr
, 1), 1)
6767 = get_temp_regvar (TREE_TYPE (t
), t
);
6768 c
= build_omp_clause (input_location
, OMP_CLAUSE_FIRSTPRIVATE
);
6769 OMP_CLAUSE_DECL (c
) = TREE_OPERAND (TREE_OPERAND (incr
, 1), 1);
6770 OMP_CLAUSE_CHAIN (c
) = clauses
;
6774 t
= TREE_OPERAND (init
, 1);
6775 if (TREE_CODE (t
) != INTEGER_CST
)
6777 TREE_OPERAND (init
, 1) = get_temp_regvar (TREE_TYPE (t
), t
);
6778 c
= build_omp_clause (input_location
, OMP_CLAUSE_FIRSTPRIVATE
);
6779 OMP_CLAUSE_DECL (c
) = TREE_OPERAND (init
, 1);
6780 OMP_CLAUSE_CHAIN (c
) = clauses
;
6783 if (orig_decl
&& orig_decl
!= decl
)
6785 c
= build_omp_clause (input_location
, OMP_CLAUSE_FIRSTPRIVATE
);
6786 OMP_CLAUSE_DECL (c
) = orig_decl
;
6787 OMP_CLAUSE_CHAIN (c
) = clauses
;
6792 c
= build_omp_clause (input_location
, OMP_CLAUSE_FIRSTPRIVATE
);
6793 OMP_CLAUSE_DECL (c
) = last
;
6794 OMP_CLAUSE_CHAIN (c
) = clauses
;
6797 c
= build_omp_clause (input_location
, OMP_CLAUSE_PRIVATE
);
6798 OMP_CLAUSE_DECL (c
) = decl
;
6799 OMP_CLAUSE_CHAIN (c
) = clauses
;
6801 c
= build_omp_clause (input_location
, OMP_CLAUSE__CILK_FOR_COUNT_
);
6802 OMP_CLAUSE_OPERAND (c
, 0)
6803 = cilk_for_number_of_iterations (omp_for
);
6804 OMP_CLAUSE_CHAIN (c
) = clauses
;
6805 OMP_PARALLEL_CLAUSES (omp_par
) = finish_omp_clauses (c
);
6809 else if (code
== CILK_FOR
&& processing_template_decl
)
6811 tree c
, clauses
= OMP_FOR_CLAUSES (omp_for
);
6812 if (orig_decl
&& orig_decl
!= decl
)
6814 c
= build_omp_clause (input_location
, OMP_CLAUSE_FIRSTPRIVATE
);
6815 OMP_CLAUSE_DECL (c
) = orig_decl
;
6816 OMP_CLAUSE_CHAIN (c
) = clauses
;
6821 c
= build_omp_clause (input_location
, OMP_CLAUSE_FIRSTPRIVATE
);
6822 OMP_CLAUSE_DECL (c
) = last
;
6823 OMP_CLAUSE_CHAIN (c
) = clauses
;
6826 OMP_FOR_CLAUSES (omp_for
) = clauses
;
6832 finish_omp_atomic (enum tree_code code
, enum tree_code opcode
, tree lhs
,
6833 tree rhs
, tree v
, tree lhs1
, tree rhs1
, bool seq_cst
)
6848 dependent_p
= false;
6851 /* Even in a template, we can detect invalid uses of the atomic
6852 pragma if neither LHS nor RHS is type-dependent. */
6853 if (processing_template_decl
)
6855 dependent_p
= (type_dependent_expression_p (lhs
)
6856 || (rhs
&& type_dependent_expression_p (rhs
))
6857 || (v
&& type_dependent_expression_p (v
))
6858 || (lhs1
&& type_dependent_expression_p (lhs1
))
6859 || (rhs1
&& type_dependent_expression_p (rhs1
)));
6862 lhs
= build_non_dependent_expr (lhs
);
6864 rhs
= build_non_dependent_expr (rhs
);
6866 v
= build_non_dependent_expr (v
);
6868 lhs1
= build_non_dependent_expr (lhs1
);
6870 rhs1
= build_non_dependent_expr (rhs1
);
6875 bool swapped
= false;
6876 if (rhs1
&& cp_tree_equal (lhs
, rhs
))
6881 swapped
= !commutative_tree_code (opcode
);
6883 if (rhs1
&& !cp_tree_equal (lhs
, rhs1
))
6885 if (code
== OMP_ATOMIC
)
6886 error ("%<#pragma omp atomic update%> uses two different "
6887 "expressions for memory");
6889 error ("%<#pragma omp atomic capture%> uses two different "
6890 "expressions for memory");
6893 if (lhs1
&& !cp_tree_equal (lhs
, lhs1
))
6895 if (code
== OMP_ATOMIC
)
6896 error ("%<#pragma omp atomic update%> uses two different "
6897 "expressions for memory");
6899 error ("%<#pragma omp atomic capture%> uses two different "
6900 "expressions for memory");
6903 stmt
= c_finish_omp_atomic (input_location
, code
, opcode
, lhs
, rhs
,
6904 v
, lhs1
, rhs1
, swapped
, seq_cst
);
6905 if (stmt
== error_mark_node
)
6908 if (processing_template_decl
)
6910 if (code
== OMP_ATOMIC_READ
)
6912 stmt
= build_min_nt_loc (EXPR_LOCATION (orig_lhs
),
6913 OMP_ATOMIC_READ
, orig_lhs
);
6914 OMP_ATOMIC_SEQ_CST (stmt
) = seq_cst
;
6915 stmt
= build2 (MODIFY_EXPR
, void_type_node
, orig_v
, stmt
);
6919 if (opcode
== NOP_EXPR
)
6920 stmt
= build2 (MODIFY_EXPR
, void_type_node
, orig_lhs
, orig_rhs
);
6922 stmt
= build2 (opcode
, void_type_node
, orig_lhs
, orig_rhs
);
6924 stmt
= build_min_nt_loc (EXPR_LOCATION (orig_rhs1
),
6925 COMPOUND_EXPR
, orig_rhs1
, stmt
);
6926 if (code
!= OMP_ATOMIC
)
6928 stmt
= build_min_nt_loc (EXPR_LOCATION (orig_lhs1
),
6929 code
, orig_lhs1
, stmt
);
6930 OMP_ATOMIC_SEQ_CST (stmt
) = seq_cst
;
6931 stmt
= build2 (MODIFY_EXPR
, void_type_node
, orig_v
, stmt
);
6934 stmt
= build2 (OMP_ATOMIC
, void_type_node
, integer_zero_node
, stmt
);
6935 OMP_ATOMIC_SEQ_CST (stmt
) = seq_cst
;
6937 finish_expr_stmt (stmt
);
6941 finish_omp_barrier (void)
6943 tree fn
= builtin_decl_explicit (BUILT_IN_GOMP_BARRIER
);
6944 vec
<tree
, va_gc
> *vec
= make_tree_vector ();
6945 tree stmt
= finish_call_expr (fn
, &vec
, false, false, tf_warning_or_error
);
6946 release_tree_vector (vec
);
6947 finish_expr_stmt (stmt
);
6951 finish_omp_flush (void)
6953 tree fn
= builtin_decl_explicit (BUILT_IN_SYNC_SYNCHRONIZE
);
6954 vec
<tree
, va_gc
> *vec
= make_tree_vector ();
6955 tree stmt
= finish_call_expr (fn
, &vec
, false, false, tf_warning_or_error
);
6956 release_tree_vector (vec
);
6957 finish_expr_stmt (stmt
);
6961 finish_omp_taskwait (void)
6963 tree fn
= builtin_decl_explicit (BUILT_IN_GOMP_TASKWAIT
);
6964 vec
<tree
, va_gc
> *vec
= make_tree_vector ();
6965 tree stmt
= finish_call_expr (fn
, &vec
, false, false, tf_warning_or_error
);
6966 release_tree_vector (vec
);
6967 finish_expr_stmt (stmt
);
6971 finish_omp_taskyield (void)
6973 tree fn
= builtin_decl_explicit (BUILT_IN_GOMP_TASKYIELD
);
6974 vec
<tree
, va_gc
> *vec
= make_tree_vector ();
6975 tree stmt
= finish_call_expr (fn
, &vec
, false, false, tf_warning_or_error
);
6976 release_tree_vector (vec
);
6977 finish_expr_stmt (stmt
);
6981 finish_omp_cancel (tree clauses
)
6983 tree fn
= builtin_decl_explicit (BUILT_IN_GOMP_CANCEL
);
6985 if (find_omp_clause (clauses
, OMP_CLAUSE_PARALLEL
))
6987 else if (find_omp_clause (clauses
, OMP_CLAUSE_FOR
))
6989 else if (find_omp_clause (clauses
, OMP_CLAUSE_SECTIONS
))
6991 else if (find_omp_clause (clauses
, OMP_CLAUSE_TASKGROUP
))
6995 error ("%<#pragma omp cancel must specify one of "
6996 "%<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses");
6999 vec
<tree
, va_gc
> *vec
= make_tree_vector ();
7000 tree ifc
= find_omp_clause (clauses
, OMP_CLAUSE_IF
);
7001 if (ifc
!= NULL_TREE
)
7003 tree type
= TREE_TYPE (OMP_CLAUSE_IF_EXPR (ifc
));
7004 ifc
= fold_build2_loc (OMP_CLAUSE_LOCATION (ifc
), NE_EXPR
,
7005 boolean_type_node
, OMP_CLAUSE_IF_EXPR (ifc
),
7006 build_zero_cst (type
));
7009 ifc
= boolean_true_node
;
7010 vec
->quick_push (build_int_cst (integer_type_node
, mask
));
7011 vec
->quick_push (ifc
);
7012 tree stmt
= finish_call_expr (fn
, &vec
, false, false, tf_warning_or_error
);
7013 release_tree_vector (vec
);
7014 finish_expr_stmt (stmt
);
7018 finish_omp_cancellation_point (tree clauses
)
7020 tree fn
= builtin_decl_explicit (BUILT_IN_GOMP_CANCELLATION_POINT
);
7022 if (find_omp_clause (clauses
, OMP_CLAUSE_PARALLEL
))
7024 else if (find_omp_clause (clauses
, OMP_CLAUSE_FOR
))
7026 else if (find_omp_clause (clauses
, OMP_CLAUSE_SECTIONS
))
7028 else if (find_omp_clause (clauses
, OMP_CLAUSE_TASKGROUP
))
7032 error ("%<#pragma omp cancellation point must specify one of "
7033 "%<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses");
7036 vec
<tree
, va_gc
> *vec
7037 = make_tree_vector_single (build_int_cst (integer_type_node
, mask
));
7038 tree stmt
= finish_call_expr (fn
, &vec
, false, false, tf_warning_or_error
);
7039 release_tree_vector (vec
);
7040 finish_expr_stmt (stmt
);
7043 /* Begin a __transaction_atomic or __transaction_relaxed statement.
7044 If PCOMPOUND is non-null, this is for a function-transaction-block, and we
7045 should create an extra compound stmt. */
7048 begin_transaction_stmt (location_t loc
, tree
*pcompound
, int flags
)
7053 *pcompound
= begin_compound_stmt (0);
7055 r
= build_stmt (loc
, TRANSACTION_EXPR
, NULL_TREE
);
7057 /* Only add the statement to the function if support enabled. */
7061 error_at (loc
, ((flags
& TM_STMT_ATTR_RELAXED
) != 0
7062 ? G_("%<__transaction_relaxed%> without "
7063 "transactional memory support enabled")
7064 : G_("%<__transaction_atomic%> without "
7065 "transactional memory support enabled")));
7067 TRANSACTION_EXPR_BODY (r
) = push_stmt_list ();
7068 TREE_SIDE_EFFECTS (r
) = 1;
7072 /* End a __transaction_atomic or __transaction_relaxed statement.
7073 If COMPOUND_STMT is non-null, this is for a function-transaction-block,
7074 and we should end the compound. If NOEX is non-NULL, we wrap the body in
7075 a MUST_NOT_THROW_EXPR with NOEX as condition. */
7078 finish_transaction_stmt (tree stmt
, tree compound_stmt
, int flags
, tree noex
)
7080 TRANSACTION_EXPR_BODY (stmt
) = pop_stmt_list (TRANSACTION_EXPR_BODY (stmt
));
7081 TRANSACTION_EXPR_OUTER (stmt
) = (flags
& TM_STMT_ATTR_OUTER
) != 0;
7082 TRANSACTION_EXPR_RELAXED (stmt
) = (flags
& TM_STMT_ATTR_RELAXED
) != 0;
7083 TRANSACTION_EXPR_IS_STMT (stmt
) = 1;
7085 /* noexcept specifications are not allowed for function transactions. */
7086 gcc_assert (!(noex
&& compound_stmt
));
7089 tree body
= build_must_not_throw_expr (TRANSACTION_EXPR_BODY (stmt
),
7091 /* This may not be true when the STATEMENT_LIST is empty. */
7093 SET_EXPR_LOCATION (body
, EXPR_LOCATION (TRANSACTION_EXPR_BODY (stmt
)));
7094 TREE_SIDE_EFFECTS (body
) = 1;
7095 TRANSACTION_EXPR_BODY (stmt
) = body
;
7099 finish_compound_stmt (compound_stmt
);
7102 /* Build a __transaction_atomic or __transaction_relaxed expression. If
7103 NOEX is non-NULL, we wrap the body in a MUST_NOT_THROW_EXPR with NOEX as
7107 build_transaction_expr (location_t loc
, tree expr
, int flags
, tree noex
)
7112 expr
= build_must_not_throw_expr (expr
, noex
);
7114 SET_EXPR_LOCATION (expr
, loc
);
7115 TREE_SIDE_EFFECTS (expr
) = 1;
7117 ret
= build1 (TRANSACTION_EXPR
, TREE_TYPE (expr
), expr
);
7118 if (flags
& TM_STMT_ATTR_RELAXED
)
7119 TRANSACTION_EXPR_RELAXED (ret
) = 1;
7120 TREE_SIDE_EFFECTS (ret
) = 1;
7121 SET_EXPR_LOCATION (ret
, loc
);
7126 init_cp_semantics (void)
7130 /* Build a STATIC_ASSERT for a static assertion with the condition
7131 CONDITION and the message text MESSAGE. LOCATION is the location
7132 of the static assertion in the source code. When MEMBER_P, this
7133 static assertion is a member of a class. */
7135 finish_static_assert (tree condition
, tree message
, location_t location
,
7138 if (message
== NULL_TREE
7139 || message
== error_mark_node
7140 || condition
== NULL_TREE
7141 || condition
== error_mark_node
)
7144 if (check_for_bare_parameter_packs (condition
))
7145 condition
= error_mark_node
;
7147 if (type_dependent_expression_p (condition
)
7148 || value_dependent_expression_p (condition
))
7150 /* We're in a template; build a STATIC_ASSERT and put it in
7154 assertion
= make_node (STATIC_ASSERT
);
7155 STATIC_ASSERT_CONDITION (assertion
) = condition
;
7156 STATIC_ASSERT_MESSAGE (assertion
) = message
;
7157 STATIC_ASSERT_SOURCE_LOCATION (assertion
) = location
;
7160 maybe_add_class_template_decl_list (current_class_type
,
7164 add_stmt (assertion
);
7169 /* Fold the expression and convert it to a boolean value. */
7170 condition
= instantiate_non_dependent_expr (condition
);
7171 condition
= cp_convert (boolean_type_node
, condition
, tf_warning_or_error
);
7172 condition
= maybe_constant_value (condition
);
7174 if (TREE_CODE (condition
) == INTEGER_CST
&& !integer_zerop (condition
))
7175 /* Do nothing; the condition is satisfied. */
7179 location_t saved_loc
= input_location
;
7181 input_location
= location
;
7182 if (TREE_CODE (condition
) == INTEGER_CST
7183 && integer_zerop (condition
))
7184 /* Report the error. */
7185 error ("static assertion failed: %s", TREE_STRING_POINTER (message
));
7186 else if (condition
&& condition
!= error_mark_node
)
7188 error ("non-constant condition for static assertion");
7189 if (require_potential_rvalue_constant_expression (condition
))
7190 cxx_constant_value (condition
);
7192 input_location
= saved_loc
;
7196 /* Implements the C++0x decltype keyword. Returns the type of EXPR,
7197 suitable for use as a type-specifier.
7199 ID_EXPRESSION_OR_MEMBER_ACCESS_P is true when EXPR was parsed as an
7200 id-expression or a class member access, FALSE when it was parsed as
7201 a full expression. */
7204 finish_decltype_type (tree expr
, bool id_expression_or_member_access_p
,
7205 tsubst_flags_t complain
)
7207 tree type
= NULL_TREE
;
7209 if (!expr
|| error_operand_p (expr
))
7210 return error_mark_node
;
7213 || TREE_CODE (expr
) == TYPE_DECL
7214 || (TREE_CODE (expr
) == BIT_NOT_EXPR
7215 && TYPE_P (TREE_OPERAND (expr
, 0))))
7217 if (complain
& tf_error
)
7218 error ("argument to decltype must be an expression");
7219 return error_mark_node
;
7222 /* Depending on the resolution of DR 1172, we may later need to distinguish
7223 instantiation-dependent but not type-dependent expressions so that, say,
7224 A<decltype(sizeof(T))>::U doesn't require 'typename'. */
7225 if (instantiation_dependent_expression_p (expr
))
7227 type
= cxx_make_type (DECLTYPE_TYPE
);
7228 DECLTYPE_TYPE_EXPR (type
) = expr
;
7229 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type
)
7230 = id_expression_or_member_access_p
;
7231 SET_TYPE_STRUCTURAL_EQUALITY (type
);
7236 /* The type denoted by decltype(e) is defined as follows: */
7238 expr
= resolve_nondeduced_context (expr
);
7240 if (invalid_nonstatic_memfn_p (expr
, complain
))
7241 return error_mark_node
;
7243 if (type_unknown_p (expr
))
7245 if (complain
& tf_error
)
7246 error ("decltype cannot resolve address of overloaded function");
7247 return error_mark_node
;
7250 /* To get the size of a static data member declared as an array of
7251 unknown bound, we need to instantiate it. */
7253 && VAR_HAD_UNKNOWN_BOUND (expr
)
7254 && DECL_TEMPLATE_INSTANTIATION (expr
))
7255 instantiate_decl (expr
, /*defer_ok*/true, /*expl_inst_mem*/false);
7257 if (id_expression_or_member_access_p
)
7259 /* If e is an id-expression or a class member access (5.2.5
7260 [expr.ref]), decltype(e) is defined as the type of the entity
7261 named by e. If there is no such entity, or e names a set of
7262 overloaded functions, the program is ill-formed. */
7263 if (identifier_p (expr
))
7264 expr
= lookup_name (expr
);
7266 if (INDIRECT_REF_P (expr
))
7267 /* This can happen when the expression is, e.g., "a.b". Just
7268 look at the underlying operand. */
7269 expr
= TREE_OPERAND (expr
, 0);
7271 if (TREE_CODE (expr
) == OFFSET_REF
7272 || TREE_CODE (expr
) == MEMBER_REF
7273 || TREE_CODE (expr
) == SCOPE_REF
)
7274 /* We're only interested in the field itself. If it is a
7275 BASELINK, we will need to see through it in the next
7277 expr
= TREE_OPERAND (expr
, 1);
7279 if (BASELINK_P (expr
))
7280 /* See through BASELINK nodes to the underlying function. */
7281 expr
= BASELINK_FUNCTIONS (expr
);
7283 switch (TREE_CODE (expr
))
7286 if (DECL_BIT_FIELD_TYPE (expr
))
7288 type
= DECL_BIT_FIELD_TYPE (expr
);
7291 /* Fall through for fields that aren't bitfields. */
7298 case TEMPLATE_PARM_INDEX
:
7299 expr
= mark_type_use (expr
);
7300 type
= TREE_TYPE (expr
);
7304 type
= error_mark_node
;
7309 mark_type_use (expr
);
7310 type
= is_bitfield_expr_with_lowered_type (expr
);
7312 type
= TREE_TYPE (TREE_OPERAND (expr
, 1));
7320 /* We can get here when the id-expression refers to an
7321 enumerator or non-type template parameter. */
7322 type
= TREE_TYPE (expr
);
7326 /* Handle instantiated template non-type arguments. */
7327 type
= TREE_TYPE (expr
);
7333 /* Within a lambda-expression:
7335 Every occurrence of decltype((x)) where x is a possibly
7336 parenthesized id-expression that names an entity of
7337 automatic storage duration is treated as if x were
7338 transformed into an access to a corresponding data member
7339 of the closure type that would have been declared if x
7340 were a use of the denoted entity. */
7341 if (outer_automatic_var_p (expr
)
7342 && current_function_decl
7343 && LAMBDA_FUNCTION_P (current_function_decl
))
7344 type
= capture_decltype (expr
);
7345 else if (error_operand_p (expr
))
7346 type
= error_mark_node
;
7347 else if (expr
== current_class_ptr
)
7348 /* If the expression is just "this", we want the
7349 cv-unqualified pointer for the "this" type. */
7350 type
= TYPE_MAIN_VARIANT (TREE_TYPE (expr
));
7353 /* Otherwise, where T is the type of e, if e is an lvalue,
7354 decltype(e) is defined as T&; if an xvalue, T&&; otherwise, T. */
7355 cp_lvalue_kind clk
= lvalue_kind (expr
);
7356 type
= unlowered_expr_type (expr
);
7357 gcc_assert (TREE_CODE (type
) != REFERENCE_TYPE
);
7359 /* For vector types, pick a non-opaque variant. */
7360 if (TREE_CODE (type
) == VECTOR_TYPE
)
7361 type
= strip_typedefs (type
);
7363 if (clk
!= clk_none
&& !(clk
& clk_class
))
7364 type
= cp_build_reference_type (type
, (clk
& clk_rvalueref
));
7371 /* Called from trait_expr_value to evaluate either __has_nothrow_assign or
7372 __has_nothrow_copy, depending on assign_p. */
7375 classtype_has_nothrow_assign_or_copy_p (tree type
, bool assign_p
)
7382 ix
= lookup_fnfields_1 (type
, ansi_assopname (NOP_EXPR
));
7385 fns
= (*CLASSTYPE_METHOD_VEC (type
))[ix
];
7387 else if (TYPE_HAS_COPY_CTOR (type
))
7389 /* If construction of the copy constructor was postponed, create
7391 if (CLASSTYPE_LAZY_COPY_CTOR (type
))
7392 lazily_declare_fn (sfk_copy_constructor
, type
);
7393 if (CLASSTYPE_LAZY_MOVE_CTOR (type
))
7394 lazily_declare_fn (sfk_move_constructor
, type
);
7395 fns
= CLASSTYPE_CONSTRUCTORS (type
);
7400 for (; fns
; fns
= OVL_NEXT (fns
))
7402 tree fn
= OVL_CURRENT (fns
);
7406 if (copy_fn_p (fn
) == 0)
7409 else if (copy_fn_p (fn
) <= 0)
7412 maybe_instantiate_noexcept (fn
);
7413 if (!TYPE_NOTHROW_P (TREE_TYPE (fn
)))
7420 /* Actually evaluates the trait. */
7423 trait_expr_value (cp_trait_kind kind
, tree type1
, tree type2
)
7425 enum tree_code type_code1
;
7428 type_code1
= TREE_CODE (type1
);
7432 case CPTK_HAS_NOTHROW_ASSIGN
:
7433 type1
= strip_array_types (type1
);
7434 return (!CP_TYPE_CONST_P (type1
) && type_code1
!= REFERENCE_TYPE
7435 && (trait_expr_value (CPTK_HAS_TRIVIAL_ASSIGN
, type1
, type2
)
7436 || (CLASS_TYPE_P (type1
)
7437 && classtype_has_nothrow_assign_or_copy_p (type1
,
7440 case CPTK_HAS_TRIVIAL_ASSIGN
:
7441 /* ??? The standard seems to be missing the "or array of such a class
7442 type" wording for this trait. */
7443 type1
= strip_array_types (type1
);
7444 return (!CP_TYPE_CONST_P (type1
) && type_code1
!= REFERENCE_TYPE
7445 && (trivial_type_p (type1
)
7446 || (CLASS_TYPE_P (type1
)
7447 && TYPE_HAS_TRIVIAL_COPY_ASSIGN (type1
))));
7449 case CPTK_HAS_NOTHROW_CONSTRUCTOR
:
7450 type1
= strip_array_types (type1
);
7451 return (trait_expr_value (CPTK_HAS_TRIVIAL_CONSTRUCTOR
, type1
, type2
)
7452 || (CLASS_TYPE_P (type1
)
7453 && (t
= locate_ctor (type1
))
7454 && (maybe_instantiate_noexcept (t
),
7455 TYPE_NOTHROW_P (TREE_TYPE (t
)))));
7457 case CPTK_HAS_TRIVIAL_CONSTRUCTOR
:
7458 type1
= strip_array_types (type1
);
7459 return (trivial_type_p (type1
)
7460 || (CLASS_TYPE_P (type1
) && TYPE_HAS_TRIVIAL_DFLT (type1
)));
7462 case CPTK_HAS_NOTHROW_COPY
:
7463 type1
= strip_array_types (type1
);
7464 return (trait_expr_value (CPTK_HAS_TRIVIAL_COPY
, type1
, type2
)
7465 || (CLASS_TYPE_P (type1
)
7466 && classtype_has_nothrow_assign_or_copy_p (type1
, false)));
7468 case CPTK_HAS_TRIVIAL_COPY
:
7469 /* ??? The standard seems to be missing the "or array of such a class
7470 type" wording for this trait. */
7471 type1
= strip_array_types (type1
);
7472 return (trivial_type_p (type1
) || type_code1
== REFERENCE_TYPE
7473 || (CLASS_TYPE_P (type1
) && TYPE_HAS_TRIVIAL_COPY_CTOR (type1
)));
7475 case CPTK_HAS_TRIVIAL_DESTRUCTOR
:
7476 type1
= strip_array_types (type1
);
7477 return (trivial_type_p (type1
) || type_code1
== REFERENCE_TYPE
7478 || (CLASS_TYPE_P (type1
)
7479 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type1
)));
7481 case CPTK_HAS_VIRTUAL_DESTRUCTOR
:
7482 return type_has_virtual_destructor (type1
);
7484 case CPTK_IS_ABSTRACT
:
7485 return (ABSTRACT_CLASS_TYPE_P (type1
));
7487 case CPTK_IS_BASE_OF
:
7488 return (NON_UNION_CLASS_TYPE_P (type1
) && NON_UNION_CLASS_TYPE_P (type2
)
7489 && (same_type_ignoring_top_level_qualifiers_p (type1
, type2
)
7490 || DERIVED_FROM_P (type1
, type2
)));
7493 return (NON_UNION_CLASS_TYPE_P (type1
));
7496 return (NON_UNION_CLASS_TYPE_P (type1
) && CLASSTYPE_EMPTY_P (type1
));
7499 return (type_code1
== ENUMERAL_TYPE
);
7502 return (CLASS_TYPE_P (type1
) && CLASSTYPE_FINAL (type1
));
7504 case CPTK_IS_LITERAL_TYPE
:
7505 return (literal_type_p (type1
));
7508 return (pod_type_p (type1
));
7510 case CPTK_IS_POLYMORPHIC
:
7511 return (CLASS_TYPE_P (type1
) && TYPE_POLYMORPHIC_P (type1
));
7513 case CPTK_IS_STD_LAYOUT
:
7514 return (std_layout_type_p (type1
));
7516 case CPTK_IS_TRIVIAL
:
7517 return (trivial_type_p (type1
));
7519 case CPTK_IS_TRIVIALLY_ASSIGNABLE
:
7520 return is_trivially_xible (MODIFY_EXPR
, type1
, type2
);
7522 case CPTK_IS_TRIVIALLY_CONSTRUCTIBLE
:
7523 return is_trivially_xible (INIT_EXPR
, type1
, type2
);
7525 case CPTK_IS_TRIVIALLY_COPYABLE
:
7526 return (trivially_copyable_p (type1
));
7529 return (type_code1
== UNION_TYPE
);
7537 /* If TYPE is an array of unknown bound, or (possibly cv-qualified)
7538 void, or a complete type, returns true, otherwise false. */
7541 check_trait_type (tree type
)
7543 if (type
== NULL_TREE
)
7546 if (TREE_CODE (type
) == TREE_LIST
)
7547 return (check_trait_type (TREE_VALUE (type
))
7548 && check_trait_type (TREE_CHAIN (type
)));
7550 if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
)
7551 && COMPLETE_TYPE_P (TREE_TYPE (type
)))
7554 if (VOID_TYPE_P (type
))
7557 return !!complete_type_or_else (strip_array_types (type
), NULL_TREE
);
7560 /* Process a trait expression. */
7563 finish_trait_expr (cp_trait_kind kind
, tree type1
, tree type2
)
7565 if (type1
== error_mark_node
7566 || type2
== error_mark_node
)
7567 return error_mark_node
;
7569 if (processing_template_decl
)
7571 tree trait_expr
= make_node (TRAIT_EXPR
);
7572 TREE_TYPE (trait_expr
) = boolean_type_node
;
7573 TRAIT_EXPR_TYPE1 (trait_expr
) = type1
;
7574 TRAIT_EXPR_TYPE2 (trait_expr
) = type2
;
7575 TRAIT_EXPR_KIND (trait_expr
) = kind
;
7581 case CPTK_HAS_NOTHROW_ASSIGN
:
7582 case CPTK_HAS_TRIVIAL_ASSIGN
:
7583 case CPTK_HAS_NOTHROW_CONSTRUCTOR
:
7584 case CPTK_HAS_TRIVIAL_CONSTRUCTOR
:
7585 case CPTK_HAS_NOTHROW_COPY
:
7586 case CPTK_HAS_TRIVIAL_COPY
:
7587 case CPTK_HAS_TRIVIAL_DESTRUCTOR
:
7588 case CPTK_HAS_VIRTUAL_DESTRUCTOR
:
7589 case CPTK_IS_ABSTRACT
:
7592 case CPTK_IS_LITERAL_TYPE
:
7594 case CPTK_IS_POLYMORPHIC
:
7595 case CPTK_IS_STD_LAYOUT
:
7596 case CPTK_IS_TRIVIAL
:
7597 case CPTK_IS_TRIVIALLY_COPYABLE
:
7598 if (!check_trait_type (type1
))
7599 return error_mark_node
;
7602 case CPTK_IS_TRIVIALLY_ASSIGNABLE
:
7603 case CPTK_IS_TRIVIALLY_CONSTRUCTIBLE
:
7604 if (!check_trait_type (type1
)
7605 || !check_trait_type (type2
))
7606 return error_mark_node
;
7609 case CPTK_IS_BASE_OF
:
7610 if (NON_UNION_CLASS_TYPE_P (type1
) && NON_UNION_CLASS_TYPE_P (type2
)
7611 && !same_type_ignoring_top_level_qualifiers_p (type1
, type2
)
7612 && !complete_type_or_else (type2
, NULL_TREE
))
7613 /* We already issued an error. */
7614 return error_mark_node
;
7626 return (trait_expr_value (kind
, type1
, type2
)
7627 ? boolean_true_node
: boolean_false_node
);
7630 /* Do-nothing variants of functions to handle pragma FLOAT_CONST_DECIMAL64,
7631 which is ignored for C++. */
7634 set_float_const_decimal64 (void)
7639 clear_float_const_decimal64 (void)
7644 float_const_decimal64_p (void)
7650 /* Return true if T designates the implied `this' parameter. */
7653 is_this_parameter (tree t
)
7655 if (!DECL_P (t
) || DECL_NAME (t
) != this_identifier
)
7657 gcc_assert (TREE_CODE (t
) == PARM_DECL
|| is_capture_proxy (t
));
7661 /* Insert the deduced return type for an auto function. */
7664 apply_deduced_return_type (tree fco
, tree return_type
)
7668 if (return_type
== error_mark_node
)
7671 if (LAMBDA_FUNCTION_P (fco
))
7673 tree lambda
= CLASSTYPE_LAMBDA_EXPR (current_class_type
);
7674 LAMBDA_EXPR_RETURN_TYPE (lambda
) = return_type
;
7677 if (DECL_CONV_FN_P (fco
))
7678 DECL_NAME (fco
) = mangle_conv_op_name_for_type (return_type
);
7680 TREE_TYPE (fco
) = change_return_type (return_type
, TREE_TYPE (fco
));
7682 result
= DECL_RESULT (fco
);
7683 if (result
== NULL_TREE
)
7685 if (TREE_TYPE (result
) == return_type
)
7688 /* We already have a DECL_RESULT from start_preparsed_function.
7689 Now we need to redo the work it and allocate_struct_function
7690 did to reflect the new type. */
7691 gcc_assert (current_function_decl
== fco
);
7692 result
= build_decl (input_location
, RESULT_DECL
, NULL_TREE
,
7693 TYPE_MAIN_VARIANT (return_type
));
7694 DECL_ARTIFICIAL (result
) = 1;
7695 DECL_IGNORED_P (result
) = 1;
7696 cp_apply_type_quals_to_decl (cp_type_quals (return_type
),
7699 DECL_RESULT (fco
) = result
;
7701 if (!processing_template_decl
)
7703 if (!VOID_TYPE_P (TREE_TYPE (result
)))
7704 complete_type_or_else (TREE_TYPE (result
), NULL_TREE
);
7705 bool aggr
= aggregate_value_p (result
, fco
);
7706 #ifdef PCC_STATIC_STRUCT_RETURN
7707 cfun
->returns_pcc_struct
= aggr
;
7709 cfun
->returns_struct
= aggr
;
7714 /* DECL is a local variable or parameter from the surrounding scope of a
7715 lambda-expression. Returns the decltype for a use of the capture field
7716 for DECL even if it hasn't been captured yet. */
7719 capture_decltype (tree decl
)
7721 tree lam
= CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (current_function_decl
));
7722 /* FIXME do lookup instead of list walk? */
7723 tree cap
= value_member (decl
, LAMBDA_EXPR_CAPTURE_LIST (lam
));
7727 type
= TREE_TYPE (TREE_PURPOSE (cap
));
7729 switch (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lam
))
7732 error ("%qD is not captured", decl
);
7733 return error_mark_node
;
7736 type
= TREE_TYPE (decl
);
7737 if (TREE_CODE (type
) == REFERENCE_TYPE
7738 && TREE_CODE (TREE_TYPE (type
)) != FUNCTION_TYPE
)
7739 type
= TREE_TYPE (type
);
7742 case CPLD_REFERENCE
:
7743 type
= TREE_TYPE (decl
);
7744 if (TREE_CODE (type
) != REFERENCE_TYPE
)
7745 type
= build_reference_type (TREE_TYPE (decl
));
7752 if (TREE_CODE (type
) != REFERENCE_TYPE
)
7754 if (!LAMBDA_EXPR_MUTABLE_P (lam
))
7755 type
= cp_build_qualified_type (type
, (cp_type_quals (type
)
7757 type
= build_reference_type (type
);
7762 #include "gt-cp-semantics.h"