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 (TREE_CODE (orig_type
) != ENUMERAL_TYPE
)
1169 orig_type
= TREE_TYPE (cond
);
1170 if (cond
!= error_mark_node
)
1172 /* Warn if the condition has boolean value. */
1173 if (TREE_CODE (orig_type
) == BOOLEAN_TYPE
)
1174 warning_at (input_location
, OPT_Wswitch_bool
,
1175 "switch condition has type bool");
1179 Integral promotions are performed. */
1180 cond
= perform_integral_promotions (cond
);
1181 cond
= maybe_cleanup_point_expr (cond
);
1184 if (check_for_bare_parameter_packs (cond
))
1185 cond
= error_mark_node
;
1186 else if (!processing_template_decl
&& warn_sequence_point
)
1187 verify_sequence_points (cond
);
1189 finish_cond (&SWITCH_STMT_COND (switch_stmt
), cond
);
1190 SWITCH_STMT_TYPE (switch_stmt
) = orig_type
;
1191 add_stmt (switch_stmt
);
1192 push_switch (switch_stmt
);
1193 SWITCH_STMT_BODY (switch_stmt
) = push_stmt_list ();
1196 /* Finish the body of a switch-statement, which may be given by
1197 SWITCH_STMT. The COND to switch on is indicated. */
1200 finish_switch_stmt (tree switch_stmt
)
1204 SWITCH_STMT_BODY (switch_stmt
) =
1205 pop_stmt_list (SWITCH_STMT_BODY (switch_stmt
));
1208 scope
= SWITCH_STMT_SCOPE (switch_stmt
);
1209 SWITCH_STMT_SCOPE (switch_stmt
) = NULL
;
1210 add_stmt (do_poplevel (scope
));
1213 /* Begin a try-block. Returns a newly-created TRY_BLOCK if
1217 begin_try_block (void)
1219 tree r
= build_stmt (input_location
, TRY_BLOCK
, NULL_TREE
, NULL_TREE
);
1221 TRY_STMTS (r
) = push_stmt_list ();
1225 /* Likewise, for a function-try-block. The block returned in
1226 *COMPOUND_STMT is an artificial outer scope, containing the
1227 function-try-block. */
1230 begin_function_try_block (tree
*compound_stmt
)
1233 /* This outer scope does not exist in the C++ standard, but we need
1234 a place to put __FUNCTION__ and similar variables. */
1235 *compound_stmt
= begin_compound_stmt (0);
1236 r
= begin_try_block ();
1237 FN_TRY_BLOCK_P (r
) = 1;
1241 /* Finish a try-block, which may be given by TRY_BLOCK. */
1244 finish_try_block (tree try_block
)
1246 TRY_STMTS (try_block
) = pop_stmt_list (TRY_STMTS (try_block
));
1247 TRY_HANDLERS (try_block
) = push_stmt_list ();
1250 /* Finish the body of a cleanup try-block, which may be given by
1254 finish_cleanup_try_block (tree try_block
)
1256 TRY_STMTS (try_block
) = pop_stmt_list (TRY_STMTS (try_block
));
1259 /* Finish an implicitly generated try-block, with a cleanup is given
1263 finish_cleanup (tree cleanup
, tree try_block
)
1265 TRY_HANDLERS (try_block
) = cleanup
;
1266 CLEANUP_P (try_block
) = 1;
1269 /* Likewise, for a function-try-block. */
1272 finish_function_try_block (tree try_block
)
1274 finish_try_block (try_block
);
1275 /* FIXME : something queer about CTOR_INITIALIZER somehow following
1276 the try block, but moving it inside. */
1277 in_function_try_handler
= 1;
1280 /* Finish a handler-sequence for a try-block, which may be given by
1284 finish_handler_sequence (tree try_block
)
1286 TRY_HANDLERS (try_block
) = pop_stmt_list (TRY_HANDLERS (try_block
));
1287 check_handlers (TRY_HANDLERS (try_block
));
1290 /* Finish the handler-seq for a function-try-block, given by
1291 TRY_BLOCK. COMPOUND_STMT is the outer block created by
1292 begin_function_try_block. */
1295 finish_function_handler_sequence (tree try_block
, tree compound_stmt
)
1297 in_function_try_handler
= 0;
1298 finish_handler_sequence (try_block
);
1299 finish_compound_stmt (compound_stmt
);
1302 /* Begin a handler. Returns a HANDLER if appropriate. */
1305 begin_handler (void)
1309 r
= build_stmt (input_location
, HANDLER
, NULL_TREE
, NULL_TREE
);
1312 /* Create a binding level for the eh_info and the exception object
1314 HANDLER_BODY (r
) = do_pushlevel (sk_catch
);
1319 /* Finish the handler-parameters for a handler, which may be given by
1320 HANDLER. DECL is the declaration for the catch parameter, or NULL
1321 if this is a `catch (...)' clause. */
1324 finish_handler_parms (tree decl
, tree handler
)
1326 tree type
= NULL_TREE
;
1327 if (processing_template_decl
)
1331 decl
= pushdecl (decl
);
1332 decl
= push_template_decl (decl
);
1333 HANDLER_PARMS (handler
) = decl
;
1334 type
= TREE_TYPE (decl
);
1338 type
= expand_start_catch_block (decl
);
1339 HANDLER_TYPE (handler
) = type
;
1342 /* Finish a handler, which may be given by HANDLER. The BLOCKs are
1343 the return value from the matching call to finish_handler_parms. */
1346 finish_handler (tree handler
)
1348 if (!processing_template_decl
)
1349 expand_end_catch_block ();
1350 HANDLER_BODY (handler
) = do_poplevel (HANDLER_BODY (handler
));
1353 /* Begin a compound statement. FLAGS contains some bits that control the
1354 behavior and context. If BCS_NO_SCOPE is set, the compound statement
1355 does not define a scope. If BCS_FN_BODY is set, this is the outermost
1356 block of a function. If BCS_TRY_BLOCK is set, this is the block
1357 created on behalf of a TRY statement. Returns a token to be passed to
1358 finish_compound_stmt. */
1361 begin_compound_stmt (unsigned int flags
)
1365 if (flags
& BCS_NO_SCOPE
)
1367 r
= push_stmt_list ();
1368 STATEMENT_LIST_NO_SCOPE (r
) = 1;
1370 /* Normally, we try hard to keep the BLOCK for a statement-expression.
1371 But, if it's a statement-expression with a scopeless block, there's
1372 nothing to keep, and we don't want to accidentally keep a block
1373 *inside* the scopeless block. */
1374 keep_next_level (false);
1377 r
= do_pushlevel (flags
& BCS_TRY_BLOCK
? sk_try
: sk_block
);
1379 /* When processing a template, we need to remember where the braces were,
1380 so that we can set up identical scopes when instantiating the template
1381 later. BIND_EXPR is a handy candidate for this.
1382 Note that do_poplevel won't create a BIND_EXPR itself here (and thus
1383 result in nested BIND_EXPRs), since we don't build BLOCK nodes when
1384 processing templates. */
1385 if (processing_template_decl
)
1387 r
= build3 (BIND_EXPR
, NULL
, NULL
, r
, NULL
);
1388 BIND_EXPR_TRY_BLOCK (r
) = (flags
& BCS_TRY_BLOCK
) != 0;
1389 BIND_EXPR_BODY_BLOCK (r
) = (flags
& BCS_FN_BODY
) != 0;
1390 TREE_SIDE_EFFECTS (r
) = 1;
1396 /* Finish a compound-statement, which is given by STMT. */
1399 finish_compound_stmt (tree stmt
)
1401 if (TREE_CODE (stmt
) == BIND_EXPR
)
1403 tree body
= do_poplevel (BIND_EXPR_BODY (stmt
));
1404 /* If the STATEMENT_LIST is empty and this BIND_EXPR isn't special,
1405 discard the BIND_EXPR so it can be merged with the containing
1407 if (TREE_CODE (body
) == STATEMENT_LIST
1408 && STATEMENT_LIST_HEAD (body
) == NULL
1409 && !BIND_EXPR_BODY_BLOCK (stmt
)
1410 && !BIND_EXPR_TRY_BLOCK (stmt
))
1413 BIND_EXPR_BODY (stmt
) = body
;
1415 else if (STATEMENT_LIST_NO_SCOPE (stmt
))
1416 stmt
= pop_stmt_list (stmt
);
1419 /* Destroy any ObjC "super" receivers that may have been
1421 objc_clear_super_receiver ();
1423 stmt
= do_poplevel (stmt
);
1426 /* ??? See c_end_compound_stmt wrt statement expressions. */
1430 /* Finish an asm-statement, whose components are a STRING, some
1431 OUTPUT_OPERANDS, some INPUT_OPERANDS, some CLOBBERS and some
1432 LABELS. Also note whether the asm-statement should be
1433 considered volatile. */
1436 finish_asm_stmt (int volatile_p
, tree string
, tree output_operands
,
1437 tree input_operands
, tree clobbers
, tree labels
)
1441 int ninputs
= list_length (input_operands
);
1442 int noutputs
= list_length (output_operands
);
1444 if (!processing_template_decl
)
1446 const char *constraint
;
1447 const char **oconstraints
;
1448 bool allows_mem
, allows_reg
, is_inout
;
1452 oconstraints
= XALLOCAVEC (const char *, noutputs
);
1454 string
= resolve_asm_operand_names (string
, output_operands
,
1455 input_operands
, labels
);
1457 for (i
= 0, t
= output_operands
; t
; t
= TREE_CHAIN (t
), ++i
)
1459 operand
= TREE_VALUE (t
);
1461 /* ??? Really, this should not be here. Users should be using a
1462 proper lvalue, dammit. But there's a long history of using
1463 casts in the output operands. In cases like longlong.h, this
1464 becomes a primitive form of typechecking -- if the cast can be
1465 removed, then the output operand had a type of the proper width;
1466 otherwise we'll get an error. Gross, but ... */
1467 STRIP_NOPS (operand
);
1469 operand
= mark_lvalue_use (operand
);
1471 if (!lvalue_or_else (operand
, lv_asm
, tf_warning_or_error
))
1472 operand
= error_mark_node
;
1474 if (operand
!= error_mark_node
1475 && (TREE_READONLY (operand
)
1476 || CP_TYPE_CONST_P (TREE_TYPE (operand
))
1477 /* Functions are not modifiable, even though they are
1479 || TREE_CODE (TREE_TYPE (operand
)) == FUNCTION_TYPE
1480 || TREE_CODE (TREE_TYPE (operand
)) == METHOD_TYPE
1481 /* If it's an aggregate and any field is const, then it is
1482 effectively const. */
1483 || (CLASS_TYPE_P (TREE_TYPE (operand
))
1484 && C_TYPE_FIELDS_READONLY (TREE_TYPE (operand
)))))
1485 cxx_readonly_error (operand
, lv_asm
);
1487 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
1488 oconstraints
[i
] = constraint
;
1490 if (parse_output_constraint (&constraint
, i
, ninputs
, noutputs
,
1491 &allows_mem
, &allows_reg
, &is_inout
))
1493 /* If the operand is going to end up in memory,
1494 mark it addressable. */
1495 if (!allows_reg
&& !cxx_mark_addressable (operand
))
1496 operand
= error_mark_node
;
1499 operand
= error_mark_node
;
1501 TREE_VALUE (t
) = operand
;
1504 for (i
= 0, t
= input_operands
; t
; ++i
, t
= TREE_CHAIN (t
))
1506 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t
)));
1507 bool constraint_parsed
1508 = parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, 0,
1509 oconstraints
, &allows_mem
, &allows_reg
);
1510 /* If the operand is going to end up in memory, don't call
1511 decay_conversion. */
1512 if (constraint_parsed
&& !allows_reg
&& allows_mem
)
1513 operand
= mark_lvalue_use (TREE_VALUE (t
));
1515 operand
= decay_conversion (TREE_VALUE (t
), tf_warning_or_error
);
1517 /* If the type of the operand hasn't been determined (e.g.,
1518 because it involves an overloaded function), then issue
1519 an error message. There's no context available to
1520 resolve the overloading. */
1521 if (TREE_TYPE (operand
) == unknown_type_node
)
1523 error ("type of asm operand %qE could not be determined",
1525 operand
= error_mark_node
;
1528 if (constraint_parsed
)
1530 /* If the operand is going to end up in memory,
1531 mark it addressable. */
1532 if (!allows_reg
&& allows_mem
)
1534 /* Strip the nops as we allow this case. FIXME, this really
1535 should be rejected or made deprecated. */
1536 STRIP_NOPS (operand
);
1537 if (!cxx_mark_addressable (operand
))
1538 operand
= error_mark_node
;
1540 else if (!allows_reg
&& !allows_mem
)
1542 /* If constraint allows neither register nor memory,
1543 try harder to get a constant. */
1544 tree constop
= maybe_constant_value (operand
);
1545 if (TREE_CONSTANT (constop
))
1550 operand
= error_mark_node
;
1552 TREE_VALUE (t
) = operand
;
1556 r
= build_stmt (input_location
, ASM_EXPR
, string
,
1557 output_operands
, input_operands
,
1559 ASM_VOLATILE_P (r
) = volatile_p
|| noutputs
== 0;
1560 r
= maybe_cleanup_point_expr_void (r
);
1561 return add_stmt (r
);
1564 /* Finish a label with the indicated NAME. Returns the new label. */
1567 finish_label_stmt (tree name
)
1569 tree decl
= define_label (input_location
, name
);
1571 if (decl
== error_mark_node
)
1572 return error_mark_node
;
1574 add_stmt (build_stmt (input_location
, LABEL_EXPR
, decl
));
1579 /* Finish a series of declarations for local labels. G++ allows users
1580 to declare "local" labels, i.e., labels with scope. This extension
1581 is useful when writing code involving statement-expressions. */
1584 finish_label_decl (tree name
)
1586 if (!at_function_scope_p ())
1588 error ("__label__ declarations are only allowed in function scopes");
1592 add_decl_expr (declare_local_label (name
));
1595 /* When DECL goes out of scope, make sure that CLEANUP is executed. */
1598 finish_decl_cleanup (tree decl
, tree cleanup
)
1600 push_cleanup (decl
, cleanup
, false);
1603 /* If the current scope exits with an exception, run CLEANUP. */
1606 finish_eh_cleanup (tree cleanup
)
1608 push_cleanup (NULL
, cleanup
, true);
1611 /* The MEM_INITS is a list of mem-initializers, in reverse of the
1612 order they were written by the user. Each node is as for
1613 emit_mem_initializers. */
1616 finish_mem_initializers (tree mem_inits
)
1618 /* Reorder the MEM_INITS so that they are in the order they appeared
1619 in the source program. */
1620 mem_inits
= nreverse (mem_inits
);
1622 if (processing_template_decl
)
1626 for (mem
= mem_inits
; mem
; mem
= TREE_CHAIN (mem
))
1628 /* If the TREE_PURPOSE is a TYPE_PACK_EXPANSION, skip the
1629 check for bare parameter packs in the TREE_VALUE, because
1630 any parameter packs in the TREE_VALUE have already been
1631 bound as part of the TREE_PURPOSE. See
1632 make_pack_expansion for more information. */
1633 if (TREE_CODE (TREE_PURPOSE (mem
)) != TYPE_PACK_EXPANSION
1634 && check_for_bare_parameter_packs (TREE_VALUE (mem
)))
1635 TREE_VALUE (mem
) = error_mark_node
;
1638 add_stmt (build_min_nt_loc (UNKNOWN_LOCATION
,
1639 CTOR_INITIALIZER
, mem_inits
));
1642 emit_mem_initializers (mem_inits
);
1645 /* Obfuscate EXPR if it looks like an id-expression or member access so
1646 that the call to finish_decltype in do_auto_deduction will give the
1650 force_paren_expr (tree expr
)
1652 /* This is only needed for decltype(auto) in C++14. */
1653 if (cxx_dialect
< cxx14
)
1656 /* If we're in unevaluated context, we can't be deducing a
1657 return/initializer type, so we don't need to mess with this. */
1658 if (cp_unevaluated_operand
)
1661 if (!DECL_P (expr
) && TREE_CODE (expr
) != COMPONENT_REF
1662 && TREE_CODE (expr
) != SCOPE_REF
)
1665 if (TREE_CODE (expr
) == COMPONENT_REF
)
1666 REF_PARENTHESIZED_P (expr
) = true;
1667 else if (type_dependent_expression_p (expr
))
1668 expr
= build1 (PAREN_EXPR
, TREE_TYPE (expr
), expr
);
1671 cp_lvalue_kind kind
= lvalue_kind (expr
);
1672 if ((kind
& ~clk_class
) != clk_none
)
1674 tree type
= unlowered_expr_type (expr
);
1675 bool rval
= !!(kind
& clk_rvalueref
);
1676 type
= cp_build_reference_type (type
, rval
);
1677 /* This inhibits warnings in, eg, cxx_mark_addressable
1679 warning_sentinel
s (extra_warnings
);
1680 expr
= build_static_cast (type
, expr
, tf_error
);
1681 if (expr
!= error_mark_node
)
1682 REF_PARENTHESIZED_P (expr
) = true;
1689 /* Finish a parenthesized expression EXPR. */
1692 finish_parenthesized_expr (tree expr
)
1695 /* This inhibits warnings in c_common_truthvalue_conversion. */
1696 TREE_NO_WARNING (expr
) = 1;
1698 if (TREE_CODE (expr
) == OFFSET_REF
1699 || TREE_CODE (expr
) == SCOPE_REF
)
1700 /* [expr.unary.op]/3 The qualified id of a pointer-to-member must not be
1701 enclosed in parentheses. */
1702 PTRMEM_OK_P (expr
) = 0;
1704 if (TREE_CODE (expr
) == STRING_CST
)
1705 PAREN_STRING_LITERAL_P (expr
) = 1;
1707 expr
= force_paren_expr (expr
);
1712 /* Finish a reference to a non-static data member (DECL) that is not
1713 preceded by `.' or `->'. */
1716 finish_non_static_data_member (tree decl
, tree object
, tree qualifying_scope
)
1718 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
);
1722 tree scope
= qualifying_scope
;
1723 if (scope
== NULL_TREE
)
1724 scope
= context_for_name_lookup (decl
);
1725 object
= maybe_dummy_object (scope
, NULL
);
1728 object
= maybe_resolve_dummy (object
, true);
1729 if (object
== error_mark_node
)
1730 return error_mark_node
;
1732 /* DR 613/850: Can use non-static data members without an associated
1733 object in sizeof/decltype/alignof. */
1734 if (is_dummy_object (object
) && cp_unevaluated_operand
== 0
1735 && (!processing_template_decl
|| !current_class_ref
))
1737 if (current_function_decl
1738 && DECL_STATIC_FUNCTION_P (current_function_decl
))
1739 error ("invalid use of member %qD in static member function", decl
);
1741 error ("invalid use of non-static data member %qD", decl
);
1742 inform (DECL_SOURCE_LOCATION (decl
), "declared here");
1744 return error_mark_node
;
1747 if (current_class_ptr
)
1748 TREE_USED (current_class_ptr
) = 1;
1749 if (processing_template_decl
&& !qualifying_scope
)
1751 tree type
= TREE_TYPE (decl
);
1753 if (TREE_CODE (type
) == REFERENCE_TYPE
)
1754 /* Quals on the object don't matter. */;
1755 else if (PACK_EXPANSION_P (type
))
1756 /* Don't bother trying to represent this. */
1760 /* Set the cv qualifiers. */
1761 int quals
= cp_type_quals (TREE_TYPE (object
));
1763 if (DECL_MUTABLE_P (decl
))
1764 quals
&= ~TYPE_QUAL_CONST
;
1766 quals
|= cp_type_quals (TREE_TYPE (decl
));
1767 type
= cp_build_qualified_type (type
, quals
);
1770 return (convert_from_reference
1771 (build_min (COMPONENT_REF
, type
, object
, decl
, NULL_TREE
)));
1773 /* If PROCESSING_TEMPLATE_DECL is nonzero here, then
1774 QUALIFYING_SCOPE is also non-null. Wrap this in a SCOPE_REF
1776 else if (processing_template_decl
)
1777 return build_qualified_name (TREE_TYPE (decl
),
1780 /*template_p=*/false);
1783 tree access_type
= TREE_TYPE (object
);
1785 perform_or_defer_access_check (TYPE_BINFO (access_type
), decl
,
1786 decl
, tf_warning_or_error
);
1788 /* If the data member was named `C::M', convert `*this' to `C'
1790 if (qualifying_scope
)
1792 tree binfo
= NULL_TREE
;
1793 object
= build_scoped_ref (object
, qualifying_scope
,
1797 return build_class_member_access_expr (object
, decl
,
1798 /*access_path=*/NULL_TREE
,
1799 /*preserve_reference=*/false,
1800 tf_warning_or_error
);
1804 /* If we are currently parsing a template and we encountered a typedef
1805 TYPEDEF_DECL that is being accessed though CONTEXT, this function
1806 adds the typedef to a list tied to the current template.
1807 At template instantiation time, that list is walked and access check
1808 performed for each typedef.
1809 LOCATION is the location of the usage point of TYPEDEF_DECL. */
1812 add_typedef_to_current_template_for_access_check (tree typedef_decl
,
1814 location_t location
)
1816 tree template_info
= NULL
;
1817 tree cs
= current_scope ();
1819 if (!is_typedef_decl (typedef_decl
)
1821 || !CLASS_TYPE_P (context
)
1825 if (CLASS_TYPE_P (cs
) || TREE_CODE (cs
) == FUNCTION_DECL
)
1826 template_info
= get_template_info (cs
);
1829 && TI_TEMPLATE (template_info
)
1830 && !currently_open_class (context
))
1831 append_type_to_template_for_access_check (cs
, typedef_decl
,
1835 /* DECL was the declaration to which a qualified-id resolved. Issue
1836 an error message if it is not accessible. If OBJECT_TYPE is
1837 non-NULL, we have just seen `x->' or `x.' and OBJECT_TYPE is the
1838 type of `*x', or `x', respectively. If the DECL was named as
1839 `A::B' then NESTED_NAME_SPECIFIER is `A'. */
1842 check_accessibility_of_qualified_id (tree decl
,
1844 tree nested_name_specifier
)
1847 tree qualifying_type
= NULL_TREE
;
1849 /* If we are parsing a template declaration and if decl is a typedef,
1850 add it to a list tied to the template.
1851 At template instantiation time, that list will be walked and
1852 access check performed. */
1853 add_typedef_to_current_template_for_access_check (decl
,
1854 nested_name_specifier
1855 ? nested_name_specifier
1856 : DECL_CONTEXT (decl
),
1859 /* If we're not checking, return immediately. */
1860 if (deferred_access_no_check
)
1863 /* Determine the SCOPE of DECL. */
1864 scope
= context_for_name_lookup (decl
);
1865 /* If the SCOPE is not a type, then DECL is not a member. */
1866 if (!TYPE_P (scope
))
1868 /* Compute the scope through which DECL is being accessed. */
1870 /* OBJECT_TYPE might not be a class type; consider:
1872 class A { typedef int I; };
1876 In this case, we will have "A::I" as the DECL, but "I" as the
1878 && CLASS_TYPE_P (object_type
)
1879 && DERIVED_FROM_P (scope
, object_type
))
1880 /* If we are processing a `->' or `.' expression, use the type of the
1882 qualifying_type
= object_type
;
1883 else if (nested_name_specifier
)
1885 /* If the reference is to a non-static member of the
1886 current class, treat it as if it were referenced through
1889 if (DECL_NONSTATIC_MEMBER_P (decl
)
1890 && current_class_ptr
1891 && DERIVED_FROM_P (scope
, ct
= current_nonlambda_class_type ()))
1892 qualifying_type
= ct
;
1893 /* Otherwise, use the type indicated by the
1894 nested-name-specifier. */
1896 qualifying_type
= nested_name_specifier
;
1899 /* Otherwise, the name must be from the current class or one of
1901 qualifying_type
= currently_open_derived_class (scope
);
1904 /* It is possible for qualifying type to be a TEMPLATE_TYPE_PARM
1905 or similar in a default argument value. */
1906 && CLASS_TYPE_P (qualifying_type
)
1907 && !dependent_type_p (qualifying_type
))
1908 perform_or_defer_access_check (TYPE_BINFO (qualifying_type
), decl
,
1909 decl
, tf_warning_or_error
);
1912 /* EXPR is the result of a qualified-id. The QUALIFYING_CLASS was the
1913 class named to the left of the "::" operator. DONE is true if this
1914 expression is a complete postfix-expression; it is false if this
1915 expression is followed by '->', '[', '(', etc. ADDRESS_P is true
1916 iff this expression is the operand of '&'. TEMPLATE_P is true iff
1917 the qualified-id was of the form "A::template B". TEMPLATE_ARG_P
1918 is true iff this qualified name appears as a template argument. */
1921 finish_qualified_id_expr (tree qualifying_class
,
1926 bool template_arg_p
,
1927 tsubst_flags_t complain
)
1929 gcc_assert (TYPE_P (qualifying_class
));
1931 if (error_operand_p (expr
))
1932 return error_mark_node
;
1934 if ((DECL_P (expr
) || BASELINK_P (expr
))
1935 && !mark_used (expr
, complain
))
1936 return error_mark_node
;
1939 check_template_keyword (expr
);
1941 /* If EXPR occurs as the operand of '&', use special handling that
1942 permits a pointer-to-member. */
1943 if (address_p
&& done
)
1945 if (TREE_CODE (expr
) == SCOPE_REF
)
1946 expr
= TREE_OPERAND (expr
, 1);
1947 expr
= build_offset_ref (qualifying_class
, expr
,
1948 /*address_p=*/true, complain
);
1952 /* No need to check access within an enum. */
1953 if (TREE_CODE (qualifying_class
) == ENUMERAL_TYPE
)
1956 /* Within the scope of a class, turn references to non-static
1957 members into expression of the form "this->...". */
1959 /* But, within a template argument, we do not want make the
1960 transformation, as there is no "this" pointer. */
1962 else if (TREE_CODE (expr
) == FIELD_DECL
)
1964 push_deferring_access_checks (dk_no_check
);
1965 expr
= finish_non_static_data_member (expr
, NULL_TREE
,
1967 pop_deferring_access_checks ();
1969 else if (BASELINK_P (expr
) && !processing_template_decl
)
1971 /* See if any of the functions are non-static members. */
1972 /* If so, the expression may be relative to 'this'. */
1973 if (!shared_member_p (expr
)
1974 && current_class_ptr
1975 && DERIVED_FROM_P (qualifying_class
,
1976 current_nonlambda_class_type ()))
1977 expr
= (build_class_member_access_expr
1978 (maybe_dummy_object (qualifying_class
, NULL
),
1980 BASELINK_ACCESS_BINFO (expr
),
1981 /*preserve_reference=*/false,
1984 /* The expression is a qualified name whose address is not
1986 expr
= build_offset_ref (qualifying_class
, expr
, /*address_p=*/false,
1989 else if (BASELINK_P (expr
))
1993 /* In a template, return a SCOPE_REF for most qualified-ids
1994 so that we can check access at instantiation time. But if
1995 we're looking at a member of the current instantiation, we
1996 know we have access and building up the SCOPE_REF confuses
1997 non-type template argument handling. */
1998 if (processing_template_decl
1999 && !currently_open_class (qualifying_class
))
2000 expr
= build_qualified_name (TREE_TYPE (expr
),
2001 qualifying_class
, expr
,
2004 expr
= convert_from_reference (expr
);
2010 /* Begin a statement-expression. The value returned must be passed to
2011 finish_stmt_expr. */
2014 begin_stmt_expr (void)
2016 return push_stmt_list ();
2019 /* Process the final expression of a statement expression. EXPR can be
2020 NULL, if the final expression is empty. Return a STATEMENT_LIST
2021 containing all the statements in the statement-expression, or
2022 ERROR_MARK_NODE if there was an error. */
2025 finish_stmt_expr_expr (tree expr
, tree stmt_expr
)
2027 if (error_operand_p (expr
))
2029 /* The type of the statement-expression is the type of the last
2031 TREE_TYPE (stmt_expr
) = error_mark_node
;
2032 return error_mark_node
;
2035 /* If the last statement does not have "void" type, then the value
2036 of the last statement is the value of the entire expression. */
2039 tree type
= TREE_TYPE (expr
);
2041 if (processing_template_decl
)
2043 expr
= build_stmt (input_location
, EXPR_STMT
, expr
);
2044 expr
= add_stmt (expr
);
2045 /* Mark the last statement so that we can recognize it as such at
2046 template-instantiation time. */
2047 EXPR_STMT_STMT_EXPR_RESULT (expr
) = 1;
2049 else if (VOID_TYPE_P (type
))
2051 /* Just treat this like an ordinary statement. */
2052 expr
= finish_expr_stmt (expr
);
2056 /* It actually has a value we need to deal with. First, force it
2057 to be an rvalue so that we won't need to build up a copy
2058 constructor call later when we try to assign it to something. */
2059 expr
= force_rvalue (expr
, tf_warning_or_error
);
2060 if (error_operand_p (expr
))
2061 return error_mark_node
;
2063 /* Update for array-to-pointer decay. */
2064 type
= TREE_TYPE (expr
);
2066 /* Wrap it in a CLEANUP_POINT_EXPR and add it to the list like a
2067 normal statement, but don't convert to void or actually add
2069 if (TREE_CODE (expr
) != CLEANUP_POINT_EXPR
)
2070 expr
= maybe_cleanup_point_expr (expr
);
2074 /* The type of the statement-expression is the type of the last
2076 TREE_TYPE (stmt_expr
) = type
;
2082 /* Finish a statement-expression. EXPR should be the value returned
2083 by the previous begin_stmt_expr. Returns an expression
2084 representing the statement-expression. */
2087 finish_stmt_expr (tree stmt_expr
, bool has_no_scope
)
2092 if (error_operand_p (stmt_expr
))
2094 pop_stmt_list (stmt_expr
);
2095 return error_mark_node
;
2098 gcc_assert (TREE_CODE (stmt_expr
) == STATEMENT_LIST
);
2100 type
= TREE_TYPE (stmt_expr
);
2101 result
= pop_stmt_list (stmt_expr
);
2102 TREE_TYPE (result
) = type
;
2104 if (processing_template_decl
)
2106 result
= build_min (STMT_EXPR
, type
, result
);
2107 TREE_SIDE_EFFECTS (result
) = 1;
2108 STMT_EXPR_NO_SCOPE (result
) = has_no_scope
;
2110 else if (CLASS_TYPE_P (type
))
2112 /* Wrap the statement-expression in a TARGET_EXPR so that the
2113 temporary object created by the final expression is destroyed at
2114 the end of the full-expression containing the
2115 statement-expression. */
2116 result
= force_target_expr (type
, result
, tf_warning_or_error
);
2122 /* Returns the expression which provides the value of STMT_EXPR. */
2125 stmt_expr_value_expr (tree stmt_expr
)
2127 tree t
= STMT_EXPR_STMT (stmt_expr
);
2129 if (TREE_CODE (t
) == BIND_EXPR
)
2130 t
= BIND_EXPR_BODY (t
);
2132 if (TREE_CODE (t
) == STATEMENT_LIST
&& STATEMENT_LIST_TAIL (t
))
2133 t
= STATEMENT_LIST_TAIL (t
)->stmt
;
2135 if (TREE_CODE (t
) == EXPR_STMT
)
2136 t
= EXPR_STMT_EXPR (t
);
2141 /* Return TRUE iff EXPR_STMT is an empty list of
2142 expression statements. */
2145 empty_expr_stmt_p (tree expr_stmt
)
2147 tree body
= NULL_TREE
;
2149 if (expr_stmt
== void_node
)
2154 if (TREE_CODE (expr_stmt
) == EXPR_STMT
)
2155 body
= EXPR_STMT_EXPR (expr_stmt
);
2156 else if (TREE_CODE (expr_stmt
) == STATEMENT_LIST
)
2162 if (TREE_CODE (body
) == STATEMENT_LIST
)
2163 return tsi_end_p (tsi_start (body
));
2165 return empty_expr_stmt_p (body
);
2170 /* Perform Koenig lookup. FN is the postfix-expression representing
2171 the function (or functions) to call; ARGS are the arguments to the
2172 call. Returns the functions to be considered by overload resolution. */
2175 perform_koenig_lookup (tree fn
, vec
<tree
, va_gc
> *args
,
2176 tsubst_flags_t complain
)
2178 tree identifier
= NULL_TREE
;
2179 tree functions
= NULL_TREE
;
2180 tree tmpl_args
= NULL_TREE
;
2181 bool template_id
= false;
2183 if (TREE_CODE (fn
) == TEMPLATE_ID_EXPR
)
2185 /* Use a separate flag to handle null args. */
2187 tmpl_args
= TREE_OPERAND (fn
, 1);
2188 fn
= TREE_OPERAND (fn
, 0);
2191 /* Find the name of the overloaded function. */
2192 if (identifier_p (fn
))
2194 else if (is_overloaded_fn (fn
))
2197 identifier
= DECL_NAME (get_first_fn (functions
));
2199 else if (DECL_P (fn
))
2202 identifier
= DECL_NAME (fn
);
2205 /* A call to a namespace-scope function using an unqualified name.
2207 Do Koenig lookup -- unless any of the arguments are
2209 if (!any_type_dependent_arguments_p (args
)
2210 && !any_dependent_template_arguments_p (tmpl_args
))
2212 fn
= lookup_arg_dependent (identifier
, functions
, args
);
2215 /* The unqualified name could not be resolved. */
2217 fn
= unqualified_fn_lookup_error (identifier
);
2223 if (fn
&& template_id
)
2224 fn
= build2 (TEMPLATE_ID_EXPR
, unknown_type_node
, fn
, tmpl_args
);
2229 /* Generate an expression for `FN (ARGS)'. This may change the
2232 If DISALLOW_VIRTUAL is true, the call to FN will be not generated
2233 as a virtual call, even if FN is virtual. (This flag is set when
2234 encountering an expression where the function name is explicitly
2235 qualified. For example a call to `X::f' never generates a virtual
2238 Returns code for the call. */
2241 finish_call_expr (tree fn
, vec
<tree
, va_gc
> **args
, bool disallow_virtual
,
2242 bool koenig_p
, tsubst_flags_t complain
)
2246 vec
<tree
, va_gc
> *orig_args
= NULL
;
2248 if (fn
== error_mark_node
)
2249 return error_mark_node
;
2251 gcc_assert (!TYPE_P (fn
));
2255 if (processing_template_decl
)
2257 /* If the call expression is dependent, build a CALL_EXPR node
2258 with no type; type_dependent_expression_p recognizes
2259 expressions with no type as being dependent. */
2260 if (type_dependent_expression_p (fn
)
2261 || any_type_dependent_arguments_p (*args
)
2262 /* For a non-static member function that doesn't have an
2263 explicit object argument, we need to specifically
2264 test the type dependency of the "this" pointer because it
2265 is not included in *ARGS even though it is considered to
2266 be part of the list of arguments. Note that this is
2267 related to CWG issues 515 and 1005. */
2268 || (TREE_CODE (fn
) != COMPONENT_REF
2269 && non_static_member_function_p (fn
)
2270 && current_class_ref
2271 && type_dependent_expression_p (current_class_ref
)))
2273 result
= build_nt_call_vec (fn
, *args
);
2274 SET_EXPR_LOCATION (result
, EXPR_LOC_OR_LOC (fn
, input_location
));
2275 KOENIG_LOOKUP_P (result
) = koenig_p
;
2280 tree fndecl
= OVL_CURRENT (fn
);
2281 if (TREE_CODE (fndecl
) != FUNCTION_DECL
2282 || !TREE_THIS_VOLATILE (fndecl
))
2288 current_function_returns_abnormally
= 1;
2292 orig_args
= make_tree_vector_copy (*args
);
2293 if (!BASELINK_P (fn
)
2294 && TREE_CODE (fn
) != PSEUDO_DTOR_EXPR
2295 && TREE_TYPE (fn
) != unknown_type_node
)
2296 fn
= build_non_dependent_expr (fn
);
2297 make_args_non_dependent (*args
);
2300 if (TREE_CODE (fn
) == COMPONENT_REF
)
2302 tree member
= TREE_OPERAND (fn
, 1);
2303 if (BASELINK_P (member
))
2305 tree object
= TREE_OPERAND (fn
, 0);
2306 return build_new_method_call (object
, member
,
2309 ? LOOKUP_NORMAL
| LOOKUP_NONVIRTUAL
2316 /* Per 13.3.1.1, '(&f)(...)' is the same as '(f)(...)'. */
2317 if (TREE_CODE (fn
) == ADDR_EXPR
2318 && TREE_CODE (TREE_OPERAND (fn
, 0)) == OVERLOAD
)
2319 fn
= TREE_OPERAND (fn
, 0);
2321 if (is_overloaded_fn (fn
))
2322 fn
= baselink_for_fns (fn
);
2325 if (BASELINK_P (fn
))
2329 /* A call to a member function. From [over.call.func]:
2331 If the keyword this is in scope and refers to the class of
2332 that member function, or a derived class thereof, then the
2333 function call is transformed into a qualified function call
2334 using (*this) as the postfix-expression to the left of the
2335 . operator.... [Otherwise] a contrived object of type T
2336 becomes the implied object argument.
2340 struct A { void f(); };
2341 struct B : public A {};
2342 struct C : public A { void g() { B::f(); }};
2344 "the class of that member function" refers to `A'. But 11.2
2345 [class.access.base] says that we need to convert 'this' to B* as
2346 part of the access, so we pass 'B' to maybe_dummy_object. */
2348 object
= maybe_dummy_object (BINFO_TYPE (BASELINK_ACCESS_BINFO (fn
)),
2351 if (processing_template_decl
)
2353 if (type_dependent_expression_p (object
))
2355 tree ret
= build_nt_call_vec (orig_fn
, orig_args
);
2356 release_tree_vector (orig_args
);
2359 object
= build_non_dependent_expr (object
);
2362 result
= build_new_method_call (object
, fn
, args
, NULL_TREE
,
2364 ? LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
2369 else if (is_overloaded_fn (fn
))
2371 /* If the function is an overloaded builtin, resolve it. */
2372 if (TREE_CODE (fn
) == FUNCTION_DECL
2373 && (DECL_BUILT_IN_CLASS (fn
) == BUILT_IN_NORMAL
2374 || DECL_BUILT_IN_CLASS (fn
) == BUILT_IN_MD
))
2375 result
= resolve_overloaded_builtin (input_location
, fn
, *args
);
2379 if (warn_sizeof_pointer_memaccess
2380 && (complain
& tf_warning
)
2381 && !vec_safe_is_empty (*args
)
2382 && !processing_template_decl
)
2384 location_t sizeof_arg_loc
[3];
2387 for (i
= 0; i
< 3; i
++)
2391 sizeof_arg_loc
[i
] = UNKNOWN_LOCATION
;
2392 sizeof_arg
[i
] = NULL_TREE
;
2393 if (i
>= (*args
)->length ())
2396 if (TREE_CODE (t
) != SIZEOF_EXPR
)
2398 if (SIZEOF_EXPR_TYPE_P (t
))
2399 sizeof_arg
[i
] = TREE_TYPE (TREE_OPERAND (t
, 0));
2401 sizeof_arg
[i
] = TREE_OPERAND (t
, 0);
2402 sizeof_arg_loc
[i
] = EXPR_LOCATION (t
);
2404 sizeof_pointer_memaccess_warning
2405 (sizeof_arg_loc
, fn
, *args
,
2406 sizeof_arg
, same_type_ignoring_top_level_qualifiers_p
);
2409 /* A call to a namespace-scope function. */
2410 result
= build_new_function_call (fn
, args
, koenig_p
, complain
);
2413 else if (TREE_CODE (fn
) == PSEUDO_DTOR_EXPR
)
2415 if (!vec_safe_is_empty (*args
))
2416 error ("arguments to destructor are not allowed");
2417 /* Mark the pseudo-destructor call as having side-effects so
2418 that we do not issue warnings about its use. */
2419 result
= build1 (NOP_EXPR
,
2421 TREE_OPERAND (fn
, 0));
2422 TREE_SIDE_EFFECTS (result
) = 1;
2424 else if (CLASS_TYPE_P (TREE_TYPE (fn
)))
2425 /* If the "function" is really an object of class type, it might
2426 have an overloaded `operator ()'. */
2427 result
= build_op_call (fn
, args
, complain
);
2430 /* A call where the function is unknown. */
2431 result
= cp_build_function_call_vec (fn
, args
, complain
);
2433 if (processing_template_decl
&& result
!= error_mark_node
)
2435 if (INDIRECT_REF_P (result
))
2436 result
= TREE_OPERAND (result
, 0);
2437 result
= build_call_vec (TREE_TYPE (result
), orig_fn
, orig_args
);
2438 SET_EXPR_LOCATION (result
, input_location
);
2439 KOENIG_LOOKUP_P (result
) = koenig_p
;
2440 release_tree_vector (orig_args
);
2441 result
= convert_from_reference (result
);
2446 /* Free garbage OVERLOADs from arg-dependent lookup. */
2447 tree next
= NULL_TREE
;
2449 fn
&& TREE_CODE (fn
) == OVERLOAD
&& OVL_ARG_DEPENDENT (fn
);
2452 if (processing_template_decl
)
2453 /* In a template, we'll re-use them at instantiation time. */
2454 OVL_ARG_DEPENDENT (fn
) = false;
2457 next
= OVL_CHAIN (fn
);
2466 /* Finish a call to a postfix increment or decrement or EXPR. (Which
2467 is indicated by CODE, which should be POSTINCREMENT_EXPR or
2468 POSTDECREMENT_EXPR.) */
2471 finish_increment_expr (tree expr
, enum tree_code code
)
2473 return build_x_unary_op (input_location
, code
, expr
, tf_warning_or_error
);
2476 /* Finish a use of `this'. Returns an expression for `this'. */
2479 finish_this_expr (void)
2481 tree result
= NULL_TREE
;
2483 if (current_class_ptr
)
2485 tree type
= TREE_TYPE (current_class_ref
);
2487 /* In a lambda expression, 'this' refers to the captured 'this'. */
2488 if (LAMBDA_TYPE_P (type
))
2489 result
= lambda_expr_this_capture (CLASSTYPE_LAMBDA_EXPR (type
), true);
2491 result
= current_class_ptr
;
2495 /* The keyword 'this' is a prvalue expression. */
2496 return rvalue (result
);
2498 tree fn
= current_nonlambda_function ();
2499 if (fn
&& DECL_STATIC_FUNCTION_P (fn
))
2500 error ("%<this%> is unavailable for static member functions");
2502 error ("invalid use of %<this%> in non-member function");
2504 error ("invalid use of %<this%> at top level");
2505 return error_mark_node
;
2508 /* Finish a pseudo-destructor expression. If SCOPE is NULL, the
2509 expression was of the form `OBJECT.~DESTRUCTOR' where DESTRUCTOR is
2510 the TYPE for the type given. If SCOPE is non-NULL, the expression
2511 was of the form `OBJECT.SCOPE::~DESTRUCTOR'. */
2514 finish_pseudo_destructor_expr (tree object
, tree scope
, tree destructor
,
2517 if (object
== error_mark_node
|| destructor
== error_mark_node
)
2518 return error_mark_node
;
2520 gcc_assert (TYPE_P (destructor
));
2522 if (!processing_template_decl
)
2524 if (scope
== error_mark_node
)
2526 error_at (loc
, "invalid qualifying scope in pseudo-destructor name");
2527 return error_mark_node
;
2529 if (is_auto (destructor
))
2530 destructor
= TREE_TYPE (object
);
2531 if (scope
&& TYPE_P (scope
) && !check_dtor_name (scope
, destructor
))
2534 "qualified type %qT does not match destructor name ~%qT",
2536 return error_mark_node
;
2540 /* [expr.pseudo] says both:
2542 The type designated by the pseudo-destructor-name shall be
2543 the same as the object type.
2547 The cv-unqualified versions of the object type and of the
2548 type designated by the pseudo-destructor-name shall be the
2551 We implement the more generous second sentence, since that is
2552 what most other compilers do. */
2553 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (object
),
2556 error_at (loc
, "%qE is not of type %qT", object
, destructor
);
2557 return error_mark_node
;
2561 return build3_loc (loc
, PSEUDO_DTOR_EXPR
, void_type_node
, object
,
2565 /* Finish an expression of the form CODE EXPR. */
2568 finish_unary_op_expr (location_t loc
, enum tree_code code
, tree expr
,
2569 tsubst_flags_t complain
)
2571 tree result
= build_x_unary_op (loc
, code
, expr
, complain
);
2572 if ((complain
& tf_warning
)
2573 && TREE_OVERFLOW_P (result
) && !TREE_OVERFLOW_P (expr
))
2574 overflow_warning (input_location
, result
);
2579 /* Finish a compound-literal expression. TYPE is the type to which
2580 the CONSTRUCTOR in COMPOUND_LITERAL is being cast. */
2583 finish_compound_literal (tree type
, tree compound_literal
,
2584 tsubst_flags_t complain
)
2586 if (type
== error_mark_node
)
2587 return error_mark_node
;
2589 if (TREE_CODE (type
) == REFERENCE_TYPE
)
2592 = finish_compound_literal (TREE_TYPE (type
), compound_literal
,
2594 return cp_build_c_cast (type
, compound_literal
, complain
);
2597 if (!TYPE_OBJ_P (type
))
2599 if (complain
& tf_error
)
2600 error ("compound literal of non-object type %qT", type
);
2601 return error_mark_node
;
2604 if (processing_template_decl
)
2606 TREE_TYPE (compound_literal
) = type
;
2607 /* Mark the expression as a compound literal. */
2608 TREE_HAS_CONSTRUCTOR (compound_literal
) = 1;
2609 return compound_literal
;
2612 type
= complete_type (type
);
2614 if (TYPE_NON_AGGREGATE_CLASS (type
))
2616 /* Trying to deal with a CONSTRUCTOR instead of a TREE_LIST
2617 everywhere that deals with function arguments would be a pain, so
2618 just wrap it in a TREE_LIST. The parser set a flag so we know
2619 that it came from T{} rather than T({}). */
2620 CONSTRUCTOR_IS_DIRECT_INIT (compound_literal
) = 1;
2621 compound_literal
= build_tree_list (NULL_TREE
, compound_literal
);
2622 return build_functional_cast (type
, compound_literal
, complain
);
2625 if (TREE_CODE (type
) == ARRAY_TYPE
2626 && check_array_initializer (NULL_TREE
, type
, compound_literal
))
2627 return error_mark_node
;
2628 compound_literal
= reshape_init (type
, compound_literal
, complain
);
2629 if (SCALAR_TYPE_P (type
)
2630 && !BRACE_ENCLOSED_INITIALIZER_P (compound_literal
)
2631 && !check_narrowing (type
, compound_literal
, complain
))
2632 return error_mark_node
;
2633 if (TREE_CODE (type
) == ARRAY_TYPE
2634 && TYPE_DOMAIN (type
) == NULL_TREE
)
2636 cp_complete_array_type_or_error (&type
, compound_literal
,
2638 if (type
== error_mark_node
)
2639 return error_mark_node
;
2641 compound_literal
= digest_init (type
, compound_literal
, complain
);
2642 if (TREE_CODE (compound_literal
) == CONSTRUCTOR
)
2643 TREE_HAS_CONSTRUCTOR (compound_literal
) = true;
2644 /* Put static/constant array temporaries in static variables, but always
2645 represent class temporaries with TARGET_EXPR so we elide copies. */
2646 if ((!at_function_scope_p () || CP_TYPE_CONST_P (type
))
2647 && TREE_CODE (type
) == ARRAY_TYPE
2648 && !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
2649 && initializer_constant_valid_p (compound_literal
, type
))
2651 tree decl
= create_temporary_var (type
);
2652 DECL_INITIAL (decl
) = compound_literal
;
2653 TREE_STATIC (decl
) = 1;
2654 if (literal_type_p (type
) && CP_TYPE_CONST_NON_VOLATILE_P (type
))
2656 /* 5.19 says that a constant expression can include an
2657 lvalue-rvalue conversion applied to "a glvalue of literal type
2658 that refers to a non-volatile temporary object initialized
2659 with a constant expression". Rather than try to communicate
2660 that this VAR_DECL is a temporary, just mark it constexpr. */
2661 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
2662 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = true;
2663 TREE_CONSTANT (decl
) = true;
2665 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
2666 decl
= pushdecl_top_level (decl
);
2667 DECL_NAME (decl
) = make_anon_name ();
2668 SET_DECL_ASSEMBLER_NAME (decl
, DECL_NAME (decl
));
2669 /* Make sure the destructor is callable. */
2670 tree clean
= cxx_maybe_build_cleanup (decl
, complain
);
2671 if (clean
== error_mark_node
)
2672 return error_mark_node
;
2676 return get_target_expr_sfinae (compound_literal
, complain
);
2679 /* Return the declaration for the function-name variable indicated by
2683 finish_fname (tree id
)
2687 decl
= fname_decl (input_location
, C_RID_CODE (id
), id
);
2688 if (processing_template_decl
&& current_function_decl
2689 && decl
!= error_mark_node
)
2690 decl
= DECL_NAME (decl
);
2694 /* Finish a translation unit. */
2697 finish_translation_unit (void)
2699 /* In case there were missing closebraces,
2700 get us back to the global binding level. */
2702 while (current_namespace
!= global_namespace
)
2705 /* Do file scope __FUNCTION__ et al. */
2706 finish_fname_decls ();
2709 /* Finish a template type parameter, specified as AGGR IDENTIFIER.
2710 Returns the parameter. */
2713 finish_template_type_parm (tree aggr
, tree identifier
)
2715 if (aggr
!= class_type_node
)
2717 permerror (input_location
, "template type parameters must use the keyword %<class%> or %<typename%>");
2718 aggr
= class_type_node
;
2721 return build_tree_list (aggr
, identifier
);
2724 /* Finish a template template parameter, specified as AGGR IDENTIFIER.
2725 Returns the parameter. */
2728 finish_template_template_parm (tree aggr
, tree identifier
)
2730 tree decl
= build_decl (input_location
,
2731 TYPE_DECL
, identifier
, NULL_TREE
);
2732 tree tmpl
= build_lang_decl (TEMPLATE_DECL
, identifier
, NULL_TREE
);
2733 DECL_TEMPLATE_PARMS (tmpl
) = current_template_parms
;
2734 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
2735 DECL_ARTIFICIAL (decl
) = 1;
2736 end_template_decl ();
2738 gcc_assert (DECL_TEMPLATE_PARMS (tmpl
));
2740 check_default_tmpl_args (decl
, DECL_TEMPLATE_PARMS (tmpl
),
2741 /*is_primary=*/true, /*is_partial=*/false,
2744 return finish_template_type_parm (aggr
, tmpl
);
2747 /* ARGUMENT is the default-argument value for a template template
2748 parameter. If ARGUMENT is invalid, issue error messages and return
2749 the ERROR_MARK_NODE. Otherwise, ARGUMENT itself is returned. */
2752 check_template_template_default_arg (tree argument
)
2754 if (TREE_CODE (argument
) != TEMPLATE_DECL
2755 && TREE_CODE (argument
) != TEMPLATE_TEMPLATE_PARM
2756 && TREE_CODE (argument
) != UNBOUND_CLASS_TEMPLATE
)
2758 if (TREE_CODE (argument
) == TYPE_DECL
)
2759 error ("invalid use of type %qT as a default value for a template "
2760 "template-parameter", TREE_TYPE (argument
));
2762 error ("invalid default argument for a template template parameter");
2763 return error_mark_node
;
2769 /* Begin a class definition, as indicated by T. */
2772 begin_class_definition (tree t
)
2774 if (error_operand_p (t
) || error_operand_p (TYPE_MAIN_DECL (t
)))
2775 return error_mark_node
;
2777 if (processing_template_parmlist
)
2779 error ("definition of %q#T inside template parameter list", t
);
2780 return error_mark_node
;
2783 /* According to the C++ ABI, decimal classes defined in ISO/IEC TR 24733
2784 are passed the same as decimal scalar types. */
2785 if (TREE_CODE (t
) == RECORD_TYPE
2786 && !processing_template_decl
)
2788 tree ns
= TYPE_CONTEXT (t
);
2789 if (ns
&& TREE_CODE (ns
) == NAMESPACE_DECL
2790 && DECL_CONTEXT (ns
) == std_node
2792 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (ns
)), "decimal"))
2794 const char *n
= TYPE_NAME_STRING (t
);
2795 if ((strcmp (n
, "decimal32") == 0)
2796 || (strcmp (n
, "decimal64") == 0)
2797 || (strcmp (n
, "decimal128") == 0))
2798 TYPE_TRANSPARENT_AGGR (t
) = 1;
2802 /* A non-implicit typename comes from code like:
2804 template <typename T> struct A {
2805 template <typename U> struct A<T>::B ...
2807 This is erroneous. */
2808 else if (TREE_CODE (t
) == TYPENAME_TYPE
)
2810 error ("invalid definition of qualified type %qT", t
);
2811 t
= error_mark_node
;
2814 if (t
== error_mark_node
|| ! MAYBE_CLASS_TYPE_P (t
))
2816 t
= make_class_type (RECORD_TYPE
);
2817 pushtag (make_anon_name (), t
, /*tag_scope=*/ts_current
);
2820 if (TYPE_BEING_DEFINED (t
))
2822 t
= make_class_type (TREE_CODE (t
));
2823 pushtag (TYPE_IDENTIFIER (t
), t
, /*tag_scope=*/ts_current
);
2825 maybe_process_partial_specialization (t
);
2827 TYPE_BEING_DEFINED (t
) = 1;
2828 class_binding_level
->defining_class_p
= 1;
2830 if (flag_pack_struct
)
2833 TYPE_PACKED (t
) = 1;
2834 /* Even though the type is being defined for the first time
2835 here, there might have been a forward declaration, so there
2836 might be cv-qualified variants of T. */
2837 for (v
= TYPE_NEXT_VARIANT (t
); v
; v
= TYPE_NEXT_VARIANT (v
))
2838 TYPE_PACKED (v
) = 1;
2840 /* Reset the interface data, at the earliest possible
2841 moment, as it might have been set via a class foo;
2843 if (! TYPE_ANONYMOUS_P (t
))
2845 struct c_fileinfo
*finfo
= \
2846 get_fileinfo (LOCATION_FILE (input_location
));
2847 CLASSTYPE_INTERFACE_ONLY (t
) = finfo
->interface_only
;
2848 SET_CLASSTYPE_INTERFACE_UNKNOWN_X
2849 (t
, finfo
->interface_unknown
);
2851 reset_specialization();
2853 /* Make a declaration for this class in its own scope. */
2854 build_self_reference ();
2859 /* Finish the member declaration given by DECL. */
2862 finish_member_declaration (tree decl
)
2864 if (decl
== error_mark_node
|| decl
== NULL_TREE
)
2867 if (decl
== void_type_node
)
2868 /* The COMPONENT was a friend, not a member, and so there's
2869 nothing for us to do. */
2872 /* We should see only one DECL at a time. */
2873 gcc_assert (DECL_CHAIN (decl
) == NULL_TREE
);
2875 /* Set up access control for DECL. */
2877 = (current_access_specifier
== access_private_node
);
2878 TREE_PROTECTED (decl
)
2879 = (current_access_specifier
== access_protected_node
);
2880 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
2882 TREE_PRIVATE (DECL_TEMPLATE_RESULT (decl
)) = TREE_PRIVATE (decl
);
2883 TREE_PROTECTED (DECL_TEMPLATE_RESULT (decl
)) = TREE_PROTECTED (decl
);
2886 /* Mark the DECL as a member of the current class, unless it's
2887 a member of an enumeration. */
2888 if (TREE_CODE (decl
) != CONST_DECL
)
2889 DECL_CONTEXT (decl
) = current_class_type
;
2891 /* Check for bare parameter packs in the member variable declaration. */
2892 if (TREE_CODE (decl
) == FIELD_DECL
)
2894 if (check_for_bare_parameter_packs (TREE_TYPE (decl
)))
2895 TREE_TYPE (decl
) = error_mark_node
;
2896 if (check_for_bare_parameter_packs (DECL_ATTRIBUTES (decl
)))
2897 DECL_ATTRIBUTES (decl
) = NULL_TREE
;
2902 A C language linkage is ignored for the names of class members
2903 and the member function type of class member functions. */
2904 if (DECL_LANG_SPECIFIC (decl
) && DECL_LANGUAGE (decl
) == lang_c
)
2905 SET_DECL_LANGUAGE (decl
, lang_cplusplus
);
2907 /* Put functions on the TYPE_METHODS list and everything else on the
2908 TYPE_FIELDS list. Note that these are built up in reverse order.
2909 We reverse them (to obtain declaration order) in finish_struct. */
2910 if (DECL_DECLARES_FUNCTION_P (decl
))
2912 /* We also need to add this function to the
2913 CLASSTYPE_METHOD_VEC. */
2914 if (add_method (current_class_type
, decl
, NULL_TREE
))
2916 DECL_CHAIN (decl
) = TYPE_METHODS (current_class_type
);
2917 TYPE_METHODS (current_class_type
) = decl
;
2919 maybe_add_class_template_decl_list (current_class_type
, decl
,
2923 /* Enter the DECL into the scope of the class, if the class
2924 isn't a closure (whose fields are supposed to be unnamed). */
2925 else if (CLASSTYPE_LAMBDA_EXPR (current_class_type
)
2926 || pushdecl_class_level (decl
))
2928 if (TREE_CODE (decl
) == USING_DECL
)
2930 /* For now, ignore class-scope USING_DECLS, so that
2931 debugging backends do not see them. */
2932 DECL_IGNORED_P (decl
) = 1;
2935 /* All TYPE_DECLs go at the end of TYPE_FIELDS. Ordinary fields
2936 go at the beginning. The reason is that lookup_field_1
2937 searches the list in order, and we want a field name to
2938 override a type name so that the "struct stat hack" will
2939 work. In particular:
2941 struct S { enum E { }; int E } s;
2944 is valid. In addition, the FIELD_DECLs must be maintained in
2945 declaration order so that class layout works as expected.
2946 However, we don't need that order until class layout, so we
2947 save a little time by putting FIELD_DECLs on in reverse order
2948 here, and then reversing them in finish_struct_1. (We could
2949 also keep a pointer to the correct insertion points in the
2952 if (TREE_CODE (decl
) == TYPE_DECL
)
2953 TYPE_FIELDS (current_class_type
)
2954 = chainon (TYPE_FIELDS (current_class_type
), decl
);
2957 DECL_CHAIN (decl
) = TYPE_FIELDS (current_class_type
);
2958 TYPE_FIELDS (current_class_type
) = decl
;
2961 maybe_add_class_template_decl_list (current_class_type
, decl
,
2966 note_decl_for_pch (decl
);
2969 /* DECL has been declared while we are building a PCH file. Perform
2970 actions that we might normally undertake lazily, but which can be
2971 performed now so that they do not have to be performed in
2972 translation units which include the PCH file. */
2975 note_decl_for_pch (tree decl
)
2977 gcc_assert (pch_file
);
2979 /* There's a good chance that we'll have to mangle names at some
2980 point, even if only for emission in debugging information. */
2981 if (VAR_OR_FUNCTION_DECL_P (decl
)
2982 && !processing_template_decl
)
2986 /* Finish processing a complete template declaration. The PARMS are
2987 the template parameters. */
2990 finish_template_decl (tree parms
)
2993 end_template_decl ();
2995 end_specialization ();
2998 /* Finish processing a template-id (which names a type) of the form
2999 NAME < ARGS >. Return the TYPE_DECL for the type named by the
3000 template-id. If ENTERING_SCOPE is nonzero we are about to enter
3001 the scope of template-id indicated. */
3004 finish_template_type (tree name
, tree args
, int entering_scope
)
3008 type
= lookup_template_class (name
, args
,
3009 NULL_TREE
, NULL_TREE
, entering_scope
,
3010 tf_warning_or_error
| tf_user
);
3011 if (type
== error_mark_node
)
3013 else if (CLASS_TYPE_P (type
) && !alias_type_or_template_p (type
))
3014 return TYPE_STUB_DECL (type
);
3016 return TYPE_NAME (type
);
3019 /* Finish processing a BASE_CLASS with the indicated ACCESS_SPECIFIER.
3020 Return a TREE_LIST containing the ACCESS_SPECIFIER and the
3021 BASE_CLASS, or NULL_TREE if an error occurred. The
3022 ACCESS_SPECIFIER is one of
3023 access_{default,public,protected_private}_node. For a virtual base
3024 we set TREE_TYPE. */
3027 finish_base_specifier (tree base
, tree access
, bool virtual_p
)
3031 if (base
== error_mark_node
)
3033 error ("invalid base-class specification");
3036 else if (! MAYBE_CLASS_TYPE_P (base
))
3038 error ("%qT is not a class type", base
);
3043 if (cp_type_quals (base
) != 0)
3045 /* DR 484: Can a base-specifier name a cv-qualified
3047 base
= TYPE_MAIN_VARIANT (base
);
3049 result
= build_tree_list (access
, base
);
3051 TREE_TYPE (result
) = integer_type_node
;
3057 /* If FNS is a member function, a set of member functions, or a
3058 template-id referring to one or more member functions, return a
3059 BASELINK for FNS, incorporating the current access context.
3060 Otherwise, return FNS unchanged. */
3063 baselink_for_fns (tree fns
)
3068 if (BASELINK_P (fns
)
3069 || error_operand_p (fns
))
3072 scope
= ovl_scope (fns
);
3073 if (!CLASS_TYPE_P (scope
))
3076 cl
= currently_open_derived_class (scope
);
3079 cl
= TYPE_BINFO (cl
);
3080 return build_baselink (cl
, cl
, fns
, /*optype=*/NULL_TREE
);
3083 /* Returns true iff DECL is a variable from a function outside
3087 outer_var_p (tree decl
)
3089 return ((VAR_P (decl
) || TREE_CODE (decl
) == PARM_DECL
)
3090 && DECL_FUNCTION_SCOPE_P (decl
)
3091 && (DECL_CONTEXT (decl
) != current_function_decl
3092 || parsing_nsdmi ()));
3095 /* As above, but also checks that DECL is automatic. */
3098 outer_automatic_var_p (tree decl
)
3100 return (outer_var_p (decl
)
3101 && !TREE_STATIC (decl
));
3104 /* DECL satisfies outer_automatic_var_p. Possibly complain about it or
3105 rewrite it for lambda capture. */
3108 process_outer_var_ref (tree decl
, tsubst_flags_t complain
)
3110 if (cp_unevaluated_operand
)
3111 /* It's not a use (3.2) if we're in an unevaluated context. */
3114 tree context
= DECL_CONTEXT (decl
);
3115 tree containing_function
= current_function_decl
;
3116 tree lambda_stack
= NULL_TREE
;
3117 tree lambda_expr
= NULL_TREE
;
3118 tree initializer
= convert_from_reference (decl
);
3120 /* Mark it as used now even if the use is ill-formed. */
3121 if (!mark_used (decl
, complain
) && !(complain
& tf_error
))
3122 return error_mark_node
;
3124 /* Core issue 696: "[At the July 2009 meeting] the CWG expressed
3125 support for an approach in which a reference to a local
3126 [constant] automatic variable in a nested class or lambda body
3127 would enter the expression as an rvalue, which would reduce
3128 the complexity of the problem"
3130 FIXME update for final resolution of core issue 696. */
3131 if (decl_maybe_constant_var_p (decl
))
3133 if (processing_template_decl
)
3134 /* In a template, the constant value may not be in a usable
3135 form, so wait until instantiation time. */
3137 else if (decl_constant_var_p (decl
))
3138 return scalar_constant_value (decl
);
3141 if (parsing_nsdmi ())
3142 containing_function
= NULL_TREE
;
3144 /* If we are in a lambda function, we can move out until we hit
3146 2. a non-lambda function, or
3147 3. a non-default capturing lambda function. */
3148 while (context
!= containing_function
3149 && LAMBDA_FUNCTION_P (containing_function
))
3151 tree closure
= DECL_CONTEXT (containing_function
);
3152 lambda_expr
= CLASSTYPE_LAMBDA_EXPR (closure
);
3154 if (TYPE_CLASS_SCOPE_P (closure
))
3155 /* A lambda in an NSDMI (c++/64496). */
3158 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr
)
3162 lambda_stack
= tree_cons (NULL_TREE
,
3167 = decl_function_context (containing_function
);
3170 if (lambda_expr
&& TREE_CODE (decl
) == VAR_DECL
3171 && DECL_ANON_UNION_VAR_P (decl
))
3173 if (complain
& tf_error
)
3174 error ("cannot capture member %qD of anonymous union", decl
);
3175 return error_mark_node
;
3177 if (context
== containing_function
)
3179 decl
= add_default_capture (lambda_stack
,
3180 /*id=*/DECL_NAME (decl
),
3183 else if (lambda_expr
)
3185 if (complain
& tf_error
)
3187 error ("%qD is not captured", decl
);
3188 tree closure
= LAMBDA_EXPR_CLOSURE (lambda_expr
);
3189 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr
)
3191 inform (location_of (closure
),
3192 "the lambda has no capture-default");
3193 else if (TYPE_CLASS_SCOPE_P (closure
))
3194 inform (0, "lambda in local class %q+T cannot "
3195 "capture variables from the enclosing context",
3196 TYPE_CONTEXT (closure
));
3197 inform (input_location
, "%q+#D declared here", decl
);
3199 return error_mark_node
;
3203 if (complain
& tf_error
)
3205 ? G_("use of local variable with automatic storage from containing function")
3206 : G_("use of parameter from containing function"));
3207 inform (input_location
, "%q+#D declared here", decl
);
3208 return error_mark_node
;
3213 /* ID_EXPRESSION is a representation of parsed, but unprocessed,
3214 id-expression. (See cp_parser_id_expression for details.) SCOPE,
3215 if non-NULL, is the type or namespace used to explicitly qualify
3216 ID_EXPRESSION. DECL is the entity to which that name has been
3219 *CONSTANT_EXPRESSION_P is true if we are presently parsing a
3220 constant-expression. In that case, *NON_CONSTANT_EXPRESSION_P will
3221 be set to true if this expression isn't permitted in a
3222 constant-expression, but it is otherwise not set by this function.
3223 *ALLOW_NON_CONSTANT_EXPRESSION_P is true if we are parsing a
3224 constant-expression, but a non-constant expression is also
3227 DONE is true if this expression is a complete postfix-expression;
3228 it is false if this expression is followed by '->', '[', '(', etc.
3229 ADDRESS_P is true iff this expression is the operand of '&'.
3230 TEMPLATE_P is true iff the qualified-id was of the form
3231 "A::template B". TEMPLATE_ARG_P is true iff this qualified name
3232 appears as a template argument.
3234 If an error occurs, and it is the kind of error that might cause
3235 the parser to abort a tentative parse, *ERROR_MSG is filled in. It
3236 is the caller's responsibility to issue the message. *ERROR_MSG
3237 will be a string with static storage duration, so the caller need
3240 Return an expression for the entity, after issuing appropriate
3241 diagnostics. This function is also responsible for transforming a
3242 reference to a non-static member into a COMPONENT_REF that makes
3243 the use of "this" explicit.
3245 Upon return, *IDK will be filled in appropriately. */
3247 finish_id_expression (tree id_expression
,
3251 bool integral_constant_expression_p
,
3252 bool allow_non_integral_constant_expression_p
,
3253 bool *non_integral_constant_expression_p
,
3257 bool template_arg_p
,
3258 const char **error_msg
,
3259 location_t location
)
3261 decl
= strip_using_decl (decl
);
3263 /* Initialize the output parameters. */
3264 *idk
= CP_ID_KIND_NONE
;
3267 if (id_expression
== error_mark_node
)
3268 return error_mark_node
;
3269 /* If we have a template-id, then no further lookup is
3270 required. If the template-id was for a template-class, we
3271 will sometimes have a TYPE_DECL at this point. */
3272 else if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
3273 || TREE_CODE (decl
) == TYPE_DECL
)
3275 /* Look up the name. */
3278 if (decl
== error_mark_node
)
3280 /* Name lookup failed. */
3283 || (!dependent_type_p (scope
)
3284 && !(identifier_p (id_expression
)
3285 && IDENTIFIER_TYPENAME_P (id_expression
)
3286 && dependent_type_p (TREE_TYPE (id_expression
))))))
3288 /* If the qualifying type is non-dependent (and the name
3289 does not name a conversion operator to a dependent
3290 type), issue an error. */
3291 qualified_name_lookup_error (scope
, id_expression
, decl
, location
);
3292 return error_mark_node
;
3296 /* It may be resolved via Koenig lookup. */
3297 *idk
= CP_ID_KIND_UNQUALIFIED
;
3298 return id_expression
;
3301 decl
= id_expression
;
3303 /* If DECL is a variable that would be out of scope under
3304 ANSI/ISO rules, but in scope in the ARM, name lookup
3305 will succeed. Issue a diagnostic here. */
3307 decl
= check_for_out_of_scope_variable (decl
);
3309 /* Remember that the name was used in the definition of
3310 the current class so that we can check later to see if
3311 the meaning would have been different after the class
3312 was entirely defined. */
3313 if (!scope
&& decl
!= error_mark_node
&& identifier_p (id_expression
))
3314 maybe_note_name_used_in_class (id_expression
, decl
);
3316 /* Disallow uses of local variables from containing functions, except
3317 within lambda-expressions. */
3318 if (outer_automatic_var_p (decl
))
3320 decl
= process_outer_var_ref (decl
, tf_warning_or_error
);
3321 if (decl
== error_mark_node
)
3322 return error_mark_node
;
3325 /* Also disallow uses of function parameters outside the function
3326 body, except inside an unevaluated context (i.e. decltype). */
3327 if (TREE_CODE (decl
) == PARM_DECL
3328 && DECL_CONTEXT (decl
) == NULL_TREE
3329 && !cp_unevaluated_operand
)
3331 *error_msg
= "use of parameter outside function body";
3332 return error_mark_node
;
3336 /* If we didn't find anything, or what we found was a type,
3337 then this wasn't really an id-expression. */
3338 if (TREE_CODE (decl
) == TEMPLATE_DECL
3339 && !DECL_FUNCTION_TEMPLATE_P (decl
))
3341 *error_msg
= "missing template arguments";
3342 return error_mark_node
;
3344 else if (TREE_CODE (decl
) == TYPE_DECL
3345 || TREE_CODE (decl
) == NAMESPACE_DECL
)
3347 *error_msg
= "expected primary-expression";
3348 return error_mark_node
;
3351 /* If the name resolved to a template parameter, there is no
3352 need to look it up again later. */
3353 if ((TREE_CODE (decl
) == CONST_DECL
&& DECL_TEMPLATE_PARM_P (decl
))
3354 || TREE_CODE (decl
) == TEMPLATE_PARM_INDEX
)
3358 *idk
= CP_ID_KIND_NONE
;
3359 if (TREE_CODE (decl
) == TEMPLATE_PARM_INDEX
)
3360 decl
= TEMPLATE_PARM_DECL (decl
);
3361 r
= convert_from_reference (DECL_INITIAL (decl
));
3363 if (integral_constant_expression_p
3364 && !dependent_type_p (TREE_TYPE (decl
))
3365 && !(INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (r
))))
3367 if (!allow_non_integral_constant_expression_p
)
3368 error ("template parameter %qD of type %qT is not allowed in "
3369 "an integral constant expression because it is not of "
3370 "integral or enumeration type", decl
, TREE_TYPE (decl
));
3371 *non_integral_constant_expression_p
= true;
3379 /* If the declaration was explicitly qualified indicate
3380 that. The semantics of `A::f(3)' are different than
3381 `f(3)' if `f' is virtual. */
3383 ? CP_ID_KIND_QUALIFIED
3384 : (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
3385 ? CP_ID_KIND_TEMPLATE_ID
3386 : CP_ID_KIND_UNQUALIFIED
));
3391 An id-expression is type-dependent if it contains an
3392 identifier that was declared with a dependent type.
3394 The standard is not very specific about an id-expression that
3395 names a set of overloaded functions. What if some of them
3396 have dependent types and some of them do not? Presumably,
3397 such a name should be treated as a dependent name. */
3398 /* Assume the name is not dependent. */
3399 dependent_p
= false;
3400 if (!processing_template_decl
)
3401 /* No names are dependent outside a template. */
3403 else if (TREE_CODE (decl
) == CONST_DECL
)
3404 /* We don't want to treat enumerators as dependent. */
3406 /* A template-id where the name of the template was not resolved
3407 is definitely dependent. */
3408 else if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
3409 && (identifier_p (TREE_OPERAND (decl
, 0))))
3411 /* For anything except an overloaded function, just check its
3413 else if (!is_overloaded_fn (decl
))
3415 = dependent_type_p (TREE_TYPE (decl
));
3416 /* For a set of overloaded functions, check each of the
3422 if (BASELINK_P (fns
))
3423 fns
= BASELINK_FUNCTIONS (fns
);
3425 /* For a template-id, check to see if the template
3426 arguments are dependent. */
3427 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
3429 tree args
= TREE_OPERAND (fns
, 1);
3430 dependent_p
= any_dependent_template_arguments_p (args
);
3431 /* The functions are those referred to by the
3433 fns
= TREE_OPERAND (fns
, 0);
3436 /* If there are no dependent template arguments, go through
3437 the overloaded functions. */
3438 while (fns
&& !dependent_p
)
3440 tree fn
= OVL_CURRENT (fns
);
3442 /* Member functions of dependent classes are
3444 if (TREE_CODE (fn
) == FUNCTION_DECL
3445 && type_dependent_expression_p (fn
))
3447 else if (TREE_CODE (fn
) == TEMPLATE_DECL
3448 && dependent_template_p (fn
))
3451 fns
= OVL_NEXT (fns
);
3455 /* If the name was dependent on a template parameter, we will
3456 resolve the name at instantiation time. */
3459 /* Create a SCOPE_REF for qualified names, if the scope is
3465 if (address_p
&& done
)
3466 decl
= finish_qualified_id_expr (scope
, decl
,
3470 tf_warning_or_error
);
3473 tree type
= NULL_TREE
;
3474 if (DECL_P (decl
) && !dependent_scope_p (scope
))
3475 type
= TREE_TYPE (decl
);
3476 decl
= build_qualified_name (type
,
3482 if (TREE_TYPE (decl
))
3483 decl
= convert_from_reference (decl
);
3486 /* A TEMPLATE_ID already contains all the information we
3488 if (TREE_CODE (id_expression
) == TEMPLATE_ID_EXPR
)
3489 return id_expression
;
3490 *idk
= CP_ID_KIND_UNQUALIFIED_DEPENDENT
;
3491 /* If we found a variable, then name lookup during the
3492 instantiation will always resolve to the same VAR_DECL
3493 (or an instantiation thereof). */
3495 || TREE_CODE (decl
) == PARM_DECL
)
3498 return convert_from_reference (decl
);
3500 /* The same is true for FIELD_DECL, but we also need to
3501 make sure that the syntax is correct. */
3502 else if (TREE_CODE (decl
) == FIELD_DECL
)
3504 /* Since SCOPE is NULL here, this is an unqualified name.
3505 Access checking has been performed during name lookup
3506 already. Turn off checking to avoid duplicate errors. */
3507 push_deferring_access_checks (dk_no_check
);
3508 decl
= finish_non_static_data_member
3510 /*qualifying_scope=*/NULL_TREE
);
3511 pop_deferring_access_checks ();
3514 return id_expression
;
3517 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
3519 error ("use of namespace %qD as expression", decl
);
3520 return error_mark_node
;
3522 else if (DECL_CLASS_TEMPLATE_P (decl
))
3524 error ("use of class template %qT as expression", decl
);
3525 return error_mark_node
;
3527 else if (TREE_CODE (decl
) == TREE_LIST
)
3529 /* Ambiguous reference to base members. */
3530 error ("request for member %qD is ambiguous in "
3531 "multiple inheritance lattice", id_expression
);
3532 print_candidates (decl
);
3533 return error_mark_node
;
3536 /* Mark variable-like entities as used. Functions are similarly
3537 marked either below or after overload resolution. */
3539 || TREE_CODE (decl
) == PARM_DECL
3540 || TREE_CODE (decl
) == CONST_DECL
3541 || TREE_CODE (decl
) == RESULT_DECL
)
3542 && !mark_used (decl
))
3543 return error_mark_node
;
3545 /* Only certain kinds of names are allowed in constant
3546 expression. Template parameters have already
3547 been handled above. */
3548 if (! error_operand_p (decl
)
3549 && integral_constant_expression_p
3550 && ! decl_constant_var_p (decl
)
3551 && TREE_CODE (decl
) != CONST_DECL
3552 && ! builtin_valid_in_constant_expr_p (decl
))
3554 if (!allow_non_integral_constant_expression_p
)
3556 error ("%qD cannot appear in a constant-expression", decl
);
3557 return error_mark_node
;
3559 *non_integral_constant_expression_p
= true;
3564 && !cp_unevaluated_operand
3565 && !processing_template_decl
3566 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
))
3567 && DECL_THREAD_LOCAL_P (decl
)
3568 && (wrap
= get_tls_wrapper_fn (decl
)))
3570 /* Replace an evaluated use of the thread_local variable with
3571 a call to its wrapper. */
3572 decl
= build_cxx_call (wrap
, 0, NULL
, tf_warning_or_error
);
3574 else if (TREE_CODE (decl
) == TEMPLATE_ID_EXPR
3575 && variable_template_p (TREE_OPERAND (decl
, 0)))
3577 decl
= finish_template_variable (decl
);
3582 decl
= (adjust_result_of_qualified_name_lookup
3583 (decl
, scope
, current_nonlambda_class_type()));
3585 if (TREE_CODE (decl
) == FUNCTION_DECL
)
3589 decl
= finish_qualified_id_expr (scope
,
3595 tf_warning_or_error
);
3597 decl
= convert_from_reference (decl
);
3599 else if (TREE_CODE (decl
) == FIELD_DECL
)
3601 /* Since SCOPE is NULL here, this is an unqualified name.
3602 Access checking has been performed during name lookup
3603 already. Turn off checking to avoid duplicate errors. */
3604 push_deferring_access_checks (dk_no_check
);
3605 decl
= finish_non_static_data_member (decl
, NULL_TREE
,
3606 /*qualifying_scope=*/NULL_TREE
);
3607 pop_deferring_access_checks ();
3609 else if (is_overloaded_fn (decl
))
3613 first_fn
= get_first_fn (decl
);
3614 if (TREE_CODE (first_fn
) == TEMPLATE_DECL
)
3615 first_fn
= DECL_TEMPLATE_RESULT (first_fn
);
3617 if (!really_overloaded_fn (decl
)
3618 && !mark_used (first_fn
))
3619 return error_mark_node
;
3622 && TREE_CODE (first_fn
) == FUNCTION_DECL
3623 && DECL_FUNCTION_MEMBER_P (first_fn
)
3624 && !shared_member_p (decl
))
3626 /* A set of member functions. */
3627 decl
= maybe_dummy_object (DECL_CONTEXT (first_fn
), 0);
3628 return finish_class_member_access_expr (decl
, id_expression
,
3629 /*template_p=*/false,
3630 tf_warning_or_error
);
3633 decl
= baselink_for_fns (decl
);
3637 if (DECL_P (decl
) && DECL_NONLOCAL (decl
)
3638 && DECL_CLASS_SCOPE_P (decl
))
3640 tree context
= context_for_name_lookup (decl
);
3641 if (context
!= current_class_type
)
3643 tree path
= currently_open_derived_class (context
);
3644 perform_or_defer_access_check (TYPE_BINFO (path
),
3646 tf_warning_or_error
);
3650 decl
= convert_from_reference (decl
);
3654 /* Handle references (c++/56130). */
3655 tree t
= REFERENCE_REF_P (decl
) ? TREE_OPERAND (decl
, 0) : decl
;
3656 if (TREE_DEPRECATED (t
))
3657 warn_deprecated_use (t
, NULL_TREE
);
3662 /* Implement the __typeof keyword: Return the type of EXPR, suitable for
3663 use as a type-specifier. */
3666 finish_typeof (tree expr
)
3670 if (type_dependent_expression_p (expr
))
3672 type
= cxx_make_type (TYPEOF_TYPE
);
3673 TYPEOF_TYPE_EXPR (type
) = expr
;
3674 SET_TYPE_STRUCTURAL_EQUALITY (type
);
3679 expr
= mark_type_use (expr
);
3681 type
= unlowered_expr_type (expr
);
3683 if (!type
|| type
== unknown_type_node
)
3685 error ("type of %qE is unknown", expr
);
3686 return error_mark_node
;
3692 /* Implement the __underlying_type keyword: Return the underlying
3693 type of TYPE, suitable for use as a type-specifier. */
3696 finish_underlying_type (tree type
)
3698 tree underlying_type
;
3700 if (processing_template_decl
)
3702 underlying_type
= cxx_make_type (UNDERLYING_TYPE
);
3703 UNDERLYING_TYPE_TYPE (underlying_type
) = type
;
3704 SET_TYPE_STRUCTURAL_EQUALITY (underlying_type
);
3706 return underlying_type
;
3709 complete_type (type
);
3711 if (TREE_CODE (type
) != ENUMERAL_TYPE
)
3713 error ("%qT is not an enumeration type", type
);
3714 return error_mark_node
;
3717 underlying_type
= ENUM_UNDERLYING_TYPE (type
);
3719 /* Fixup necessary in this case because ENUM_UNDERLYING_TYPE
3720 includes TYPE_MIN_VALUE and TYPE_MAX_VALUE information.
3721 See finish_enum_value_list for details. */
3722 if (!ENUM_FIXED_UNDERLYING_TYPE_P (type
))
3724 = c_common_type_for_mode (TYPE_MODE (underlying_type
),
3725 TYPE_UNSIGNED (underlying_type
));
3727 return underlying_type
;
3730 /* Implement the __direct_bases keyword: Return the direct base classes
3734 calculate_direct_bases (tree type
)
3736 vec
<tree
, va_gc
> *vector
= make_tree_vector();
3737 tree bases_vec
= NULL_TREE
;
3738 vec
<tree
, va_gc
> *base_binfos
;
3742 complete_type (type
);
3744 if (!NON_UNION_CLASS_TYPE_P (type
))
3745 return make_tree_vec (0);
3747 base_binfos
= BINFO_BASE_BINFOS (TYPE_BINFO (type
));
3749 /* Virtual bases are initialized first */
3750 for (i
= 0; base_binfos
->iterate (i
, &binfo
); i
++)
3752 if (BINFO_VIRTUAL_P (binfo
))
3754 vec_safe_push (vector
, binfo
);
3758 /* Now non-virtuals */
3759 for (i
= 0; base_binfos
->iterate (i
, &binfo
); i
++)
3761 if (!BINFO_VIRTUAL_P (binfo
))
3763 vec_safe_push (vector
, binfo
);
3768 bases_vec
= make_tree_vec (vector
->length ());
3770 for (i
= 0; i
< vector
->length (); ++i
)
3772 TREE_VEC_ELT (bases_vec
, i
) = BINFO_TYPE ((*vector
)[i
]);
3777 /* Implement the __bases keyword: Return the base classes
3780 /* Find morally non-virtual base classes by walking binfo hierarchy */
3781 /* Virtual base classes are handled separately in finish_bases */
3784 dfs_calculate_bases_pre (tree binfo
, void * /*data_*/)
3786 /* Don't walk bases of virtual bases */
3787 return BINFO_VIRTUAL_P (binfo
) ? dfs_skip_bases
: NULL_TREE
;
3791 dfs_calculate_bases_post (tree binfo
, void *data_
)
3793 vec
<tree
, va_gc
> **data
= ((vec
<tree
, va_gc
> **) data_
);
3794 if (!BINFO_VIRTUAL_P (binfo
))
3796 vec_safe_push (*data
, BINFO_TYPE (binfo
));
3801 /* Calculates the morally non-virtual base classes of a class */
3802 static vec
<tree
, va_gc
> *
3803 calculate_bases_helper (tree type
)
3805 vec
<tree
, va_gc
> *vector
= make_tree_vector();
3807 /* Now add non-virtual base classes in order of construction */
3808 dfs_walk_all (TYPE_BINFO (type
),
3809 dfs_calculate_bases_pre
, dfs_calculate_bases_post
, &vector
);
3814 calculate_bases (tree type
)
3816 vec
<tree
, va_gc
> *vector
= make_tree_vector();
3817 tree bases_vec
= NULL_TREE
;
3819 vec
<tree
, va_gc
> *vbases
;
3820 vec
<tree
, va_gc
> *nonvbases
;
3823 complete_type (type
);
3825 if (!NON_UNION_CLASS_TYPE_P (type
))
3826 return make_tree_vec (0);
3828 /* First go through virtual base classes */
3829 for (vbases
= CLASSTYPE_VBASECLASSES (type
), i
= 0;
3830 vec_safe_iterate (vbases
, i
, &binfo
); i
++)
3832 vec
<tree
, va_gc
> *vbase_bases
;
3833 vbase_bases
= calculate_bases_helper (BINFO_TYPE (binfo
));
3834 vec_safe_splice (vector
, vbase_bases
);
3835 release_tree_vector (vbase_bases
);
3838 /* Now for the non-virtual bases */
3839 nonvbases
= calculate_bases_helper (type
);
3840 vec_safe_splice (vector
, nonvbases
);
3841 release_tree_vector (nonvbases
);
3843 /* Last element is entire class, so don't copy */
3844 bases_vec
= make_tree_vec (vector
->length () - 1);
3846 for (i
= 0; i
< vector
->length () - 1; ++i
)
3848 TREE_VEC_ELT (bases_vec
, i
) = (*vector
)[i
];
3850 release_tree_vector (vector
);
3855 finish_bases (tree type
, bool direct
)
3857 tree bases
= NULL_TREE
;
3859 if (!processing_template_decl
)
3861 /* Parameter packs can only be used in templates */
3862 error ("Parameter pack __bases only valid in template declaration");
3863 return error_mark_node
;
3866 bases
= cxx_make_type (BASES
);
3867 BASES_TYPE (bases
) = type
;
3868 BASES_DIRECT (bases
) = direct
;
3869 SET_TYPE_STRUCTURAL_EQUALITY (bases
);
3874 /* Perform C++-specific checks for __builtin_offsetof before calling
3878 finish_offsetof (tree expr
, location_t loc
)
3880 /* If we're processing a template, we can't finish the semantics yet.
3881 Otherwise we can fold the entire expression now. */
3882 if (processing_template_decl
)
3884 expr
= build1 (OFFSETOF_EXPR
, size_type_node
, expr
);
3885 SET_EXPR_LOCATION (expr
, loc
);
3889 if (TREE_CODE (expr
) == PSEUDO_DTOR_EXPR
)
3891 error ("cannot apply %<offsetof%> to destructor %<~%T%>",
3892 TREE_OPERAND (expr
, 2));
3893 return error_mark_node
;
3895 if (TREE_CODE (TREE_TYPE (expr
)) == FUNCTION_TYPE
3896 || TREE_CODE (TREE_TYPE (expr
)) == METHOD_TYPE
3897 || TREE_TYPE (expr
) == unknown_type_node
)
3899 if (INDIRECT_REF_P (expr
))
3900 error ("second operand of %<offsetof%> is neither a single "
3901 "identifier nor a sequence of member accesses and "
3902 "array references");
3905 if (TREE_CODE (expr
) == COMPONENT_REF
3906 || TREE_CODE (expr
) == COMPOUND_EXPR
)
3907 expr
= TREE_OPERAND (expr
, 1);
3908 error ("cannot apply %<offsetof%> to member function %qD", expr
);
3910 return error_mark_node
;
3912 if (REFERENCE_REF_P (expr
))
3913 expr
= TREE_OPERAND (expr
, 0);
3914 if (TREE_CODE (expr
) == COMPONENT_REF
)
3916 tree object
= TREE_OPERAND (expr
, 0);
3917 if (!complete_type_or_else (TREE_TYPE (object
), object
))
3918 return error_mark_node
;
3919 if (warn_invalid_offsetof
3920 && CLASS_TYPE_P (TREE_TYPE (object
))
3921 && CLASSTYPE_NON_STD_LAYOUT (TREE_TYPE (object
))
3922 && cp_unevaluated_operand
== 0)
3923 pedwarn (loc
, OPT_Winvalid_offsetof
,
3924 "offsetof within non-standard-layout type %qT is undefined",
3925 TREE_TYPE (object
));
3927 return fold_offsetof (expr
);
3930 /* Replace the AGGR_INIT_EXPR at *TP with an equivalent CALL_EXPR. This
3931 function is broken out from the above for the benefit of the tree-ssa
3935 simplify_aggr_init_expr (tree
*tp
)
3937 tree aggr_init_expr
= *tp
;
3939 /* Form an appropriate CALL_EXPR. */
3940 tree fn
= AGGR_INIT_EXPR_FN (aggr_init_expr
);
3941 tree slot
= AGGR_INIT_EXPR_SLOT (aggr_init_expr
);
3942 tree type
= TREE_TYPE (slot
);
3945 enum style_t
{ ctor
, arg
, pcc
} style
;
3947 if (AGGR_INIT_VIA_CTOR_P (aggr_init_expr
))
3949 #ifdef PCC_STATIC_STRUCT_RETURN
3955 gcc_assert (TREE_ADDRESSABLE (type
));
3959 call_expr
= build_call_array_loc (input_location
,
3960 TREE_TYPE (TREE_TYPE (TREE_TYPE (fn
))),
3962 aggr_init_expr_nargs (aggr_init_expr
),
3963 AGGR_INIT_EXPR_ARGP (aggr_init_expr
));
3964 TREE_NOTHROW (call_expr
) = TREE_NOTHROW (aggr_init_expr
);
3965 CALL_EXPR_LIST_INIT_P (call_expr
) = CALL_EXPR_LIST_INIT_P (aggr_init_expr
);
3969 /* Replace the first argument to the ctor with the address of the
3971 cxx_mark_addressable (slot
);
3972 CALL_EXPR_ARG (call_expr
, 0) =
3973 build1 (ADDR_EXPR
, build_pointer_type (type
), slot
);
3975 else if (style
== arg
)
3977 /* Just mark it addressable here, and leave the rest to
3978 expand_call{,_inline}. */
3979 cxx_mark_addressable (slot
);
3980 CALL_EXPR_RETURN_SLOT_OPT (call_expr
) = true;
3981 call_expr
= build2 (INIT_EXPR
, TREE_TYPE (call_expr
), slot
, call_expr
);
3983 else if (style
== pcc
)
3985 /* If we're using the non-reentrant PCC calling convention, then we
3986 need to copy the returned value out of the static buffer into the
3988 push_deferring_access_checks (dk_no_check
);
3989 call_expr
= build_aggr_init (slot
, call_expr
,
3990 DIRECT_BIND
| LOOKUP_ONLYCONVERTING
,
3991 tf_warning_or_error
);
3992 pop_deferring_access_checks ();
3993 call_expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (slot
), call_expr
, slot
);
3996 if (AGGR_INIT_ZERO_FIRST (aggr_init_expr
))
3998 tree init
= build_zero_init (type
, NULL_TREE
,
3999 /*static_storage_p=*/false);
4000 init
= build2 (INIT_EXPR
, void_type_node
, slot
, init
);
4001 call_expr
= build2 (COMPOUND_EXPR
, TREE_TYPE (call_expr
),
4008 /* Emit all thunks to FN that should be emitted when FN is emitted. */
4011 emit_associated_thunks (tree fn
)
4013 /* When we use vcall offsets, we emit thunks with the virtual
4014 functions to which they thunk. The whole point of vcall offsets
4015 is so that you can know statically the entire set of thunks that
4016 will ever be needed for a given virtual function, thereby
4017 enabling you to output all the thunks with the function itself. */
4018 if (DECL_VIRTUAL_P (fn
)
4019 /* Do not emit thunks for extern template instantiations. */
4020 && ! DECL_REALLY_EXTERN (fn
))
4024 for (thunk
= DECL_THUNKS (fn
); thunk
; thunk
= DECL_CHAIN (thunk
))
4026 if (!THUNK_ALIAS (thunk
))
4028 use_thunk (thunk
, /*emit_p=*/1);
4029 if (DECL_RESULT_THUNK_P (thunk
))
4033 for (probe
= DECL_THUNKS (thunk
);
4034 probe
; probe
= DECL_CHAIN (probe
))
4035 use_thunk (probe
, /*emit_p=*/1);
4039 gcc_assert (!DECL_THUNKS (thunk
));
4044 /* Generate RTL for FN. */
4047 expand_or_defer_fn_1 (tree fn
)
4049 /* When the parser calls us after finishing the body of a template
4050 function, we don't really want to expand the body. */
4051 if (processing_template_decl
)
4053 /* Normally, collection only occurs in rest_of_compilation. So,
4054 if we don't collect here, we never collect junk generated
4055 during the processing of templates until we hit a
4056 non-template function. It's not safe to do this inside a
4057 nested class, though, as the parser may have local state that
4058 is not a GC root. */
4059 if (!function_depth
)
4064 gcc_assert (DECL_SAVED_TREE (fn
));
4066 /* We make a decision about linkage for these functions at the end
4067 of the compilation. Until that point, we do not want the back
4068 end to output them -- but we do want it to see the bodies of
4069 these functions so that it can inline them as appropriate. */
4070 if (DECL_DECLARED_INLINE_P (fn
) || DECL_IMPLICIT_INSTANTIATION (fn
))
4072 if (DECL_INTERFACE_KNOWN (fn
))
4073 /* We've already made a decision as to how this function will
4076 tentative_decl_linkage (fn
);
4078 import_export_decl (fn
);
4080 /* If the user wants us to keep all inline functions, then mark
4081 this function as needed so that finish_file will make sure to
4082 output it later. Similarly, all dllexport'd functions must
4083 be emitted; there may be callers in other DLLs. */
4084 if (DECL_DECLARED_INLINE_P (fn
)
4085 && !DECL_REALLY_EXTERN (fn
)
4086 && (flag_keep_inline_functions
4087 || (flag_keep_inline_dllexport
4088 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (fn
)))))
4091 DECL_EXTERNAL (fn
) = 0;
4095 /* If this is a constructor or destructor body, we have to clone
4097 if (maybe_clone_body (fn
))
4099 /* We don't want to process FN again, so pretend we've written
4100 it out, even though we haven't. */
4101 TREE_ASM_WRITTEN (fn
) = 1;
4102 /* If this is an instantiation of a constexpr function, keep
4103 DECL_SAVED_TREE for explain_invalid_constexpr_fn. */
4104 if (!is_instantiation_of_constexpr (fn
))
4105 DECL_SAVED_TREE (fn
) = NULL_TREE
;
4109 /* There's no reason to do any of the work here if we're only doing
4110 semantic analysis; this code just generates RTL. */
4111 if (flag_syntax_only
)
4118 expand_or_defer_fn (tree fn
)
4120 if (expand_or_defer_fn_1 (fn
))
4124 /* Expand or defer, at the whim of the compilation unit manager. */
4125 cgraph_node::finalize_function (fn
, function_depth
> 1);
4126 emit_associated_thunks (fn
);
4134 nrv_data () : visited (37) {}
4138 hash_table
<pointer_hash
<tree_node
> > visited
;
4141 /* Helper function for walk_tree, used by finalize_nrv below. */
4144 finalize_nrv_r (tree
* tp
, int* walk_subtrees
, void* data
)
4146 struct nrv_data
*dp
= (struct nrv_data
*)data
;
4149 /* No need to walk into types. There wouldn't be any need to walk into
4150 non-statements, except that we have to consider STMT_EXPRs. */
4153 /* Change all returns to just refer to the RESULT_DECL; this is a nop,
4154 but differs from using NULL_TREE in that it indicates that we care
4155 about the value of the RESULT_DECL. */
4156 else if (TREE_CODE (*tp
) == RETURN_EXPR
)
4157 TREE_OPERAND (*tp
, 0) = dp
->result
;
4158 /* Change all cleanups for the NRV to only run when an exception is
4160 else if (TREE_CODE (*tp
) == CLEANUP_STMT
4161 && CLEANUP_DECL (*tp
) == dp
->var
)
4162 CLEANUP_EH_ONLY (*tp
) = 1;
4163 /* Replace the DECL_EXPR for the NRV with an initialization of the
4164 RESULT_DECL, if needed. */
4165 else if (TREE_CODE (*tp
) == DECL_EXPR
4166 && DECL_EXPR_DECL (*tp
) == dp
->var
)
4169 if (DECL_INITIAL (dp
->var
)
4170 && DECL_INITIAL (dp
->var
) != error_mark_node
)
4171 init
= build2 (INIT_EXPR
, void_type_node
, dp
->result
,
4172 DECL_INITIAL (dp
->var
));
4174 init
= build_empty_stmt (EXPR_LOCATION (*tp
));
4175 DECL_INITIAL (dp
->var
) = NULL_TREE
;
4176 SET_EXPR_LOCATION (init
, EXPR_LOCATION (*tp
));
4179 /* And replace all uses of the NRV with the RESULT_DECL. */
4180 else if (*tp
== dp
->var
)
4183 /* Avoid walking into the same tree more than once. Unfortunately, we
4184 can't just use walk_tree_without duplicates because it would only call
4185 us for the first occurrence of dp->var in the function body. */
4186 slot
= dp
->visited
.find_slot (*tp
, INSERT
);
4192 /* Keep iterating. */
4196 /* Called from finish_function to implement the named return value
4197 optimization by overriding all the RETURN_EXPRs and pertinent
4198 CLEANUP_STMTs and replacing all occurrences of VAR with RESULT, the
4199 RESULT_DECL for the function. */
4202 finalize_nrv (tree
*tp
, tree var
, tree result
)
4204 struct nrv_data data
;
4206 /* Copy name from VAR to RESULT. */
4207 DECL_NAME (result
) = DECL_NAME (var
);
4208 /* Don't forget that we take its address. */
4209 TREE_ADDRESSABLE (result
) = TREE_ADDRESSABLE (var
);
4210 /* Finally set DECL_VALUE_EXPR to avoid assigning
4211 a stack slot at -O0 for the original var and debug info
4212 uses RESULT location for VAR. */
4213 SET_DECL_VALUE_EXPR (var
, result
);
4214 DECL_HAS_VALUE_EXPR_P (var
) = 1;
4217 data
.result
= result
;
4218 cp_walk_tree (tp
, finalize_nrv_r
, &data
, 0);
4221 /* Create CP_OMP_CLAUSE_INFO for clause C. Returns true if it is invalid. */
4224 cxx_omp_create_clause_info (tree c
, tree type
, bool need_default_ctor
,
4225 bool need_copy_ctor
, bool need_copy_assignment
,
4228 int save_errorcount
= errorcount
;
4231 /* Always allocate 3 elements for simplicity. These are the
4232 function decls for the ctor, dtor, and assignment op.
4233 This layout is known to the three lang hooks,
4234 cxx_omp_clause_default_init, cxx_omp_clause_copy_init,
4235 and cxx_omp_clause_assign_op. */
4236 info
= make_tree_vec (3);
4237 CP_OMP_CLAUSE_INFO (c
) = info
;
4239 if (need_default_ctor
|| need_copy_ctor
)
4241 if (need_default_ctor
)
4242 t
= get_default_ctor (type
);
4244 t
= get_copy_ctor (type
, tf_warning_or_error
);
4246 if (t
&& !trivial_fn_p (t
))
4247 TREE_VEC_ELT (info
, 0) = t
;
4250 if (need_dtor
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
4251 TREE_VEC_ELT (info
, 1) = get_dtor (type
, tf_warning_or_error
);
4253 if (need_copy_assignment
)
4255 t
= get_copy_assign (type
);
4257 if (t
&& !trivial_fn_p (t
))
4258 TREE_VEC_ELT (info
, 2) = t
;
4261 return errorcount
!= save_errorcount
;
4264 /* Helper function for handle_omp_array_sections. Called recursively
4265 to handle multiple array-section-subscripts. C is the clause,
4266 T current expression (initially OMP_CLAUSE_DECL), which is either
4267 a TREE_LIST for array-section-subscript (TREE_PURPOSE is low-bound
4268 expression if specified, TREE_VALUE length expression if specified,
4269 TREE_CHAIN is what it has been specified after, or some decl.
4270 TYPES vector is populated with array section types, MAYBE_ZERO_LEN
4271 set to true if any of the array-section-subscript could have length
4272 of zero (explicit or implicit), FIRST_NON_ONE is the index of the
4273 first array-section-subscript which is known not to have length
4275 map(a[:b][2:1][:c][:2][:d][e:f][2:5])
4276 FIRST_NON_ONE will be 3, array-section-subscript [:b], [2:1] and [:c]
4277 all are or may have length of 1, array-section-subscript [:2] is the
4278 first one knonwn not to have length 1. For array-section-subscript
4279 <= FIRST_NON_ONE we diagnose non-contiguous arrays if low bound isn't
4280 0 or length isn't the array domain max + 1, for > FIRST_NON_ONE we
4281 can if MAYBE_ZERO_LEN is false. MAYBE_ZERO_LEN will be true in the above
4282 case though, as some lengths could be zero. */
4285 handle_omp_array_sections_1 (tree c
, tree t
, vec
<tree
> &types
,
4286 bool &maybe_zero_len
, unsigned int &first_non_one
)
4288 tree ret
, low_bound
, length
, type
;
4289 if (TREE_CODE (t
) != TREE_LIST
)
4291 if (error_operand_p (t
))
4292 return error_mark_node
;
4293 if (type_dependent_expression_p (t
))
4295 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
4297 if (processing_template_decl
)
4300 error_at (OMP_CLAUSE_LOCATION (c
),
4301 "%qD is not a variable in %qs clause", t
,
4302 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
4304 error_at (OMP_CLAUSE_LOCATION (c
),
4305 "%qE is not a variable in %qs clause", t
,
4306 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
4307 return error_mark_node
;
4309 else if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_DEPEND
4310 && TREE_CODE (t
) == VAR_DECL
&& DECL_THREAD_LOCAL_P (t
))
4312 error_at (OMP_CLAUSE_LOCATION (c
),
4313 "%qD is threadprivate variable in %qs clause", t
,
4314 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
4315 return error_mark_node
;
4317 t
= convert_from_reference (t
);
4321 ret
= handle_omp_array_sections_1 (c
, TREE_CHAIN (t
), types
,
4322 maybe_zero_len
, first_non_one
);
4323 if (ret
== error_mark_node
|| ret
== NULL_TREE
)
4326 type
= TREE_TYPE (ret
);
4327 low_bound
= TREE_PURPOSE (t
);
4328 length
= TREE_VALUE (t
);
4329 if ((low_bound
&& type_dependent_expression_p (low_bound
))
4330 || (length
&& type_dependent_expression_p (length
)))
4333 if (low_bound
== error_mark_node
|| length
== error_mark_node
)
4334 return error_mark_node
;
4336 if (low_bound
&& !INTEGRAL_TYPE_P (TREE_TYPE (low_bound
)))
4338 error_at (OMP_CLAUSE_LOCATION (c
),
4339 "low bound %qE of array section does not have integral type",
4341 return error_mark_node
;
4343 if (length
&& !INTEGRAL_TYPE_P (TREE_TYPE (length
)))
4345 error_at (OMP_CLAUSE_LOCATION (c
),
4346 "length %qE of array section does not have integral type",
4348 return error_mark_node
;
4351 low_bound
= mark_rvalue_use (low_bound
);
4353 length
= mark_rvalue_use (length
);
4355 && TREE_CODE (low_bound
) == INTEGER_CST
4356 && TYPE_PRECISION (TREE_TYPE (low_bound
))
4357 > TYPE_PRECISION (sizetype
))
4358 low_bound
= fold_convert (sizetype
, low_bound
);
4360 && TREE_CODE (length
) == INTEGER_CST
4361 && TYPE_PRECISION (TREE_TYPE (length
))
4362 > TYPE_PRECISION (sizetype
))
4363 length
= fold_convert (sizetype
, length
);
4364 if (low_bound
== NULL_TREE
)
4365 low_bound
= integer_zero_node
;
4367 if (length
!= NULL_TREE
)
4369 if (!integer_nonzerop (length
))
4370 maybe_zero_len
= true;
4371 if (first_non_one
== types
.length ()
4372 && (TREE_CODE (length
) != INTEGER_CST
|| integer_onep (length
)))
4375 if (TREE_CODE (type
) == ARRAY_TYPE
)
4377 if (length
== NULL_TREE
4378 && (TYPE_DOMAIN (type
) == NULL_TREE
4379 || TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) == NULL_TREE
))
4381 error_at (OMP_CLAUSE_LOCATION (c
),
4382 "for unknown bound array type length expression must "
4384 return error_mark_node
;
4386 if (TREE_CODE (low_bound
) == INTEGER_CST
4387 && tree_int_cst_sgn (low_bound
) == -1)
4389 error_at (OMP_CLAUSE_LOCATION (c
),
4390 "negative low bound in array section in %qs clause",
4391 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
4392 return error_mark_node
;
4394 if (length
!= NULL_TREE
4395 && TREE_CODE (length
) == INTEGER_CST
4396 && tree_int_cst_sgn (length
) == -1)
4398 error_at (OMP_CLAUSE_LOCATION (c
),
4399 "negative length in array section in %qs clause",
4400 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
4401 return error_mark_node
;
4403 if (TYPE_DOMAIN (type
)
4404 && TYPE_MAX_VALUE (TYPE_DOMAIN (type
))
4405 && TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)))
4408 tree size
= size_binop (PLUS_EXPR
,
4409 TYPE_MAX_VALUE (TYPE_DOMAIN (type
)),
4411 if (TREE_CODE (low_bound
) == INTEGER_CST
)
4413 if (tree_int_cst_lt (size
, low_bound
))
4415 error_at (OMP_CLAUSE_LOCATION (c
),
4416 "low bound %qE above array section size "
4417 "in %qs clause", low_bound
,
4418 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
4419 return error_mark_node
;
4421 if (tree_int_cst_equal (size
, low_bound
))
4422 maybe_zero_len
= true;
4423 else if (length
== NULL_TREE
4424 && first_non_one
== types
.length ()
4425 && tree_int_cst_equal
4426 (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)),
4430 else if (length
== NULL_TREE
)
4432 maybe_zero_len
= true;
4433 if (first_non_one
== types
.length ())
4436 if (length
&& TREE_CODE (length
) == INTEGER_CST
)
4438 if (tree_int_cst_lt (size
, length
))
4440 error_at (OMP_CLAUSE_LOCATION (c
),
4441 "length %qE above array section size "
4442 "in %qs clause", length
,
4443 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
4444 return error_mark_node
;
4446 if (TREE_CODE (low_bound
) == INTEGER_CST
)
4449 = size_binop (PLUS_EXPR
,
4450 fold_convert (sizetype
, low_bound
),
4451 fold_convert (sizetype
, length
));
4452 if (TREE_CODE (lbpluslen
) == INTEGER_CST
4453 && tree_int_cst_lt (size
, lbpluslen
))
4455 error_at (OMP_CLAUSE_LOCATION (c
),
4456 "high bound %qE above array section size "
4457 "in %qs clause", lbpluslen
,
4458 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
4459 return error_mark_node
;
4464 else if (length
== NULL_TREE
)
4466 maybe_zero_len
= true;
4467 if (first_non_one
== types
.length ())
4471 /* For [lb:] we will need to evaluate lb more than once. */
4472 if (length
== NULL_TREE
&& OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_DEPEND
)
4474 tree lb
= cp_save_expr (low_bound
);
4475 if (lb
!= low_bound
)
4477 TREE_PURPOSE (t
) = lb
;
4482 else if (TREE_CODE (type
) == POINTER_TYPE
)
4484 if (length
== NULL_TREE
)
4486 error_at (OMP_CLAUSE_LOCATION (c
),
4487 "for pointer type length expression must be specified");
4488 return error_mark_node
;
4490 /* If there is a pointer type anywhere but in the very first
4491 array-section-subscript, the array section can't be contiguous. */
4492 if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_DEPEND
4493 && TREE_CODE (TREE_CHAIN (t
)) == TREE_LIST
)
4495 error_at (OMP_CLAUSE_LOCATION (c
),
4496 "array section is not contiguous in %qs clause",
4497 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
4498 return error_mark_node
;
4503 error_at (OMP_CLAUSE_LOCATION (c
),
4504 "%qE does not have pointer or array type", ret
);
4505 return error_mark_node
;
4507 if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_DEPEND
)
4508 types
.safe_push (TREE_TYPE (ret
));
4509 /* We will need to evaluate lb more than once. */
4510 tree lb
= cp_save_expr (low_bound
);
4511 if (lb
!= low_bound
)
4513 TREE_PURPOSE (t
) = lb
;
4516 ret
= grok_array_decl (OMP_CLAUSE_LOCATION (c
), ret
, low_bound
, false);
4520 /* Handle array sections for clause C. */
4523 handle_omp_array_sections (tree c
)
4525 bool maybe_zero_len
= false;
4526 unsigned int first_non_one
= 0;
4527 auto_vec
<tree
> types
;
4528 tree first
= handle_omp_array_sections_1 (c
, OMP_CLAUSE_DECL (c
), types
,
4529 maybe_zero_len
, first_non_one
);
4530 if (first
== error_mark_node
)
4532 if (first
== NULL_TREE
)
4534 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_DEPEND
)
4536 tree t
= OMP_CLAUSE_DECL (c
);
4537 tree tem
= NULL_TREE
;
4538 if (processing_template_decl
)
4540 /* Need to evaluate side effects in the length expressions
4542 while (TREE_CODE (t
) == TREE_LIST
)
4544 if (TREE_VALUE (t
) && TREE_SIDE_EFFECTS (TREE_VALUE (t
)))
4546 if (tem
== NULL_TREE
)
4547 tem
= TREE_VALUE (t
);
4549 tem
= build2 (COMPOUND_EXPR
, TREE_TYPE (tem
),
4550 TREE_VALUE (t
), tem
);
4555 first
= build2 (COMPOUND_EXPR
, TREE_TYPE (first
), tem
, first
);
4556 OMP_CLAUSE_DECL (c
) = first
;
4560 unsigned int num
= types
.length (), i
;
4561 tree t
, side_effects
= NULL_TREE
, size
= NULL_TREE
;
4562 tree condition
= NULL_TREE
;
4564 if (int_size_in_bytes (TREE_TYPE (first
)) <= 0)
4565 maybe_zero_len
= true;
4566 if (processing_template_decl
&& maybe_zero_len
)
4569 for (i
= num
, t
= OMP_CLAUSE_DECL (c
); i
> 0;
4572 tree low_bound
= TREE_PURPOSE (t
);
4573 tree length
= TREE_VALUE (t
);
4577 && TREE_CODE (low_bound
) == INTEGER_CST
4578 && TYPE_PRECISION (TREE_TYPE (low_bound
))
4579 > TYPE_PRECISION (sizetype
))
4580 low_bound
= fold_convert (sizetype
, low_bound
);
4582 && TREE_CODE (length
) == INTEGER_CST
4583 && TYPE_PRECISION (TREE_TYPE (length
))
4584 > TYPE_PRECISION (sizetype
))
4585 length
= fold_convert (sizetype
, length
);
4586 if (low_bound
== NULL_TREE
)
4587 low_bound
= integer_zero_node
;
4588 if (!maybe_zero_len
&& i
> first_non_one
)
4590 if (integer_nonzerop (low_bound
))
4591 goto do_warn_noncontiguous
;
4592 if (length
!= NULL_TREE
4593 && TREE_CODE (length
) == INTEGER_CST
4594 && TYPE_DOMAIN (types
[i
])
4595 && TYPE_MAX_VALUE (TYPE_DOMAIN (types
[i
]))
4596 && TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (types
[i
])))
4600 size
= size_binop (PLUS_EXPR
,
4601 TYPE_MAX_VALUE (TYPE_DOMAIN (types
[i
])),
4603 if (!tree_int_cst_equal (length
, size
))
4605 do_warn_noncontiguous
:
4606 error_at (OMP_CLAUSE_LOCATION (c
),
4607 "array section is not contiguous in %qs "
4609 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
4613 if (!processing_template_decl
4614 && length
!= NULL_TREE
4615 && TREE_SIDE_EFFECTS (length
))
4617 if (side_effects
== NULL_TREE
)
4618 side_effects
= length
;
4620 side_effects
= build2 (COMPOUND_EXPR
,
4621 TREE_TYPE (side_effects
),
4622 length
, side_effects
);
4625 else if (processing_template_decl
)
4631 if (i
> first_non_one
&& length
&& integer_nonzerop (length
))
4634 l
= fold_convert (sizetype
, length
);
4637 l
= size_binop (PLUS_EXPR
,
4638 TYPE_MAX_VALUE (TYPE_DOMAIN (types
[i
])),
4640 l
= size_binop (MINUS_EXPR
, l
,
4641 fold_convert (sizetype
, low_bound
));
4643 if (i
> first_non_one
)
4645 l
= fold_build2 (NE_EXPR
, boolean_type_node
, l
,
4647 if (condition
== NULL_TREE
)
4650 condition
= fold_build2 (BIT_AND_EXPR
, boolean_type_node
,
4653 else if (size
== NULL_TREE
)
4655 size
= size_in_bytes (TREE_TYPE (types
[i
]));
4656 size
= size_binop (MULT_EXPR
, size
, l
);
4658 size
= fold_build3 (COND_EXPR
, sizetype
, condition
,
4659 size
, size_zero_node
);
4662 size
= size_binop (MULT_EXPR
, size
, l
);
4665 if (!processing_template_decl
)
4668 size
= build2 (COMPOUND_EXPR
, sizetype
, side_effects
, size
);
4669 OMP_CLAUSE_DECL (c
) = first
;
4670 OMP_CLAUSE_SIZE (c
) = size
;
4671 if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_MAP
)
4673 tree c2
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
4675 OMP_CLAUSE_SET_MAP_KIND (c2
, GOMP_MAP_POINTER
);
4676 if (!cxx_mark_addressable (t
))
4678 OMP_CLAUSE_DECL (c2
) = t
;
4679 t
= build_fold_addr_expr (first
);
4680 t
= fold_convert_loc (OMP_CLAUSE_LOCATION (c
),
4681 ptrdiff_type_node
, t
);
4682 tree ptr
= OMP_CLAUSE_DECL (c2
);
4683 ptr
= convert_from_reference (ptr
);
4684 if (!POINTER_TYPE_P (TREE_TYPE (ptr
)))
4685 ptr
= build_fold_addr_expr (ptr
);
4686 t
= fold_build2_loc (OMP_CLAUSE_LOCATION (c
), MINUS_EXPR
,
4687 ptrdiff_type_node
, t
,
4688 fold_convert_loc (OMP_CLAUSE_LOCATION (c
),
4689 ptrdiff_type_node
, ptr
));
4690 OMP_CLAUSE_SIZE (c2
) = t
;
4691 OMP_CLAUSE_CHAIN (c2
) = OMP_CLAUSE_CHAIN (c
);
4692 OMP_CLAUSE_CHAIN (c
) = c2
;
4693 ptr
= OMP_CLAUSE_DECL (c2
);
4694 if (TREE_CODE (TREE_TYPE (ptr
)) == REFERENCE_TYPE
4695 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (ptr
))))
4697 tree c3
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
4699 OMP_CLAUSE_SET_MAP_KIND (c3
, GOMP_MAP_POINTER
);
4700 OMP_CLAUSE_DECL (c3
) = ptr
;
4701 OMP_CLAUSE_DECL (c2
) = convert_from_reference (ptr
);
4702 OMP_CLAUSE_SIZE (c3
) = size_zero_node
;
4703 OMP_CLAUSE_CHAIN (c3
) = OMP_CLAUSE_CHAIN (c2
);
4704 OMP_CLAUSE_CHAIN (c2
) = c3
;
4711 /* Return identifier to look up for omp declare reduction. */
4714 omp_reduction_id (enum tree_code reduction_code
, tree reduction_id
, tree type
)
4716 const char *p
= NULL
;
4717 const char *m
= NULL
;
4718 switch (reduction_code
)
4726 case TRUTH_ANDIF_EXPR
:
4727 case TRUTH_ORIF_EXPR
:
4728 reduction_id
= ansi_opname (reduction_code
);
4742 if (TREE_CODE (reduction_id
) != IDENTIFIER_NODE
)
4743 return error_mark_node
;
4744 p
= IDENTIFIER_POINTER (reduction_id
);
4747 if (type
!= NULL_TREE
)
4748 m
= mangle_type_string (TYPE_MAIN_VARIANT (type
));
4750 const char prefix
[] = "omp declare reduction ";
4751 size_t lenp
= sizeof (prefix
);
4752 if (strncmp (p
, prefix
, lenp
- 1) == 0)
4754 size_t len
= strlen (p
);
4755 size_t lenm
= m
? strlen (m
) + 1 : 0;
4756 char *name
= XALLOCAVEC (char, lenp
+ len
+ lenm
);
4758 memcpy (name
, prefix
, lenp
- 1);
4759 memcpy (name
+ lenp
- 1, p
, len
+ 1);
4762 name
[lenp
+ len
- 1] = '~';
4763 memcpy (name
+ lenp
+ len
, m
, lenm
);
4765 return get_identifier (name
);
4768 /* Lookup OpenMP UDR ID for TYPE, return the corresponding artificial
4769 FUNCTION_DECL or NULL_TREE if not found. */
4772 omp_reduction_lookup (location_t loc
, tree id
, tree type
, tree
*baselinkp
,
4773 vec
<tree
> *ambiguousp
)
4776 tree baselink
= NULL_TREE
;
4777 if (identifier_p (id
))
4780 bool nonint_cst_expression_p
;
4781 const char *error_msg
;
4782 id
= omp_reduction_id (ERROR_MARK
, id
, type
);
4783 tree decl
= lookup_name (id
);
4784 if (decl
== NULL_TREE
)
4785 decl
= error_mark_node
;
4786 id
= finish_id_expression (id
, decl
, NULL_TREE
, &idk
, false, true,
4787 &nonint_cst_expression_p
, false, true, false,
4788 false, &error_msg
, loc
);
4789 if (idk
== CP_ID_KIND_UNQUALIFIED
4790 && identifier_p (id
))
4792 vec
<tree
, va_gc
> *args
= NULL
;
4793 vec_safe_push (args
, build_reference_type (type
));
4794 id
= perform_koenig_lookup (id
, args
, tf_none
);
4797 else if (TREE_CODE (id
) == SCOPE_REF
)
4798 id
= lookup_qualified_name (TREE_OPERAND (id
, 0),
4799 omp_reduction_id (ERROR_MARK
,
4800 TREE_OPERAND (id
, 1),
4804 if (id
&& is_overloaded_fn (id
))
4806 for (; id
; id
= OVL_NEXT (id
))
4808 tree fndecl
= OVL_CURRENT (id
);
4809 if (TREE_CODE (fndecl
) == FUNCTION_DECL
)
4811 tree argtype
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (fndecl
)));
4812 if (same_type_p (TREE_TYPE (argtype
), type
))
4816 if (id
&& BASELINK_P (fns
))
4823 if (id
== NULL_TREE
&& CLASS_TYPE_P (type
) && TYPE_BINFO (type
))
4825 vec
<tree
> ambiguous
= vNULL
;
4826 tree binfo
= TYPE_BINFO (type
), base_binfo
, ret
= NULL_TREE
;
4828 if (ambiguousp
== NULL
)
4829 ambiguousp
= &ambiguous
;
4830 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
4832 id
= omp_reduction_lookup (loc
, orig_id
, BINFO_TYPE (base_binfo
),
4833 baselinkp
? baselinkp
: &baselink
,
4835 if (id
== NULL_TREE
)
4837 if (!ambiguousp
->is_empty ())
4838 ambiguousp
->safe_push (id
);
4839 else if (ret
!= NULL_TREE
)
4841 ambiguousp
->safe_push (ret
);
4842 ambiguousp
->safe_push (id
);
4848 if (ambiguousp
!= &ambiguous
)
4850 if (!ambiguous
.is_empty ())
4852 const char *str
= _("candidates are:");
4855 error_at (loc
, "user defined reduction lookup is ambiguous");
4856 FOR_EACH_VEC_ELT (ambiguous
, idx
, udr
)
4858 inform (DECL_SOURCE_LOCATION (udr
), "%s %#D", str
, udr
);
4860 str
= get_spaces (str
);
4862 ambiguous
.release ();
4863 ret
= error_mark_node
;
4864 baselink
= NULL_TREE
;
4869 perform_or_defer_access_check (BASELINK_BINFO (baselink
),
4870 id
, id
, tf_warning_or_error
);
4874 /* Helper function for cp_parser_omp_declare_reduction_exprs
4876 Remove CLEANUP_STMT for data (omp_priv variable).
4877 Also append INIT_EXPR for DECL_INITIAL of omp_priv after its
4881 cp_remove_omp_priv_cleanup_stmt (tree
*tp
, int *walk_subtrees
, void *data
)
4885 else if (TREE_CODE (*tp
) == CLEANUP_STMT
&& CLEANUP_DECL (*tp
) == (tree
) data
)
4886 *tp
= CLEANUP_BODY (*tp
);
4887 else if (TREE_CODE (*tp
) == DECL_EXPR
)
4889 tree decl
= DECL_EXPR_DECL (*tp
);
4890 if (!processing_template_decl
4891 && decl
== (tree
) data
4892 && DECL_INITIAL (decl
)
4893 && DECL_INITIAL (decl
) != error_mark_node
)
4895 tree list
= NULL_TREE
;
4896 append_to_statement_list_force (*tp
, &list
);
4897 tree init_expr
= build2 (INIT_EXPR
, void_type_node
,
4898 decl
, DECL_INITIAL (decl
));
4899 DECL_INITIAL (decl
) = NULL_TREE
;
4900 append_to_statement_list_force (init_expr
, &list
);
4907 /* Data passed from cp_check_omp_declare_reduction to
4908 cp_check_omp_declare_reduction_r. */
4910 struct cp_check_omp_declare_reduction_data
4917 /* Helper function for cp_check_omp_declare_reduction, called via
4921 cp_check_omp_declare_reduction_r (tree
*tp
, int *, void *data
)
4923 struct cp_check_omp_declare_reduction_data
*udr_data
4924 = (struct cp_check_omp_declare_reduction_data
*) data
;
4926 && !DECL_ARTIFICIAL (*tp
)
4927 && *tp
!= DECL_EXPR_DECL (udr_data
->stmts
[udr_data
->combiner_p
? 0 : 3])
4928 && *tp
!= DECL_EXPR_DECL (udr_data
->stmts
[udr_data
->combiner_p
? 1 : 4]))
4930 location_t loc
= udr_data
->loc
;
4931 if (udr_data
->combiner_p
)
4932 error_at (loc
, "%<#pragma omp declare reduction%> combiner refers to "
4933 "variable %qD which is not %<omp_out%> nor %<omp_in%>",
4936 error_at (loc
, "%<#pragma omp declare reduction%> initializer refers "
4937 "to variable %qD which is not %<omp_priv%> nor "
4945 /* Diagnose violation of OpenMP #pragma omp declare reduction restrictions. */
4948 cp_check_omp_declare_reduction (tree udr
)
4950 tree type
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (udr
)));
4951 gcc_assert (TREE_CODE (type
) == REFERENCE_TYPE
);
4952 type
= TREE_TYPE (type
);
4954 location_t loc
= DECL_SOURCE_LOCATION (udr
);
4956 if (type
== error_mark_node
)
4958 if (ARITHMETIC_TYPE_P (type
))
4960 static enum tree_code predef_codes
[]
4961 = { PLUS_EXPR
, MULT_EXPR
, MINUS_EXPR
, BIT_AND_EXPR
, BIT_XOR_EXPR
,
4962 BIT_IOR_EXPR
, TRUTH_ANDIF_EXPR
, TRUTH_ORIF_EXPR
};
4963 for (i
= 0; i
< 8; i
++)
4965 tree id
= omp_reduction_id (predef_codes
[i
], NULL_TREE
, NULL_TREE
);
4966 const char *n1
= IDENTIFIER_POINTER (DECL_NAME (udr
));
4967 const char *n2
= IDENTIFIER_POINTER (id
);
4968 if (strncmp (n1
, n2
, IDENTIFIER_LENGTH (id
)) == 0
4969 && (n1
[IDENTIFIER_LENGTH (id
)] == '~'
4970 || n1
[IDENTIFIER_LENGTH (id
)] == '\0'))
4975 && TREE_CODE (type
) != COMPLEX_EXPR
)
4977 const char prefix_minmax
[] = "omp declare reduction m";
4978 size_t prefix_size
= sizeof (prefix_minmax
) - 1;
4979 const char *n
= IDENTIFIER_POINTER (DECL_NAME (udr
));
4980 if (strncmp (IDENTIFIER_POINTER (DECL_NAME (udr
)),
4981 prefix_minmax
, prefix_size
) == 0
4982 && ((n
[prefix_size
] == 'i' && n
[prefix_size
+ 1] == 'n')
4983 || (n
[prefix_size
] == 'a' && n
[prefix_size
+ 1] == 'x'))
4984 && (n
[prefix_size
+ 2] == '~' || n
[prefix_size
+ 2] == '\0'))
4989 error_at (loc
, "predeclared arithmetic type %qT in "
4990 "%<#pragma omp declare reduction%>", type
);
4994 else if (TREE_CODE (type
) == FUNCTION_TYPE
4995 || TREE_CODE (type
) == METHOD_TYPE
4996 || TREE_CODE (type
) == ARRAY_TYPE
)
4998 error_at (loc
, "function or array type %qT in "
4999 "%<#pragma omp declare reduction%>", type
);
5002 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
5004 error_at (loc
, "reference type %qT in %<#pragma omp declare reduction%>",
5008 else if (TYPE_QUALS_NO_ADDR_SPACE (type
))
5010 error_at (loc
, "const, volatile or __restrict qualified type %qT in "
5011 "%<#pragma omp declare reduction%>", type
);
5015 tree body
= DECL_SAVED_TREE (udr
);
5016 if (body
== NULL_TREE
|| TREE_CODE (body
) != STATEMENT_LIST
)
5019 tree_stmt_iterator tsi
;
5020 struct cp_check_omp_declare_reduction_data data
;
5021 memset (data
.stmts
, 0, sizeof data
.stmts
);
5022 for (i
= 0, tsi
= tsi_start (body
);
5023 i
< 7 && !tsi_end_p (tsi
);
5024 i
++, tsi_next (&tsi
))
5025 data
.stmts
[i
] = tsi_stmt (tsi
);
5027 gcc_assert (tsi_end_p (tsi
));
5030 gcc_assert (TREE_CODE (data
.stmts
[0]) == DECL_EXPR
5031 && TREE_CODE (data
.stmts
[1]) == DECL_EXPR
);
5032 if (TREE_NO_WARNING (DECL_EXPR_DECL (data
.stmts
[0])))
5034 data
.combiner_p
= true;
5035 if (cp_walk_tree (&data
.stmts
[2], cp_check_omp_declare_reduction_r
,
5037 TREE_NO_WARNING (DECL_EXPR_DECL (data
.stmts
[0])) = 1;
5041 gcc_assert (TREE_CODE (data
.stmts
[3]) == DECL_EXPR
5042 && TREE_CODE (data
.stmts
[4]) == DECL_EXPR
);
5043 data
.combiner_p
= false;
5044 if (cp_walk_tree (&data
.stmts
[5], cp_check_omp_declare_reduction_r
,
5046 || cp_walk_tree (&DECL_INITIAL (DECL_EXPR_DECL (data
.stmts
[3])),
5047 cp_check_omp_declare_reduction_r
, &data
, NULL
))
5048 TREE_NO_WARNING (DECL_EXPR_DECL (data
.stmts
[0])) = 1;
5050 gcc_assert (TREE_CODE (data
.stmts
[6]) == DECL_EXPR
);
5054 /* Helper function of finish_omp_clauses. Clone STMT as if we were making
5055 an inline call. But, remap
5056 the OMP_DECL1 VAR_DECL (omp_out resp. omp_orig) to PLACEHOLDER
5057 and OMP_DECL2 VAR_DECL (omp_in resp. omp_priv) to DECL. */
5060 clone_omp_udr (tree stmt
, tree omp_decl1
, tree omp_decl2
,
5061 tree decl
, tree placeholder
)
5064 hash_map
<tree
, tree
> decl_map
;
5066 decl_map
.put (omp_decl1
, placeholder
);
5067 decl_map
.put (omp_decl2
, decl
);
5068 memset (&id
, 0, sizeof (id
));
5069 id
.src_fn
= DECL_CONTEXT (omp_decl1
);
5070 id
.dst_fn
= current_function_decl
;
5071 id
.src_cfun
= DECL_STRUCT_FUNCTION (id
.src_fn
);
5072 id
.decl_map
= &decl_map
;
5074 id
.copy_decl
= copy_decl_no_change
;
5075 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
5076 id
.transform_new_cfg
= true;
5077 id
.transform_return_to_modify
= false;
5078 id
.transform_lang_insert_block
= NULL
;
5080 walk_tree (&stmt
, copy_tree_body_r
, &id
, NULL
);
5084 /* Helper function of finish_omp_clauses, called via cp_walk_tree.
5085 Find OMP_CLAUSE_PLACEHOLDER (passed in DATA) in *TP. */
5088 find_omp_placeholder_r (tree
*tp
, int *, void *data
)
5090 if (*tp
== (tree
) data
)
5095 /* Helper function of finish_omp_clauses. Handle OMP_CLAUSE_REDUCTION C.
5096 Return true if there is some error and the clause should be removed. */
5099 finish_omp_reduction_clause (tree c
, bool *need_default_ctor
, bool *need_dtor
)
5101 tree t
= OMP_CLAUSE_DECL (c
);
5102 bool predefined
= false;
5103 tree type
= TREE_TYPE (t
);
5104 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5105 type
= TREE_TYPE (type
);
5106 if (type
== error_mark_node
)
5108 else if (ARITHMETIC_TYPE_P (type
))
5109 switch (OMP_CLAUSE_REDUCTION_CODE (c
))
5118 if (TREE_CODE (type
) == COMPLEX_TYPE
)
5125 if (FLOAT_TYPE_P (type
) || TREE_CODE (type
) == COMPLEX_TYPE
)
5129 case TRUTH_ANDIF_EXPR
:
5130 case TRUTH_ORIF_EXPR
:
5131 if (FLOAT_TYPE_P (type
))
5138 else if (TREE_CODE (type
) == ARRAY_TYPE
|| TYPE_READONLY (type
))
5140 error ("%qE has invalid type for %<reduction%>", t
);
5143 else if (!processing_template_decl
)
5145 t
= require_complete_type (t
);
5146 if (t
== error_mark_node
)
5148 OMP_CLAUSE_DECL (c
) = t
;
5153 OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
) = NULL_TREE
;
5156 else if (processing_template_decl
)
5159 tree id
= OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
);
5161 type
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
5162 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5163 type
= TREE_TYPE (type
);
5164 OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
) = NULL_TREE
;
5165 if (id
== NULL_TREE
)
5166 id
= omp_reduction_id (OMP_CLAUSE_REDUCTION_CODE (c
),
5167 NULL_TREE
, NULL_TREE
);
5168 id
= omp_reduction_lookup (OMP_CLAUSE_LOCATION (c
), id
, type
, NULL
, NULL
);
5171 if (id
== error_mark_node
)
5173 id
= OVL_CURRENT (id
);
5175 tree body
= DECL_SAVED_TREE (id
);
5178 if (TREE_CODE (body
) == STATEMENT_LIST
)
5180 tree_stmt_iterator tsi
;
5181 tree placeholder
= NULL_TREE
;
5184 tree atype
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (id
)));
5185 atype
= TREE_TYPE (atype
);
5186 bool need_static_cast
= !same_type_p (type
, atype
);
5187 memset (stmts
, 0, sizeof stmts
);
5188 for (i
= 0, tsi
= tsi_start (body
);
5189 i
< 7 && !tsi_end_p (tsi
);
5190 i
++, tsi_next (&tsi
))
5191 stmts
[i
] = tsi_stmt (tsi
);
5192 gcc_assert (tsi_end_p (tsi
));
5196 gcc_assert (TREE_CODE (stmts
[0]) == DECL_EXPR
5197 && TREE_CODE (stmts
[1]) == DECL_EXPR
);
5198 placeholder
= build_lang_decl (VAR_DECL
, NULL_TREE
, type
);
5199 DECL_ARTIFICIAL (placeholder
) = 1;
5200 DECL_IGNORED_P (placeholder
) = 1;
5201 OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
) = placeholder
;
5202 if (TREE_ADDRESSABLE (DECL_EXPR_DECL (stmts
[0])))
5203 cxx_mark_addressable (placeholder
);
5204 if (TREE_ADDRESSABLE (DECL_EXPR_DECL (stmts
[1]))
5205 && TREE_CODE (TREE_TYPE (OMP_CLAUSE_DECL (c
)))
5207 cxx_mark_addressable (OMP_CLAUSE_DECL (c
));
5208 tree omp_out
= placeholder
;
5209 tree omp_in
= convert_from_reference (OMP_CLAUSE_DECL (c
));
5210 if (need_static_cast
)
5212 tree rtype
= build_reference_type (atype
);
5213 omp_out
= build_static_cast (rtype
, omp_out
,
5214 tf_warning_or_error
);
5215 omp_in
= build_static_cast (rtype
, omp_in
,
5216 tf_warning_or_error
);
5217 if (omp_out
== error_mark_node
|| omp_in
== error_mark_node
)
5219 omp_out
= convert_from_reference (omp_out
);
5220 omp_in
= convert_from_reference (omp_in
);
5222 OMP_CLAUSE_REDUCTION_MERGE (c
)
5223 = clone_omp_udr (stmts
[2], DECL_EXPR_DECL (stmts
[0]),
5224 DECL_EXPR_DECL (stmts
[1]), omp_in
, omp_out
);
5228 gcc_assert (TREE_CODE (stmts
[3]) == DECL_EXPR
5229 && TREE_CODE (stmts
[4]) == DECL_EXPR
);
5230 if (TREE_ADDRESSABLE (DECL_EXPR_DECL (stmts
[3])))
5231 cxx_mark_addressable (OMP_CLAUSE_DECL (c
));
5232 if (TREE_ADDRESSABLE (DECL_EXPR_DECL (stmts
[4])))
5233 cxx_mark_addressable (placeholder
);
5234 tree omp_priv
= convert_from_reference (OMP_CLAUSE_DECL (c
));
5235 tree omp_orig
= placeholder
;
5236 if (need_static_cast
)
5240 error_at (OMP_CLAUSE_LOCATION (c
),
5241 "user defined reduction with constructor "
5242 "initializer for base class %qT", atype
);
5245 tree rtype
= build_reference_type (atype
);
5246 omp_priv
= build_static_cast (rtype
, omp_priv
,
5247 tf_warning_or_error
);
5248 omp_orig
= build_static_cast (rtype
, omp_orig
,
5249 tf_warning_or_error
);
5250 if (omp_priv
== error_mark_node
5251 || omp_orig
== error_mark_node
)
5253 omp_priv
= convert_from_reference (omp_priv
);
5254 omp_orig
= convert_from_reference (omp_orig
);
5257 *need_default_ctor
= true;
5258 OMP_CLAUSE_REDUCTION_INIT (c
)
5259 = clone_omp_udr (stmts
[5], DECL_EXPR_DECL (stmts
[4]),
5260 DECL_EXPR_DECL (stmts
[3]),
5261 omp_priv
, omp_orig
);
5262 if (cp_walk_tree (&OMP_CLAUSE_REDUCTION_INIT (c
),
5263 find_omp_placeholder_r
, placeholder
, NULL
))
5264 OMP_CLAUSE_REDUCTION_OMP_ORIG_REF (c
) = 1;
5268 if (CLASS_TYPE_P (type
) && !pod_type_p (type
))
5269 *need_default_ctor
= true;
5273 tree v
= convert_from_reference (t
);
5274 if (AGGREGATE_TYPE_P (TREE_TYPE (v
)))
5275 init
= build_constructor (TREE_TYPE (v
), NULL
);
5277 init
= fold_convert (TREE_TYPE (v
), integer_zero_node
);
5278 OMP_CLAUSE_REDUCTION_INIT (c
)
5279 = build2 (INIT_EXPR
, TREE_TYPE (v
), v
, init
);
5284 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
))
5288 error ("user defined reduction not found for %qD", t
);
5294 /* For all elements of CLAUSES, validate them vs OpenMP constraints.
5295 Remove any elements from the list that are invalid. */
5298 finish_omp_clauses (tree clauses
)
5300 bitmap_head generic_head
, firstprivate_head
, lastprivate_head
;
5301 bitmap_head aligned_head
;
5303 bool branch_seen
= false;
5304 bool copyprivate_seen
= false;
5306 bitmap_obstack_initialize (NULL
);
5307 bitmap_initialize (&generic_head
, &bitmap_default_obstack
);
5308 bitmap_initialize (&firstprivate_head
, &bitmap_default_obstack
);
5309 bitmap_initialize (&lastprivate_head
, &bitmap_default_obstack
);
5310 bitmap_initialize (&aligned_head
, &bitmap_default_obstack
);
5312 for (pc
= &clauses
, c
= clauses
; c
; c
= *pc
)
5314 bool remove
= false;
5316 switch (OMP_CLAUSE_CODE (c
))
5318 case OMP_CLAUSE_SHARED
:
5319 goto check_dup_generic
;
5320 case OMP_CLAUSE_PRIVATE
:
5321 goto check_dup_generic
;
5322 case OMP_CLAUSE_REDUCTION
:
5323 goto check_dup_generic
;
5324 case OMP_CLAUSE_COPYPRIVATE
:
5325 copyprivate_seen
= true;
5326 goto check_dup_generic
;
5327 case OMP_CLAUSE_COPYIN
:
5328 goto check_dup_generic
;
5329 case OMP_CLAUSE_LINEAR
:
5330 t
= OMP_CLAUSE_DECL (c
);
5331 if (!type_dependent_expression_p (t
)
5332 && !INTEGRAL_TYPE_P (TREE_TYPE (t
))
5333 && TREE_CODE (TREE_TYPE (t
)) != POINTER_TYPE
)
5335 error ("linear clause applied to non-integral non-pointer "
5336 "variable with %qT type", TREE_TYPE (t
));
5340 t
= OMP_CLAUSE_LINEAR_STEP (c
);
5342 t
= integer_one_node
;
5343 if (t
== error_mark_node
)
5348 else if (!type_dependent_expression_p (t
)
5349 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
5351 error ("linear step expression must be integral");
5357 t
= mark_rvalue_use (t
);
5358 if (!processing_template_decl
)
5360 if (TREE_CODE (OMP_CLAUSE_DECL (c
)) == PARM_DECL
)
5361 t
= maybe_constant_value (t
);
5362 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
5363 if (TREE_CODE (TREE_TYPE (OMP_CLAUSE_DECL (c
)))
5366 t
= pointer_int_sum (OMP_CLAUSE_LOCATION (c
), PLUS_EXPR
,
5367 OMP_CLAUSE_DECL (c
), t
);
5368 t
= fold_build2_loc (OMP_CLAUSE_LOCATION (c
),
5369 MINUS_EXPR
, sizetype
, t
,
5370 OMP_CLAUSE_DECL (c
));
5371 if (t
== error_mark_node
)
5378 t
= fold_convert (TREE_TYPE (OMP_CLAUSE_DECL (c
)), t
);
5380 OMP_CLAUSE_LINEAR_STEP (c
) = t
;
5382 goto check_dup_generic
;
5384 t
= OMP_CLAUSE_DECL (c
);
5385 if (!VAR_P (t
) && TREE_CODE (t
) != PARM_DECL
)
5387 if (processing_template_decl
)
5390 error ("%qD is not a variable in clause %qs", t
,
5391 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
5393 error ("%qE is not a variable in clause %qs", t
,
5394 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
5397 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
5398 || bitmap_bit_p (&firstprivate_head
, DECL_UID (t
))
5399 || bitmap_bit_p (&lastprivate_head
, DECL_UID (t
)))
5401 error ("%qD appears more than once in data clauses", t
);
5405 bitmap_set_bit (&generic_head
, DECL_UID (t
));
5408 case OMP_CLAUSE_FIRSTPRIVATE
:
5409 t
= OMP_CLAUSE_DECL (c
);
5410 if (!VAR_P (t
) && TREE_CODE (t
) != PARM_DECL
)
5412 if (processing_template_decl
)
5415 error ("%qD is not a variable in clause %<firstprivate%>", t
);
5417 error ("%qE is not a variable in clause %<firstprivate%>", t
);
5420 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
5421 || bitmap_bit_p (&firstprivate_head
, DECL_UID (t
)))
5423 error ("%qD appears more than once in data clauses", t
);
5427 bitmap_set_bit (&firstprivate_head
, DECL_UID (t
));
5430 case OMP_CLAUSE_LASTPRIVATE
:
5431 t
= OMP_CLAUSE_DECL (c
);
5432 if (!VAR_P (t
) && TREE_CODE (t
) != PARM_DECL
)
5434 if (processing_template_decl
)
5437 error ("%qD is not a variable in clause %<lastprivate%>", t
);
5439 error ("%qE is not a variable in clause %<lastprivate%>", t
);
5442 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
5443 || bitmap_bit_p (&lastprivate_head
, DECL_UID (t
)))
5445 error ("%qD appears more than once in data clauses", t
);
5449 bitmap_set_bit (&lastprivate_head
, DECL_UID (t
));
5453 t
= OMP_CLAUSE_IF_EXPR (c
);
5454 t
= maybe_convert_cond (t
);
5455 if (t
== error_mark_node
)
5457 else if (!processing_template_decl
)
5458 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
5459 OMP_CLAUSE_IF_EXPR (c
) = t
;
5462 case OMP_CLAUSE_FINAL
:
5463 t
= OMP_CLAUSE_FINAL_EXPR (c
);
5464 t
= maybe_convert_cond (t
);
5465 if (t
== error_mark_node
)
5467 else if (!processing_template_decl
)
5468 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
5469 OMP_CLAUSE_FINAL_EXPR (c
) = t
;
5472 case OMP_CLAUSE_NUM_THREADS
:
5473 t
= OMP_CLAUSE_NUM_THREADS_EXPR (c
);
5474 if (t
== error_mark_node
)
5476 else if (!type_dependent_expression_p (t
)
5477 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
5479 error ("num_threads expression must be integral");
5484 t
= mark_rvalue_use (t
);
5485 if (!processing_template_decl
)
5486 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
5487 OMP_CLAUSE_NUM_THREADS_EXPR (c
) = t
;
5491 case OMP_CLAUSE_SCHEDULE
:
5492 t
= OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c
);
5495 else if (t
== error_mark_node
)
5497 else if (!type_dependent_expression_p (t
)
5498 && (OMP_CLAUSE_SCHEDULE_KIND (c
)
5499 != OMP_CLAUSE_SCHEDULE_CILKFOR
)
5500 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
5502 error ("schedule chunk size expression must be integral");
5507 t
= mark_rvalue_use (t
);
5508 if (!processing_template_decl
)
5510 if (OMP_CLAUSE_SCHEDULE_KIND (c
)
5511 == OMP_CLAUSE_SCHEDULE_CILKFOR
)
5513 t
= convert_to_integer (long_integer_type_node
, t
);
5514 if (t
== error_mark_node
)
5520 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
5522 OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c
) = t
;
5526 case OMP_CLAUSE_SIMDLEN
:
5527 case OMP_CLAUSE_SAFELEN
:
5528 t
= OMP_CLAUSE_OPERAND (c
, 0);
5529 if (t
== error_mark_node
)
5531 else if (!type_dependent_expression_p (t
)
5532 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
5534 error ("%qs length expression must be integral",
5535 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
5540 t
= mark_rvalue_use (t
);
5541 t
= maybe_constant_value (t
);
5542 if (!processing_template_decl
)
5544 if (TREE_CODE (t
) != INTEGER_CST
5545 || tree_int_cst_sgn (t
) != 1)
5547 error ("%qs length expression must be positive constant"
5548 " integer expression",
5549 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
5553 OMP_CLAUSE_OPERAND (c
, 0) = t
;
5557 case OMP_CLAUSE_NUM_TEAMS
:
5558 t
= OMP_CLAUSE_NUM_TEAMS_EXPR (c
);
5559 if (t
== error_mark_node
)
5561 else if (!type_dependent_expression_p (t
)
5562 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
5564 error ("%<num_teams%> expression must be integral");
5569 t
= mark_rvalue_use (t
);
5570 if (!processing_template_decl
)
5571 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
5572 OMP_CLAUSE_NUM_TEAMS_EXPR (c
) = t
;
5576 case OMP_CLAUSE_ASYNC
:
5577 t
= OMP_CLAUSE_ASYNC_EXPR (c
);
5578 if (t
== error_mark_node
)
5580 else if (!type_dependent_expression_p (t
)
5581 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
5583 error ("%<async%> expression must be integral");
5588 t
= mark_rvalue_use (t
);
5589 if (!processing_template_decl
)
5590 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
5591 OMP_CLAUSE_ASYNC_EXPR (c
) = t
;
5595 case OMP_CLAUSE_VECTOR_LENGTH
:
5596 t
= OMP_CLAUSE_VECTOR_LENGTH_EXPR (c
);
5597 t
= maybe_convert_cond (t
);
5598 if (t
== error_mark_node
)
5600 else if (!processing_template_decl
)
5601 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
5602 OMP_CLAUSE_VECTOR_LENGTH_EXPR (c
) = t
;
5605 case OMP_CLAUSE_WAIT
:
5606 t
= OMP_CLAUSE_WAIT_EXPR (c
);
5607 if (t
== error_mark_node
)
5609 else if (!processing_template_decl
)
5610 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
5611 OMP_CLAUSE_WAIT_EXPR (c
) = t
;
5614 case OMP_CLAUSE_THREAD_LIMIT
:
5615 t
= OMP_CLAUSE_THREAD_LIMIT_EXPR (c
);
5616 if (t
== error_mark_node
)
5618 else if (!type_dependent_expression_p (t
)
5619 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
5621 error ("%<thread_limit%> expression must be integral");
5626 t
= mark_rvalue_use (t
);
5627 if (!processing_template_decl
)
5628 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
5629 OMP_CLAUSE_THREAD_LIMIT_EXPR (c
) = t
;
5633 case OMP_CLAUSE_DEVICE
:
5634 t
= OMP_CLAUSE_DEVICE_ID (c
);
5635 if (t
== error_mark_node
)
5637 else if (!type_dependent_expression_p (t
)
5638 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
5640 error ("%<device%> id must be integral");
5645 t
= mark_rvalue_use (t
);
5646 if (!processing_template_decl
)
5647 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
5648 OMP_CLAUSE_DEVICE_ID (c
) = t
;
5652 case OMP_CLAUSE_DIST_SCHEDULE
:
5653 t
= OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (c
);
5656 else if (t
== error_mark_node
)
5658 else if (!type_dependent_expression_p (t
)
5659 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
5661 error ("%<dist_schedule%> chunk size expression must be "
5667 t
= mark_rvalue_use (t
);
5668 if (!processing_template_decl
)
5669 t
= fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
5670 OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (c
) = t
;
5674 case OMP_CLAUSE_ALIGNED
:
5675 t
= OMP_CLAUSE_DECL (c
);
5676 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
5678 if (processing_template_decl
)
5681 error ("%qD is not a variable in %<aligned%> clause", t
);
5683 error ("%qE is not a variable in %<aligned%> clause", t
);
5686 else if (!type_dependent_expression_p (t
)
5687 && TREE_CODE (TREE_TYPE (t
)) != POINTER_TYPE
5688 && TREE_CODE (TREE_TYPE (t
)) != ARRAY_TYPE
5689 && (TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
5690 || (!POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (t
)))
5691 && (TREE_CODE (TREE_TYPE (TREE_TYPE (t
)))
5694 error_at (OMP_CLAUSE_LOCATION (c
),
5695 "%qE in %<aligned%> clause is neither a pointer nor "
5696 "an array nor a reference to pointer or array", t
);
5699 else if (bitmap_bit_p (&aligned_head
, DECL_UID (t
)))
5701 error ("%qD appears more than once in %<aligned%> clauses", t
);
5705 bitmap_set_bit (&aligned_head
, DECL_UID (t
));
5706 t
= OMP_CLAUSE_ALIGNED_ALIGNMENT (c
);
5707 if (t
== error_mark_node
)
5709 else if (t
== NULL_TREE
)
5711 else if (!type_dependent_expression_p (t
)
5712 && !INTEGRAL_TYPE_P (TREE_TYPE (t
)))
5714 error ("%<aligned%> clause alignment expression must "
5720 t
= mark_rvalue_use (t
);
5721 t
= maybe_constant_value (t
);
5722 if (!processing_template_decl
)
5724 if (TREE_CODE (t
) != INTEGER_CST
5725 || tree_int_cst_sgn (t
) != 1)
5727 error ("%<aligned%> clause alignment expression must be "
5728 "positive constant integer expression");
5732 OMP_CLAUSE_ALIGNED_ALIGNMENT (c
) = t
;
5736 case OMP_CLAUSE_DEPEND
:
5737 t
= OMP_CLAUSE_DECL (c
);
5738 if (TREE_CODE (t
) == TREE_LIST
)
5740 if (handle_omp_array_sections (c
))
5744 if (t
== error_mark_node
)
5746 else if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
5748 if (processing_template_decl
)
5751 error ("%qD is not a variable in %<depend%> clause", t
);
5753 error ("%qE is not a variable in %<depend%> clause", t
);
5756 else if (!processing_template_decl
5757 && !cxx_mark_addressable (t
))
5761 case OMP_CLAUSE_MAP
:
5763 case OMP_CLAUSE_FROM
:
5764 case OMP_CLAUSE__CACHE_
:
5765 t
= OMP_CLAUSE_DECL (c
);
5766 if (TREE_CODE (t
) == TREE_LIST
)
5768 if (handle_omp_array_sections (c
))
5772 t
= OMP_CLAUSE_DECL (c
);
5773 if (TREE_CODE (t
) != TREE_LIST
5774 && !type_dependent_expression_p (t
)
5775 && !cp_omp_mappable_type (TREE_TYPE (t
)))
5777 error_at (OMP_CLAUSE_LOCATION (c
),
5778 "array section does not have mappable type "
5780 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
5786 if (t
== error_mark_node
)
5788 else if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
5790 if (processing_template_decl
)
5792 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_MAP
5793 && OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_POINTER
)
5796 error ("%qD is not a variable in %qs clause", t
,
5797 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
5799 error ("%qE is not a variable in %qs clause", t
,
5800 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
5803 else if (TREE_CODE (t
) == VAR_DECL
&& DECL_THREAD_LOCAL_P (t
))
5805 error ("%qD is threadprivate variable in %qs clause", t
,
5806 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
5809 else if (!processing_template_decl
5810 && TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
5811 && !cxx_mark_addressable (t
))
5813 else if (!(OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_MAP
5814 && OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_POINTER
)
5815 && !type_dependent_expression_p (t
)
5816 && !cp_omp_mappable_type ((TREE_CODE (TREE_TYPE (t
))
5818 ? TREE_TYPE (TREE_TYPE (t
))
5821 error_at (OMP_CLAUSE_LOCATION (c
),
5822 "%qD does not have a mappable type in %qs clause", t
,
5823 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
5826 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
)))
5828 if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_MAP
)
5829 error ("%qD appears more than once in motion clauses", t
);
5831 error ("%qD appears more than once in map clauses", t
);
5835 bitmap_set_bit (&generic_head
, DECL_UID (t
));
5838 case OMP_CLAUSE_UNIFORM
:
5839 t
= OMP_CLAUSE_DECL (c
);
5840 if (TREE_CODE (t
) != PARM_DECL
)
5842 if (processing_template_decl
)
5845 error ("%qD is not an argument in %<uniform%> clause", t
);
5847 error ("%qE is not an argument in %<uniform%> clause", t
);
5851 goto check_dup_generic
;
5853 case OMP_CLAUSE_NOWAIT
:
5854 case OMP_CLAUSE_ORDERED
:
5855 case OMP_CLAUSE_DEFAULT
:
5856 case OMP_CLAUSE_UNTIED
:
5857 case OMP_CLAUSE_COLLAPSE
:
5858 case OMP_CLAUSE_MERGEABLE
:
5859 case OMP_CLAUSE_PARALLEL
:
5860 case OMP_CLAUSE_FOR
:
5861 case OMP_CLAUSE_SECTIONS
:
5862 case OMP_CLAUSE_TASKGROUP
:
5863 case OMP_CLAUSE_PROC_BIND
:
5864 case OMP_CLAUSE__CILK_FOR_COUNT_
:
5867 case OMP_CLAUSE_INBRANCH
:
5868 case OMP_CLAUSE_NOTINBRANCH
:
5871 error ("%<inbranch%> clause is incompatible with "
5883 *pc
= OMP_CLAUSE_CHAIN (c
);
5885 pc
= &OMP_CLAUSE_CHAIN (c
);
5888 for (pc
= &clauses
, c
= clauses
; c
; c
= *pc
)
5890 enum omp_clause_code c_kind
= OMP_CLAUSE_CODE (c
);
5891 bool remove
= false;
5892 bool need_complete_non_reference
= false;
5893 bool need_default_ctor
= false;
5894 bool need_copy_ctor
= false;
5895 bool need_copy_assignment
= false;
5896 bool need_implicitly_determined
= false;
5897 bool need_dtor
= false;
5898 tree type
, inner_type
;
5902 case OMP_CLAUSE_SHARED
:
5903 need_implicitly_determined
= true;
5905 case OMP_CLAUSE_PRIVATE
:
5906 need_complete_non_reference
= true;
5907 need_default_ctor
= true;
5909 need_implicitly_determined
= true;
5911 case OMP_CLAUSE_FIRSTPRIVATE
:
5912 need_complete_non_reference
= true;
5913 need_copy_ctor
= true;
5915 need_implicitly_determined
= true;
5917 case OMP_CLAUSE_LASTPRIVATE
:
5918 need_complete_non_reference
= true;
5919 need_copy_assignment
= true;
5920 need_implicitly_determined
= true;
5922 case OMP_CLAUSE_REDUCTION
:
5923 need_implicitly_determined
= true;
5925 case OMP_CLAUSE_COPYPRIVATE
:
5926 need_copy_assignment
= true;
5928 case OMP_CLAUSE_COPYIN
:
5929 need_copy_assignment
= true;
5931 case OMP_CLAUSE_NOWAIT
:
5932 if (copyprivate_seen
)
5934 error_at (OMP_CLAUSE_LOCATION (c
),
5935 "%<nowait%> clause must not be used together "
5936 "with %<copyprivate%>");
5937 *pc
= OMP_CLAUSE_CHAIN (c
);
5942 pc
= &OMP_CLAUSE_CHAIN (c
);
5946 t
= OMP_CLAUSE_DECL (c
);
5947 if (processing_template_decl
5948 && !VAR_P (t
) && TREE_CODE (t
) != PARM_DECL
)
5950 pc
= &OMP_CLAUSE_CHAIN (c
);
5956 case OMP_CLAUSE_LASTPRIVATE
:
5957 if (!bitmap_bit_p (&firstprivate_head
, DECL_UID (t
)))
5959 need_default_ctor
= true;
5964 case OMP_CLAUSE_REDUCTION
:
5965 if (finish_omp_reduction_clause (c
, &need_default_ctor
,
5969 t
= OMP_CLAUSE_DECL (c
);
5972 case OMP_CLAUSE_COPYIN
:
5973 if (!VAR_P (t
) || !DECL_THREAD_LOCAL_P (t
))
5975 error ("%qE must be %<threadprivate%> for %<copyin%>", t
);
5984 if (need_complete_non_reference
|| need_copy_assignment
)
5986 t
= require_complete_type (t
);
5987 if (t
== error_mark_node
)
5989 else if (TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
5990 && need_complete_non_reference
)
5992 error ("%qE has reference type for %qs", t
,
5993 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
5997 if (need_implicitly_determined
)
5999 const char *share_name
= NULL
;
6001 if (VAR_P (t
) && DECL_THREAD_LOCAL_P (t
))
6002 share_name
= "threadprivate";
6003 else switch (cxx_omp_predetermined_sharing (t
))
6005 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
6007 case OMP_CLAUSE_DEFAULT_SHARED
:
6008 /* const vars may be specified in firstprivate clause. */
6009 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
6010 && cxx_omp_const_qual_no_mutable (t
))
6012 share_name
= "shared";
6014 case OMP_CLAUSE_DEFAULT_PRIVATE
:
6015 share_name
= "private";
6022 error ("%qE is predetermined %qs for %qs",
6023 t
, share_name
, omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
6028 /* We're interested in the base element, not arrays. */
6029 inner_type
= type
= TREE_TYPE (t
);
6030 while (TREE_CODE (inner_type
) == ARRAY_TYPE
)
6031 inner_type
= TREE_TYPE (inner_type
);
6033 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
6034 && TREE_CODE (inner_type
) == REFERENCE_TYPE
)
6035 inner_type
= TREE_TYPE (inner_type
);
6037 /* Check for special function availability by building a call to one.
6038 Save the results, because later we won't be in the right context
6039 for making these queries. */
6040 if (CLASS_TYPE_P (inner_type
)
6041 && COMPLETE_TYPE_P (inner_type
)
6042 && (need_default_ctor
|| need_copy_ctor
6043 || need_copy_assignment
|| need_dtor
)
6044 && !type_dependent_expression_p (t
)
6045 && cxx_omp_create_clause_info (c
, inner_type
, need_default_ctor
,
6046 need_copy_ctor
, need_copy_assignment
,
6051 *pc
= OMP_CLAUSE_CHAIN (c
);
6053 pc
= &OMP_CLAUSE_CHAIN (c
);
6056 bitmap_obstack_release (NULL
);
6060 /* For all variables in the tree_list VARS, mark them as thread local. */
6063 finish_omp_threadprivate (tree vars
)
6067 /* Mark every variable in VARS to be assigned thread local storage. */
6068 for (t
= vars
; t
; t
= TREE_CHAIN (t
))
6070 tree v
= TREE_PURPOSE (t
);
6072 if (error_operand_p (v
))
6074 else if (!VAR_P (v
))
6075 error ("%<threadprivate%> %qD is not file, namespace "
6076 "or block scope variable", v
);
6077 /* If V had already been marked threadprivate, it doesn't matter
6078 whether it had been used prior to this point. */
6079 else if (TREE_USED (v
)
6080 && (DECL_LANG_SPECIFIC (v
) == NULL
6081 || !CP_DECL_THREADPRIVATE_P (v
)))
6082 error ("%qE declared %<threadprivate%> after first use", v
);
6083 else if (! TREE_STATIC (v
) && ! DECL_EXTERNAL (v
))
6084 error ("automatic variable %qE cannot be %<threadprivate%>", v
);
6085 else if (! COMPLETE_TYPE_P (complete_type (TREE_TYPE (v
))))
6086 error ("%<threadprivate%> %qE has incomplete type", v
);
6087 else if (TREE_STATIC (v
) && TYPE_P (CP_DECL_CONTEXT (v
))
6088 && CP_DECL_CONTEXT (v
) != current_class_type
)
6089 error ("%<threadprivate%> %qE directive not "
6090 "in %qT definition", v
, CP_DECL_CONTEXT (v
));
6093 /* Allocate a LANG_SPECIFIC structure for V, if needed. */
6094 if (DECL_LANG_SPECIFIC (v
) == NULL
)
6096 retrofit_lang_decl (v
);
6098 /* Make sure that DECL_DISCRIMINATOR_P continues to be true
6099 after the allocation of the lang_decl structure. */
6100 if (DECL_DISCRIMINATOR_P (v
))
6101 DECL_LANG_SPECIFIC (v
)->u
.base
.u2sel
= 1;
6104 if (! DECL_THREAD_LOCAL_P (v
))
6106 set_decl_tls_model (v
, decl_default_tls_model (v
));
6107 /* If rtl has been already set for this var, call
6108 make_decl_rtl once again, so that encode_section_info
6109 has a chance to look at the new decl flags. */
6110 if (DECL_RTL_SET_P (v
))
6113 CP_DECL_THREADPRIVATE_P (v
) = 1;
6118 /* Build an OpenMP structured block. */
6121 begin_omp_structured_block (void)
6123 return do_pushlevel (sk_omp
);
6127 finish_omp_structured_block (tree block
)
6129 return do_poplevel (block
);
6132 /* Generate OACC_DATA, with CLAUSES and BLOCK as its compound
6133 statement. LOC is the location of the OACC_DATA. */
6136 finish_oacc_data (tree clauses
, tree block
)
6140 block
= finish_omp_structured_block (block
);
6142 stmt
= make_node (OACC_DATA
);
6143 TREE_TYPE (stmt
) = void_type_node
;
6144 OACC_DATA_CLAUSES (stmt
) = clauses
;
6145 OACC_DATA_BODY (stmt
) = block
;
6147 return add_stmt (stmt
);
6150 /* Generate OACC_KERNELS, with CLAUSES and BLOCK as its compound
6151 statement. LOC is the location of the OACC_KERNELS. */
6154 finish_oacc_kernels (tree clauses
, tree block
)
6158 block
= finish_omp_structured_block (block
);
6160 stmt
= make_node (OACC_KERNELS
);
6161 TREE_TYPE (stmt
) = void_type_node
;
6162 OACC_KERNELS_CLAUSES (stmt
) = clauses
;
6163 OACC_KERNELS_BODY (stmt
) = block
;
6165 return add_stmt (stmt
);
6168 /* Generate OACC_PARALLEL, with CLAUSES and BLOCK as its compound
6169 statement. LOC is the location of the OACC_PARALLEL. */
6172 finish_oacc_parallel (tree clauses
, tree block
)
6176 block
= finish_omp_structured_block (block
);
6178 stmt
= make_node (OACC_PARALLEL
);
6179 TREE_TYPE (stmt
) = void_type_node
;
6180 OACC_PARALLEL_CLAUSES (stmt
) = clauses
;
6181 OACC_PARALLEL_BODY (stmt
) = block
;
6183 return add_stmt (stmt
);
6186 /* Similarly, except force the retention of the BLOCK. */
6189 begin_omp_parallel (void)
6191 keep_next_level (true);
6192 return begin_omp_structured_block ();
6196 finish_omp_parallel (tree clauses
, tree body
)
6200 body
= finish_omp_structured_block (body
);
6202 stmt
= make_node (OMP_PARALLEL
);
6203 TREE_TYPE (stmt
) = void_type_node
;
6204 OMP_PARALLEL_CLAUSES (stmt
) = clauses
;
6205 OMP_PARALLEL_BODY (stmt
) = body
;
6207 return add_stmt (stmt
);
6211 begin_omp_task (void)
6213 keep_next_level (true);
6214 return begin_omp_structured_block ();
6218 finish_omp_task (tree clauses
, tree body
)
6222 body
= finish_omp_structured_block (body
);
6224 stmt
= make_node (OMP_TASK
);
6225 TREE_TYPE (stmt
) = void_type_node
;
6226 OMP_TASK_CLAUSES (stmt
) = clauses
;
6227 OMP_TASK_BODY (stmt
) = body
;
6229 return add_stmt (stmt
);
6232 /* Helper function for finish_omp_for. Convert Ith random access iterator
6233 into integral iterator. Return FALSE if successful. */
6236 handle_omp_for_class_iterator (int i
, location_t locus
, tree declv
, tree initv
,
6237 tree condv
, tree incrv
, tree
*body
,
6238 tree
*pre_body
, tree clauses
, tree
*lastp
)
6240 tree diff
, iter_init
, iter_incr
= NULL
, last
;
6241 tree incr_var
= NULL
, orig_pre_body
, orig_body
, c
;
6242 tree decl
= TREE_VEC_ELT (declv
, i
);
6243 tree init
= TREE_VEC_ELT (initv
, i
);
6244 tree cond
= TREE_VEC_ELT (condv
, i
);
6245 tree incr
= TREE_VEC_ELT (incrv
, i
);
6247 location_t elocus
= locus
;
6249 if (init
&& EXPR_HAS_LOCATION (init
))
6250 elocus
= EXPR_LOCATION (init
);
6252 switch (TREE_CODE (cond
))
6259 if (TREE_OPERAND (cond
, 1) == iter
)
6260 cond
= build2 (swap_tree_comparison (TREE_CODE (cond
)),
6261 TREE_TYPE (cond
), iter
, TREE_OPERAND (cond
, 0));
6262 if (TREE_OPERAND (cond
, 0) != iter
)
6263 cond
= error_mark_node
;
6266 tree tem
= build_x_binary_op (EXPR_LOCATION (cond
),
6269 TREE_OPERAND (cond
, 1), ERROR_MARK
,
6270 NULL
, tf_warning_or_error
);
6271 if (error_operand_p (tem
))
6276 cond
= error_mark_node
;
6279 if (cond
== error_mark_node
)
6281 error_at (elocus
, "invalid controlling predicate");
6284 diff
= build_x_binary_op (elocus
, MINUS_EXPR
, TREE_OPERAND (cond
, 1),
6285 ERROR_MARK
, iter
, ERROR_MARK
, NULL
,
6286 tf_warning_or_error
);
6287 if (error_operand_p (diff
))
6289 if (TREE_CODE (TREE_TYPE (diff
)) != INTEGER_TYPE
)
6291 error_at (elocus
, "difference between %qE and %qD does not have integer type",
6292 TREE_OPERAND (cond
, 1), iter
);
6296 switch (TREE_CODE (incr
))
6298 case PREINCREMENT_EXPR
:
6299 case PREDECREMENT_EXPR
:
6300 case POSTINCREMENT_EXPR
:
6301 case POSTDECREMENT_EXPR
:
6302 if (TREE_OPERAND (incr
, 0) != iter
)
6304 incr
= error_mark_node
;
6307 iter_incr
= build_x_unary_op (EXPR_LOCATION (incr
),
6308 TREE_CODE (incr
), iter
,
6309 tf_warning_or_error
);
6310 if (error_operand_p (iter_incr
))
6312 else if (TREE_CODE (incr
) == PREINCREMENT_EXPR
6313 || TREE_CODE (incr
) == POSTINCREMENT_EXPR
)
6314 incr
= integer_one_node
;
6316 incr
= integer_minus_one_node
;
6319 if (TREE_OPERAND (incr
, 0) != iter
)
6320 incr
= error_mark_node
;
6321 else if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
6322 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
6324 tree rhs
= TREE_OPERAND (incr
, 1);
6325 if (TREE_OPERAND (rhs
, 0) == iter
)
6327 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs
, 1)))
6329 incr
= error_mark_node
;
6332 iter_incr
= build_x_modify_expr (EXPR_LOCATION (rhs
),
6333 iter
, TREE_CODE (rhs
),
6334 TREE_OPERAND (rhs
, 1),
6335 tf_warning_or_error
);
6336 if (error_operand_p (iter_incr
))
6338 incr
= TREE_OPERAND (rhs
, 1);
6339 incr
= cp_convert (TREE_TYPE (diff
), incr
,
6340 tf_warning_or_error
);
6341 if (TREE_CODE (rhs
) == MINUS_EXPR
)
6343 incr
= build1 (NEGATE_EXPR
, TREE_TYPE (diff
), incr
);
6344 incr
= fold_if_not_in_template (incr
);
6346 if (TREE_CODE (incr
) != INTEGER_CST
6347 && (TREE_CODE (incr
) != NOP_EXPR
6348 || (TREE_CODE (TREE_OPERAND (incr
, 0))
6353 else if (TREE_OPERAND (rhs
, 1) == iter
)
6355 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs
, 0))) != INTEGER_TYPE
6356 || TREE_CODE (rhs
) != PLUS_EXPR
)
6357 incr
= error_mark_node
;
6360 iter_incr
= build_x_binary_op (EXPR_LOCATION (rhs
),
6362 TREE_OPERAND (rhs
, 0),
6365 tf_warning_or_error
);
6366 if (error_operand_p (iter_incr
))
6368 iter_incr
= build_x_modify_expr (EXPR_LOCATION (rhs
),
6371 tf_warning_or_error
);
6372 if (error_operand_p (iter_incr
))
6374 incr
= TREE_OPERAND (rhs
, 0);
6379 incr
= error_mark_node
;
6382 incr
= error_mark_node
;
6385 incr
= error_mark_node
;
6389 if (incr
== error_mark_node
)
6391 error_at (elocus
, "invalid increment expression");
6395 incr
= cp_convert (TREE_TYPE (diff
), incr
, tf_warning_or_error
);
6396 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
6397 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
6398 && OMP_CLAUSE_DECL (c
) == iter
)
6401 decl
= create_temporary_var (TREE_TYPE (diff
));
6403 add_decl_expr (decl
);
6404 last
= create_temporary_var (TREE_TYPE (diff
));
6406 add_decl_expr (last
);
6407 if (c
&& iter_incr
== NULL
)
6409 incr_var
= create_temporary_var (TREE_TYPE (diff
));
6410 pushdecl (incr_var
);
6411 add_decl_expr (incr_var
);
6413 gcc_assert (stmts_are_full_exprs_p ());
6415 orig_pre_body
= *pre_body
;
6416 *pre_body
= push_stmt_list ();
6418 add_stmt (orig_pre_body
);
6420 finish_expr_stmt (build_x_modify_expr (elocus
,
6421 iter
, NOP_EXPR
, init
,
6422 tf_warning_or_error
));
6423 init
= build_int_cst (TREE_TYPE (diff
), 0);
6424 if (c
&& iter_incr
== NULL
)
6426 finish_expr_stmt (build_x_modify_expr (elocus
,
6428 incr
, tf_warning_or_error
));
6430 iter_incr
= build_x_modify_expr (elocus
,
6431 iter
, PLUS_EXPR
, incr
,
6432 tf_warning_or_error
);
6434 finish_expr_stmt (build_x_modify_expr (elocus
,
6435 last
, NOP_EXPR
, init
,
6436 tf_warning_or_error
));
6437 *pre_body
= pop_stmt_list (*pre_body
);
6439 cond
= cp_build_binary_op (elocus
,
6440 TREE_CODE (cond
), decl
, diff
,
6441 tf_warning_or_error
);
6442 incr
= build_modify_expr (elocus
, decl
, NULL_TREE
, PLUS_EXPR
,
6443 elocus
, incr
, NULL_TREE
);
6446 *body
= push_stmt_list ();
6447 iter_init
= build2 (MINUS_EXPR
, TREE_TYPE (diff
), decl
, last
);
6448 iter_init
= build_x_modify_expr (elocus
,
6449 iter
, PLUS_EXPR
, iter_init
,
6450 tf_warning_or_error
);
6451 iter_init
= build1 (NOP_EXPR
, void_type_node
, iter_init
);
6452 finish_expr_stmt (iter_init
);
6453 finish_expr_stmt (build_x_modify_expr (elocus
,
6454 last
, NOP_EXPR
, decl
,
6455 tf_warning_or_error
));
6456 add_stmt (orig_body
);
6457 *body
= pop_stmt_list (*body
);
6461 OMP_CLAUSE_LASTPRIVATE_STMT (c
) = push_stmt_list ();
6462 finish_expr_stmt (iter_incr
);
6463 OMP_CLAUSE_LASTPRIVATE_STMT (c
)
6464 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (c
));
6467 TREE_VEC_ELT (declv
, i
) = decl
;
6468 TREE_VEC_ELT (initv
, i
) = init
;
6469 TREE_VEC_ELT (condv
, i
) = cond
;
6470 TREE_VEC_ELT (incrv
, i
) = incr
;
6476 /* Build and validate an OMP_FOR statement. CLAUSES, BODY, COND, INCR
6477 are directly for their associated operands in the statement. DECL
6478 and INIT are a combo; if DECL is NULL then INIT ought to be a
6479 MODIFY_EXPR, and the DECL should be extracted. PRE_BODY are
6480 optional statements that need to go before the loop into its
6484 finish_omp_for (location_t locus
, enum tree_code code
, tree declv
, tree initv
,
6485 tree condv
, tree incrv
, tree body
, tree pre_body
, tree clauses
)
6487 tree omp_for
= NULL
, orig_incr
= NULL
;
6488 tree decl
= NULL
, init
, cond
, incr
, orig_decl
= NULL_TREE
, block
= NULL_TREE
;
6489 tree last
= NULL_TREE
;
6493 gcc_assert (TREE_VEC_LENGTH (declv
) == TREE_VEC_LENGTH (initv
));
6494 gcc_assert (TREE_VEC_LENGTH (declv
) == TREE_VEC_LENGTH (condv
));
6495 gcc_assert (TREE_VEC_LENGTH (declv
) == TREE_VEC_LENGTH (incrv
));
6496 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
6498 decl
= TREE_VEC_ELT (declv
, i
);
6499 init
= TREE_VEC_ELT (initv
, i
);
6500 cond
= TREE_VEC_ELT (condv
, i
);
6501 incr
= TREE_VEC_ELT (incrv
, i
);
6507 switch (TREE_CODE (init
))
6510 decl
= TREE_OPERAND (init
, 0);
6511 init
= TREE_OPERAND (init
, 1);
6514 if (TREE_CODE (TREE_OPERAND (init
, 1)) == NOP_EXPR
)
6516 decl
= TREE_OPERAND (init
, 0);
6517 init
= TREE_OPERAND (init
, 2);
6527 "expected iteration declaration or initialization");
6532 if (init
&& EXPR_HAS_LOCATION (init
))
6533 elocus
= EXPR_LOCATION (init
);
6537 error_at (elocus
, "missing controlling predicate");
6543 error_at (elocus
, "missing increment expression");
6547 TREE_VEC_ELT (declv
, i
) = decl
;
6548 TREE_VEC_ELT (initv
, i
) = init
;
6551 if (dependent_omp_for_p (declv
, initv
, condv
, incrv
))
6555 stmt
= make_node (code
);
6557 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
6559 /* This is really just a place-holder. We'll be decomposing this
6560 again and going through the cp_build_modify_expr path below when
6561 we instantiate the thing. */
6562 TREE_VEC_ELT (initv
, i
)
6563 = build2 (MODIFY_EXPR
, void_type_node
, TREE_VEC_ELT (declv
, i
),
6564 TREE_VEC_ELT (initv
, i
));
6567 TREE_TYPE (stmt
) = void_type_node
;
6568 OMP_FOR_INIT (stmt
) = initv
;
6569 OMP_FOR_COND (stmt
) = condv
;
6570 OMP_FOR_INCR (stmt
) = incrv
;
6571 OMP_FOR_BODY (stmt
) = body
;
6572 OMP_FOR_PRE_BODY (stmt
) = pre_body
;
6573 OMP_FOR_CLAUSES (stmt
) = clauses
;
6575 SET_EXPR_LOCATION (stmt
, locus
);
6576 return add_stmt (stmt
);
6579 if (processing_template_decl
)
6580 orig_incr
= make_tree_vec (TREE_VEC_LENGTH (incrv
));
6582 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); )
6584 decl
= TREE_VEC_ELT (declv
, i
);
6585 init
= TREE_VEC_ELT (initv
, i
);
6586 cond
= TREE_VEC_ELT (condv
, i
);
6587 incr
= TREE_VEC_ELT (incrv
, i
);
6589 TREE_VEC_ELT (orig_incr
, i
) = incr
;
6592 if (init
&& EXPR_HAS_LOCATION (init
))
6593 elocus
= EXPR_LOCATION (init
);
6597 error_at (elocus
, "expected iteration declaration or initialization");
6601 if (incr
&& TREE_CODE (incr
) == MODOP_EXPR
)
6604 TREE_VEC_ELT (orig_incr
, i
) = incr
;
6605 incr
= cp_build_modify_expr (TREE_OPERAND (incr
, 0),
6606 TREE_CODE (TREE_OPERAND (incr
, 1)),
6607 TREE_OPERAND (incr
, 2),
6608 tf_warning_or_error
);
6611 if (CLASS_TYPE_P (TREE_TYPE (decl
)))
6613 if (code
== OMP_SIMD
)
6615 error_at (elocus
, "%<#pragma omp simd%> used with class "
6616 "iteration variable %qE", decl
);
6619 if (code
== CILK_FOR
&& i
== 0)
6621 if (handle_omp_for_class_iterator (i
, locus
, declv
, initv
, condv
,
6622 incrv
, &body
, &pre_body
,
6628 if (!INTEGRAL_TYPE_P (TREE_TYPE (decl
))
6629 && !TYPE_PTR_P (TREE_TYPE (decl
)))
6631 error_at (elocus
, "invalid type for iteration variable %qE", decl
);
6635 if (!processing_template_decl
)
6637 init
= fold_build_cleanup_point_expr (TREE_TYPE (init
), init
);
6638 init
= cp_build_modify_expr (decl
, NOP_EXPR
, init
, tf_warning_or_error
);
6641 init
= build2 (MODIFY_EXPR
, void_type_node
, decl
, init
);
6643 && TREE_SIDE_EFFECTS (cond
)
6644 && COMPARISON_CLASS_P (cond
)
6645 && !processing_template_decl
)
6647 tree t
= TREE_OPERAND (cond
, 0);
6648 if (TREE_SIDE_EFFECTS (t
)
6650 && (TREE_CODE (t
) != NOP_EXPR
6651 || TREE_OPERAND (t
, 0) != decl
))
6652 TREE_OPERAND (cond
, 0)
6653 = fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
6655 t
= TREE_OPERAND (cond
, 1);
6656 if (TREE_SIDE_EFFECTS (t
)
6658 && (TREE_CODE (t
) != NOP_EXPR
6659 || TREE_OPERAND (t
, 0) != decl
))
6660 TREE_OPERAND (cond
, 1)
6661 = fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
6663 if (decl
== error_mark_node
|| init
== error_mark_node
)
6666 TREE_VEC_ELT (declv
, i
) = decl
;
6667 TREE_VEC_ELT (initv
, i
) = init
;
6668 TREE_VEC_ELT (condv
, i
) = cond
;
6669 TREE_VEC_ELT (incrv
, i
) = incr
;
6673 if (IS_EMPTY_STMT (pre_body
))
6676 if (code
== CILK_FOR
&& !processing_template_decl
)
6677 block
= push_stmt_list ();
6679 omp_for
= c_finish_omp_for (locus
, code
, declv
, initv
, condv
, incrv
,
6682 if (omp_for
== NULL
)
6685 pop_stmt_list (block
);
6689 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INCR (omp_for
)); i
++)
6691 decl
= TREE_OPERAND (TREE_VEC_ELT (OMP_FOR_INIT (omp_for
), i
), 0);
6692 incr
= TREE_VEC_ELT (OMP_FOR_INCR (omp_for
), i
);
6694 if (TREE_CODE (incr
) != MODIFY_EXPR
)
6697 if (TREE_SIDE_EFFECTS (TREE_OPERAND (incr
, 1))
6698 && BINARY_CLASS_P (TREE_OPERAND (incr
, 1))
6699 && !processing_template_decl
)
6701 tree t
= TREE_OPERAND (TREE_OPERAND (incr
, 1), 0);
6702 if (TREE_SIDE_EFFECTS (t
)
6704 && (TREE_CODE (t
) != NOP_EXPR
6705 || TREE_OPERAND (t
, 0) != decl
))
6706 TREE_OPERAND (TREE_OPERAND (incr
, 1), 0)
6707 = fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
6709 t
= TREE_OPERAND (TREE_OPERAND (incr
, 1), 1);
6710 if (TREE_SIDE_EFFECTS (t
)
6712 && (TREE_CODE (t
) != NOP_EXPR
6713 || TREE_OPERAND (t
, 0) != decl
))
6714 TREE_OPERAND (TREE_OPERAND (incr
, 1), 1)
6715 = fold_build_cleanup_point_expr (TREE_TYPE (t
), t
);
6719 TREE_VEC_ELT (OMP_FOR_INCR (omp_for
), i
) = TREE_VEC_ELT (orig_incr
, i
);
6721 OMP_FOR_CLAUSES (omp_for
) = clauses
;
6725 tree omp_par
= make_node (OMP_PARALLEL
);
6726 TREE_TYPE (omp_par
) = void_type_node
;
6727 OMP_PARALLEL_CLAUSES (omp_par
) = NULL_TREE
;
6728 tree bind
= build3 (BIND_EXPR
, void_type_node
, NULL
, NULL
, NULL
);
6729 TREE_SIDE_EFFECTS (bind
) = 1;
6730 BIND_EXPR_BODY (bind
) = pop_stmt_list (block
);
6731 OMP_PARALLEL_BODY (omp_par
) = bind
;
6732 if (OMP_FOR_PRE_BODY (omp_for
))
6734 add_stmt (OMP_FOR_PRE_BODY (omp_for
));
6735 OMP_FOR_PRE_BODY (omp_for
) = NULL_TREE
;
6737 init
= TREE_VEC_ELT (OMP_FOR_INIT (omp_for
), 0);
6738 decl
= TREE_OPERAND (init
, 0);
6739 cond
= TREE_VEC_ELT (OMP_FOR_COND (omp_for
), 0);
6740 incr
= TREE_VEC_ELT (OMP_FOR_INCR (omp_for
), 0);
6741 tree t
= TREE_OPERAND (cond
, 1), c
, clauses
, *pc
;
6742 clauses
= OMP_FOR_CLAUSES (omp_for
);
6743 OMP_FOR_CLAUSES (omp_for
) = NULL_TREE
;
6744 for (pc
= &clauses
; *pc
; )
6745 if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_SCHEDULE
)
6747 gcc_assert (OMP_FOR_CLAUSES (omp_for
) == NULL_TREE
);
6748 OMP_FOR_CLAUSES (omp_for
) = *pc
;
6749 *pc
= OMP_CLAUSE_CHAIN (*pc
);
6750 OMP_CLAUSE_CHAIN (OMP_FOR_CLAUSES (omp_for
)) = NULL_TREE
;
6754 gcc_assert (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_FIRSTPRIVATE
);
6755 pc
= &OMP_CLAUSE_CHAIN (*pc
);
6757 if (TREE_CODE (t
) != INTEGER_CST
)
6759 TREE_OPERAND (cond
, 1) = get_temp_regvar (TREE_TYPE (t
), t
);
6760 c
= build_omp_clause (input_location
, OMP_CLAUSE_FIRSTPRIVATE
);
6761 OMP_CLAUSE_DECL (c
) = TREE_OPERAND (cond
, 1);
6762 OMP_CLAUSE_CHAIN (c
) = clauses
;
6765 if (TREE_CODE (incr
) == MODIFY_EXPR
)
6767 t
= TREE_OPERAND (TREE_OPERAND (incr
, 1), 1);
6768 if (TREE_CODE (t
) != INTEGER_CST
)
6770 TREE_OPERAND (TREE_OPERAND (incr
, 1), 1)
6771 = get_temp_regvar (TREE_TYPE (t
), t
);
6772 c
= build_omp_clause (input_location
, OMP_CLAUSE_FIRSTPRIVATE
);
6773 OMP_CLAUSE_DECL (c
) = TREE_OPERAND (TREE_OPERAND (incr
, 1), 1);
6774 OMP_CLAUSE_CHAIN (c
) = clauses
;
6778 t
= TREE_OPERAND (init
, 1);
6779 if (TREE_CODE (t
) != INTEGER_CST
)
6781 TREE_OPERAND (init
, 1) = get_temp_regvar (TREE_TYPE (t
), t
);
6782 c
= build_omp_clause (input_location
, OMP_CLAUSE_FIRSTPRIVATE
);
6783 OMP_CLAUSE_DECL (c
) = TREE_OPERAND (init
, 1);
6784 OMP_CLAUSE_CHAIN (c
) = clauses
;
6787 if (orig_decl
&& orig_decl
!= decl
)
6789 c
= build_omp_clause (input_location
, OMP_CLAUSE_FIRSTPRIVATE
);
6790 OMP_CLAUSE_DECL (c
) = orig_decl
;
6791 OMP_CLAUSE_CHAIN (c
) = clauses
;
6796 c
= build_omp_clause (input_location
, OMP_CLAUSE_FIRSTPRIVATE
);
6797 OMP_CLAUSE_DECL (c
) = last
;
6798 OMP_CLAUSE_CHAIN (c
) = clauses
;
6801 c
= build_omp_clause (input_location
, OMP_CLAUSE_PRIVATE
);
6802 OMP_CLAUSE_DECL (c
) = decl
;
6803 OMP_CLAUSE_CHAIN (c
) = clauses
;
6805 c
= build_omp_clause (input_location
, OMP_CLAUSE__CILK_FOR_COUNT_
);
6806 OMP_CLAUSE_OPERAND (c
, 0)
6807 = cilk_for_number_of_iterations (omp_for
);
6808 OMP_CLAUSE_CHAIN (c
) = clauses
;
6809 OMP_PARALLEL_CLAUSES (omp_par
) = finish_omp_clauses (c
);
6813 else if (code
== CILK_FOR
&& processing_template_decl
)
6815 tree c
, clauses
= OMP_FOR_CLAUSES (omp_for
);
6816 if (orig_decl
&& orig_decl
!= decl
)
6818 c
= build_omp_clause (input_location
, OMP_CLAUSE_FIRSTPRIVATE
);
6819 OMP_CLAUSE_DECL (c
) = orig_decl
;
6820 OMP_CLAUSE_CHAIN (c
) = clauses
;
6825 c
= build_omp_clause (input_location
, OMP_CLAUSE_FIRSTPRIVATE
);
6826 OMP_CLAUSE_DECL (c
) = last
;
6827 OMP_CLAUSE_CHAIN (c
) = clauses
;
6830 OMP_FOR_CLAUSES (omp_for
) = clauses
;
6836 finish_omp_atomic (enum tree_code code
, enum tree_code opcode
, tree lhs
,
6837 tree rhs
, tree v
, tree lhs1
, tree rhs1
, bool seq_cst
)
6852 dependent_p
= false;
6855 /* Even in a template, we can detect invalid uses of the atomic
6856 pragma if neither LHS nor RHS is type-dependent. */
6857 if (processing_template_decl
)
6859 dependent_p
= (type_dependent_expression_p (lhs
)
6860 || (rhs
&& type_dependent_expression_p (rhs
))
6861 || (v
&& type_dependent_expression_p (v
))
6862 || (lhs1
&& type_dependent_expression_p (lhs1
))
6863 || (rhs1
&& type_dependent_expression_p (rhs1
)));
6866 lhs
= build_non_dependent_expr (lhs
);
6868 rhs
= build_non_dependent_expr (rhs
);
6870 v
= build_non_dependent_expr (v
);
6872 lhs1
= build_non_dependent_expr (lhs1
);
6874 rhs1
= build_non_dependent_expr (rhs1
);
6879 bool swapped
= false;
6880 if (rhs1
&& cp_tree_equal (lhs
, rhs
))
6885 swapped
= !commutative_tree_code (opcode
);
6887 if (rhs1
&& !cp_tree_equal (lhs
, rhs1
))
6889 if (code
== OMP_ATOMIC
)
6890 error ("%<#pragma omp atomic update%> uses two different "
6891 "expressions for memory");
6893 error ("%<#pragma omp atomic capture%> uses two different "
6894 "expressions for memory");
6897 if (lhs1
&& !cp_tree_equal (lhs
, lhs1
))
6899 if (code
== OMP_ATOMIC
)
6900 error ("%<#pragma omp atomic update%> uses two different "
6901 "expressions for memory");
6903 error ("%<#pragma omp atomic capture%> uses two different "
6904 "expressions for memory");
6907 stmt
= c_finish_omp_atomic (input_location
, code
, opcode
, lhs
, rhs
,
6908 v
, lhs1
, rhs1
, swapped
, seq_cst
);
6909 if (stmt
== error_mark_node
)
6912 if (processing_template_decl
)
6914 if (code
== OMP_ATOMIC_READ
)
6916 stmt
= build_min_nt_loc (EXPR_LOCATION (orig_lhs
),
6917 OMP_ATOMIC_READ
, orig_lhs
);
6918 OMP_ATOMIC_SEQ_CST (stmt
) = seq_cst
;
6919 stmt
= build2 (MODIFY_EXPR
, void_type_node
, orig_v
, stmt
);
6923 if (opcode
== NOP_EXPR
)
6924 stmt
= build2 (MODIFY_EXPR
, void_type_node
, orig_lhs
, orig_rhs
);
6926 stmt
= build2 (opcode
, void_type_node
, orig_lhs
, orig_rhs
);
6928 stmt
= build_min_nt_loc (EXPR_LOCATION (orig_rhs1
),
6929 COMPOUND_EXPR
, orig_rhs1
, stmt
);
6930 if (code
!= OMP_ATOMIC
)
6932 stmt
= build_min_nt_loc (EXPR_LOCATION (orig_lhs1
),
6933 code
, orig_lhs1
, stmt
);
6934 OMP_ATOMIC_SEQ_CST (stmt
) = seq_cst
;
6935 stmt
= build2 (MODIFY_EXPR
, void_type_node
, orig_v
, stmt
);
6938 stmt
= build2 (OMP_ATOMIC
, void_type_node
, integer_zero_node
, stmt
);
6939 OMP_ATOMIC_SEQ_CST (stmt
) = seq_cst
;
6941 finish_expr_stmt (stmt
);
6945 finish_omp_barrier (void)
6947 tree fn
= builtin_decl_explicit (BUILT_IN_GOMP_BARRIER
);
6948 vec
<tree
, va_gc
> *vec
= make_tree_vector ();
6949 tree stmt
= finish_call_expr (fn
, &vec
, false, false, tf_warning_or_error
);
6950 release_tree_vector (vec
);
6951 finish_expr_stmt (stmt
);
6955 finish_omp_flush (void)
6957 tree fn
= builtin_decl_explicit (BUILT_IN_SYNC_SYNCHRONIZE
);
6958 vec
<tree
, va_gc
> *vec
= make_tree_vector ();
6959 tree stmt
= finish_call_expr (fn
, &vec
, false, false, tf_warning_or_error
);
6960 release_tree_vector (vec
);
6961 finish_expr_stmt (stmt
);
6965 finish_omp_taskwait (void)
6967 tree fn
= builtin_decl_explicit (BUILT_IN_GOMP_TASKWAIT
);
6968 vec
<tree
, va_gc
> *vec
= make_tree_vector ();
6969 tree stmt
= finish_call_expr (fn
, &vec
, false, false, tf_warning_or_error
);
6970 release_tree_vector (vec
);
6971 finish_expr_stmt (stmt
);
6975 finish_omp_taskyield (void)
6977 tree fn
= builtin_decl_explicit (BUILT_IN_GOMP_TASKYIELD
);
6978 vec
<tree
, va_gc
> *vec
= make_tree_vector ();
6979 tree stmt
= finish_call_expr (fn
, &vec
, false, false, tf_warning_or_error
);
6980 release_tree_vector (vec
);
6981 finish_expr_stmt (stmt
);
6985 finish_omp_cancel (tree clauses
)
6987 tree fn
= builtin_decl_explicit (BUILT_IN_GOMP_CANCEL
);
6989 if (find_omp_clause (clauses
, OMP_CLAUSE_PARALLEL
))
6991 else if (find_omp_clause (clauses
, OMP_CLAUSE_FOR
))
6993 else if (find_omp_clause (clauses
, OMP_CLAUSE_SECTIONS
))
6995 else if (find_omp_clause (clauses
, OMP_CLAUSE_TASKGROUP
))
6999 error ("%<#pragma omp cancel must specify one of "
7000 "%<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses");
7003 vec
<tree
, va_gc
> *vec
= make_tree_vector ();
7004 tree ifc
= find_omp_clause (clauses
, OMP_CLAUSE_IF
);
7005 if (ifc
!= NULL_TREE
)
7007 tree type
= TREE_TYPE (OMP_CLAUSE_IF_EXPR (ifc
));
7008 ifc
= fold_build2_loc (OMP_CLAUSE_LOCATION (ifc
), NE_EXPR
,
7009 boolean_type_node
, OMP_CLAUSE_IF_EXPR (ifc
),
7010 build_zero_cst (type
));
7013 ifc
= boolean_true_node
;
7014 vec
->quick_push (build_int_cst (integer_type_node
, mask
));
7015 vec
->quick_push (ifc
);
7016 tree stmt
= finish_call_expr (fn
, &vec
, false, false, tf_warning_or_error
);
7017 release_tree_vector (vec
);
7018 finish_expr_stmt (stmt
);
7022 finish_omp_cancellation_point (tree clauses
)
7024 tree fn
= builtin_decl_explicit (BUILT_IN_GOMP_CANCELLATION_POINT
);
7026 if (find_omp_clause (clauses
, OMP_CLAUSE_PARALLEL
))
7028 else if (find_omp_clause (clauses
, OMP_CLAUSE_FOR
))
7030 else if (find_omp_clause (clauses
, OMP_CLAUSE_SECTIONS
))
7032 else if (find_omp_clause (clauses
, OMP_CLAUSE_TASKGROUP
))
7036 error ("%<#pragma omp cancellation point must specify one of "
7037 "%<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses");
7040 vec
<tree
, va_gc
> *vec
7041 = make_tree_vector_single (build_int_cst (integer_type_node
, mask
));
7042 tree stmt
= finish_call_expr (fn
, &vec
, false, false, tf_warning_or_error
);
7043 release_tree_vector (vec
);
7044 finish_expr_stmt (stmt
);
7047 /* Begin a __transaction_atomic or __transaction_relaxed statement.
7048 If PCOMPOUND is non-null, this is for a function-transaction-block, and we
7049 should create an extra compound stmt. */
7052 begin_transaction_stmt (location_t loc
, tree
*pcompound
, int flags
)
7057 *pcompound
= begin_compound_stmt (0);
7059 r
= build_stmt (loc
, TRANSACTION_EXPR
, NULL_TREE
);
7061 /* Only add the statement to the function if support enabled. */
7065 error_at (loc
, ((flags
& TM_STMT_ATTR_RELAXED
) != 0
7066 ? G_("%<__transaction_relaxed%> without "
7067 "transactional memory support enabled")
7068 : G_("%<__transaction_atomic%> without "
7069 "transactional memory support enabled")));
7071 TRANSACTION_EXPR_BODY (r
) = push_stmt_list ();
7072 TREE_SIDE_EFFECTS (r
) = 1;
7076 /* End a __transaction_atomic or __transaction_relaxed statement.
7077 If COMPOUND_STMT is non-null, this is for a function-transaction-block,
7078 and we should end the compound. If NOEX is non-NULL, we wrap the body in
7079 a MUST_NOT_THROW_EXPR with NOEX as condition. */
7082 finish_transaction_stmt (tree stmt
, tree compound_stmt
, int flags
, tree noex
)
7084 TRANSACTION_EXPR_BODY (stmt
) = pop_stmt_list (TRANSACTION_EXPR_BODY (stmt
));
7085 TRANSACTION_EXPR_OUTER (stmt
) = (flags
& TM_STMT_ATTR_OUTER
) != 0;
7086 TRANSACTION_EXPR_RELAXED (stmt
) = (flags
& TM_STMT_ATTR_RELAXED
) != 0;
7087 TRANSACTION_EXPR_IS_STMT (stmt
) = 1;
7089 /* noexcept specifications are not allowed for function transactions. */
7090 gcc_assert (!(noex
&& compound_stmt
));
7093 tree body
= build_must_not_throw_expr (TRANSACTION_EXPR_BODY (stmt
),
7095 /* This may not be true when the STATEMENT_LIST is empty. */
7097 SET_EXPR_LOCATION (body
, EXPR_LOCATION (TRANSACTION_EXPR_BODY (stmt
)));
7098 TREE_SIDE_EFFECTS (body
) = 1;
7099 TRANSACTION_EXPR_BODY (stmt
) = body
;
7103 finish_compound_stmt (compound_stmt
);
7106 /* Build a __transaction_atomic or __transaction_relaxed expression. If
7107 NOEX is non-NULL, we wrap the body in a MUST_NOT_THROW_EXPR with NOEX as
7111 build_transaction_expr (location_t loc
, tree expr
, int flags
, tree noex
)
7116 expr
= build_must_not_throw_expr (expr
, noex
);
7118 SET_EXPR_LOCATION (expr
, loc
);
7119 TREE_SIDE_EFFECTS (expr
) = 1;
7121 ret
= build1 (TRANSACTION_EXPR
, TREE_TYPE (expr
), expr
);
7122 if (flags
& TM_STMT_ATTR_RELAXED
)
7123 TRANSACTION_EXPR_RELAXED (ret
) = 1;
7124 TREE_SIDE_EFFECTS (ret
) = 1;
7125 SET_EXPR_LOCATION (ret
, loc
);
7130 init_cp_semantics (void)
7134 /* Build a STATIC_ASSERT for a static assertion with the condition
7135 CONDITION and the message text MESSAGE. LOCATION is the location
7136 of the static assertion in the source code. When MEMBER_P, this
7137 static assertion is a member of a class. */
7139 finish_static_assert (tree condition
, tree message
, location_t location
,
7142 if (message
== NULL_TREE
7143 || message
== error_mark_node
7144 || condition
== NULL_TREE
7145 || condition
== error_mark_node
)
7148 if (check_for_bare_parameter_packs (condition
))
7149 condition
= error_mark_node
;
7151 if (type_dependent_expression_p (condition
)
7152 || value_dependent_expression_p (condition
))
7154 /* We're in a template; build a STATIC_ASSERT and put it in
7158 assertion
= make_node (STATIC_ASSERT
);
7159 STATIC_ASSERT_CONDITION (assertion
) = condition
;
7160 STATIC_ASSERT_MESSAGE (assertion
) = message
;
7161 STATIC_ASSERT_SOURCE_LOCATION (assertion
) = location
;
7164 maybe_add_class_template_decl_list (current_class_type
,
7168 add_stmt (assertion
);
7173 /* Fold the expression and convert it to a boolean value. */
7174 condition
= instantiate_non_dependent_expr (condition
);
7175 condition
= cp_convert (boolean_type_node
, condition
, tf_warning_or_error
);
7176 condition
= maybe_constant_value (condition
);
7178 if (TREE_CODE (condition
) == INTEGER_CST
&& !integer_zerop (condition
))
7179 /* Do nothing; the condition is satisfied. */
7183 location_t saved_loc
= input_location
;
7185 input_location
= location
;
7186 if (TREE_CODE (condition
) == INTEGER_CST
7187 && integer_zerop (condition
))
7188 /* Report the error. */
7189 error ("static assertion failed: %s", TREE_STRING_POINTER (message
));
7190 else if (condition
&& condition
!= error_mark_node
)
7192 error ("non-constant condition for static assertion");
7193 if (require_potential_rvalue_constant_expression (condition
))
7194 cxx_constant_value (condition
);
7196 input_location
= saved_loc
;
7200 /* Implements the C++0x decltype keyword. Returns the type of EXPR,
7201 suitable for use as a type-specifier.
7203 ID_EXPRESSION_OR_MEMBER_ACCESS_P is true when EXPR was parsed as an
7204 id-expression or a class member access, FALSE when it was parsed as
7205 a full expression. */
7208 finish_decltype_type (tree expr
, bool id_expression_or_member_access_p
,
7209 tsubst_flags_t complain
)
7211 tree type
= NULL_TREE
;
7213 if (!expr
|| error_operand_p (expr
))
7214 return error_mark_node
;
7217 || TREE_CODE (expr
) == TYPE_DECL
7218 || (TREE_CODE (expr
) == BIT_NOT_EXPR
7219 && TYPE_P (TREE_OPERAND (expr
, 0))))
7221 if (complain
& tf_error
)
7222 error ("argument to decltype must be an expression");
7223 return error_mark_node
;
7226 /* Depending on the resolution of DR 1172, we may later need to distinguish
7227 instantiation-dependent but not type-dependent expressions so that, say,
7228 A<decltype(sizeof(T))>::U doesn't require 'typename'. */
7229 if (instantiation_dependent_expression_p (expr
))
7231 type
= cxx_make_type (DECLTYPE_TYPE
);
7232 DECLTYPE_TYPE_EXPR (type
) = expr
;
7233 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type
)
7234 = id_expression_or_member_access_p
;
7235 SET_TYPE_STRUCTURAL_EQUALITY (type
);
7240 /* The type denoted by decltype(e) is defined as follows: */
7242 expr
= resolve_nondeduced_context (expr
);
7244 if (invalid_nonstatic_memfn_p (expr
, complain
))
7245 return error_mark_node
;
7247 if (type_unknown_p (expr
))
7249 if (complain
& tf_error
)
7250 error ("decltype cannot resolve address of overloaded function");
7251 return error_mark_node
;
7254 /* To get the size of a static data member declared as an array of
7255 unknown bound, we need to instantiate it. */
7257 && VAR_HAD_UNKNOWN_BOUND (expr
)
7258 && DECL_TEMPLATE_INSTANTIATION (expr
))
7259 instantiate_decl (expr
, /*defer_ok*/true, /*expl_inst_mem*/false);
7261 if (id_expression_or_member_access_p
)
7263 /* If e is an id-expression or a class member access (5.2.5
7264 [expr.ref]), decltype(e) is defined as the type of the entity
7265 named by e. If there is no such entity, or e names a set of
7266 overloaded functions, the program is ill-formed. */
7267 if (identifier_p (expr
))
7268 expr
= lookup_name (expr
);
7270 if (INDIRECT_REF_P (expr
))
7271 /* This can happen when the expression is, e.g., "a.b". Just
7272 look at the underlying operand. */
7273 expr
= TREE_OPERAND (expr
, 0);
7275 if (TREE_CODE (expr
) == OFFSET_REF
7276 || TREE_CODE (expr
) == MEMBER_REF
7277 || TREE_CODE (expr
) == SCOPE_REF
)
7278 /* We're only interested in the field itself. If it is a
7279 BASELINK, we will need to see through it in the next
7281 expr
= TREE_OPERAND (expr
, 1);
7283 if (BASELINK_P (expr
))
7284 /* See through BASELINK nodes to the underlying function. */
7285 expr
= BASELINK_FUNCTIONS (expr
);
7287 switch (TREE_CODE (expr
))
7290 if (DECL_BIT_FIELD_TYPE (expr
))
7292 type
= DECL_BIT_FIELD_TYPE (expr
);
7295 /* Fall through for fields that aren't bitfields. */
7302 case TEMPLATE_PARM_INDEX
:
7303 expr
= mark_type_use (expr
);
7304 type
= TREE_TYPE (expr
);
7308 type
= error_mark_node
;
7313 mark_type_use (expr
);
7314 type
= is_bitfield_expr_with_lowered_type (expr
);
7316 type
= TREE_TYPE (TREE_OPERAND (expr
, 1));
7324 /* We can get here when the id-expression refers to an
7325 enumerator or non-type template parameter. */
7326 type
= TREE_TYPE (expr
);
7330 /* Handle instantiated template non-type arguments. */
7331 type
= TREE_TYPE (expr
);
7337 /* Within a lambda-expression:
7339 Every occurrence of decltype((x)) where x is a possibly
7340 parenthesized id-expression that names an entity of
7341 automatic storage duration is treated as if x were
7342 transformed into an access to a corresponding data member
7343 of the closure type that would have been declared if x
7344 were a use of the denoted entity. */
7345 if (outer_automatic_var_p (expr
)
7346 && current_function_decl
7347 && LAMBDA_FUNCTION_P (current_function_decl
))
7348 type
= capture_decltype (expr
);
7349 else if (error_operand_p (expr
))
7350 type
= error_mark_node
;
7351 else if (expr
== current_class_ptr
)
7352 /* If the expression is just "this", we want the
7353 cv-unqualified pointer for the "this" type. */
7354 type
= TYPE_MAIN_VARIANT (TREE_TYPE (expr
));
7357 /* Otherwise, where T is the type of e, if e is an lvalue,
7358 decltype(e) is defined as T&; if an xvalue, T&&; otherwise, T. */
7359 cp_lvalue_kind clk
= lvalue_kind (expr
);
7360 type
= unlowered_expr_type (expr
);
7361 gcc_assert (TREE_CODE (type
) != REFERENCE_TYPE
);
7363 /* For vector types, pick a non-opaque variant. */
7364 if (TREE_CODE (type
) == VECTOR_TYPE
)
7365 type
= strip_typedefs (type
);
7367 if (clk
!= clk_none
&& !(clk
& clk_class
))
7368 type
= cp_build_reference_type (type
, (clk
& clk_rvalueref
));
7375 /* Called from trait_expr_value to evaluate either __has_nothrow_assign or
7376 __has_nothrow_copy, depending on assign_p. */
7379 classtype_has_nothrow_assign_or_copy_p (tree type
, bool assign_p
)
7386 ix
= lookup_fnfields_1 (type
, ansi_assopname (NOP_EXPR
));
7389 fns
= (*CLASSTYPE_METHOD_VEC (type
))[ix
];
7391 else if (TYPE_HAS_COPY_CTOR (type
))
7393 /* If construction of the copy constructor was postponed, create
7395 if (CLASSTYPE_LAZY_COPY_CTOR (type
))
7396 lazily_declare_fn (sfk_copy_constructor
, type
);
7397 if (CLASSTYPE_LAZY_MOVE_CTOR (type
))
7398 lazily_declare_fn (sfk_move_constructor
, type
);
7399 fns
= CLASSTYPE_CONSTRUCTORS (type
);
7404 for (; fns
; fns
= OVL_NEXT (fns
))
7406 tree fn
= OVL_CURRENT (fns
);
7410 if (copy_fn_p (fn
) == 0)
7413 else if (copy_fn_p (fn
) <= 0)
7416 maybe_instantiate_noexcept (fn
);
7417 if (!TYPE_NOTHROW_P (TREE_TYPE (fn
)))
7424 /* Actually evaluates the trait. */
7427 trait_expr_value (cp_trait_kind kind
, tree type1
, tree type2
)
7429 enum tree_code type_code1
;
7432 type_code1
= TREE_CODE (type1
);
7436 case CPTK_HAS_NOTHROW_ASSIGN
:
7437 type1
= strip_array_types (type1
);
7438 return (!CP_TYPE_CONST_P (type1
) && type_code1
!= REFERENCE_TYPE
7439 && (trait_expr_value (CPTK_HAS_TRIVIAL_ASSIGN
, type1
, type2
)
7440 || (CLASS_TYPE_P (type1
)
7441 && classtype_has_nothrow_assign_or_copy_p (type1
,
7444 case CPTK_HAS_TRIVIAL_ASSIGN
:
7445 /* ??? The standard seems to be missing the "or array of such a class
7446 type" wording for this trait. */
7447 type1
= strip_array_types (type1
);
7448 return (!CP_TYPE_CONST_P (type1
) && type_code1
!= REFERENCE_TYPE
7449 && (trivial_type_p (type1
)
7450 || (CLASS_TYPE_P (type1
)
7451 && TYPE_HAS_TRIVIAL_COPY_ASSIGN (type1
))));
7453 case CPTK_HAS_NOTHROW_CONSTRUCTOR
:
7454 type1
= strip_array_types (type1
);
7455 return (trait_expr_value (CPTK_HAS_TRIVIAL_CONSTRUCTOR
, type1
, type2
)
7456 || (CLASS_TYPE_P (type1
)
7457 && (t
= locate_ctor (type1
))
7458 && (maybe_instantiate_noexcept (t
),
7459 TYPE_NOTHROW_P (TREE_TYPE (t
)))));
7461 case CPTK_HAS_TRIVIAL_CONSTRUCTOR
:
7462 type1
= strip_array_types (type1
);
7463 return (trivial_type_p (type1
)
7464 || (CLASS_TYPE_P (type1
) && TYPE_HAS_TRIVIAL_DFLT (type1
)));
7466 case CPTK_HAS_NOTHROW_COPY
:
7467 type1
= strip_array_types (type1
);
7468 return (trait_expr_value (CPTK_HAS_TRIVIAL_COPY
, type1
, type2
)
7469 || (CLASS_TYPE_P (type1
)
7470 && classtype_has_nothrow_assign_or_copy_p (type1
, false)));
7472 case CPTK_HAS_TRIVIAL_COPY
:
7473 /* ??? The standard seems to be missing the "or array of such a class
7474 type" wording for this trait. */
7475 type1
= strip_array_types (type1
);
7476 return (trivial_type_p (type1
) || type_code1
== REFERENCE_TYPE
7477 || (CLASS_TYPE_P (type1
) && TYPE_HAS_TRIVIAL_COPY_CTOR (type1
)));
7479 case CPTK_HAS_TRIVIAL_DESTRUCTOR
:
7480 type1
= strip_array_types (type1
);
7481 return (trivial_type_p (type1
) || type_code1
== REFERENCE_TYPE
7482 || (CLASS_TYPE_P (type1
)
7483 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type1
)));
7485 case CPTK_HAS_VIRTUAL_DESTRUCTOR
:
7486 return type_has_virtual_destructor (type1
);
7488 case CPTK_IS_ABSTRACT
:
7489 return (ABSTRACT_CLASS_TYPE_P (type1
));
7491 case CPTK_IS_BASE_OF
:
7492 return (NON_UNION_CLASS_TYPE_P (type1
) && NON_UNION_CLASS_TYPE_P (type2
)
7493 && (same_type_ignoring_top_level_qualifiers_p (type1
, type2
)
7494 || DERIVED_FROM_P (type1
, type2
)));
7497 return (NON_UNION_CLASS_TYPE_P (type1
));
7500 return (NON_UNION_CLASS_TYPE_P (type1
) && CLASSTYPE_EMPTY_P (type1
));
7503 return (type_code1
== ENUMERAL_TYPE
);
7506 return (CLASS_TYPE_P (type1
) && CLASSTYPE_FINAL (type1
));
7508 case CPTK_IS_LITERAL_TYPE
:
7509 return (literal_type_p (type1
));
7512 return (pod_type_p (type1
));
7514 case CPTK_IS_POLYMORPHIC
:
7515 return (CLASS_TYPE_P (type1
) && TYPE_POLYMORPHIC_P (type1
));
7517 case CPTK_IS_STD_LAYOUT
:
7518 return (std_layout_type_p (type1
));
7520 case CPTK_IS_TRIVIAL
:
7521 return (trivial_type_p (type1
));
7523 case CPTK_IS_TRIVIALLY_ASSIGNABLE
:
7524 return is_trivially_xible (MODIFY_EXPR
, type1
, type2
);
7526 case CPTK_IS_TRIVIALLY_CONSTRUCTIBLE
:
7527 return is_trivially_xible (INIT_EXPR
, type1
, type2
);
7529 case CPTK_IS_TRIVIALLY_COPYABLE
:
7530 return (trivially_copyable_p (type1
));
7533 return (type_code1
== UNION_TYPE
);
7541 /* If TYPE is an array of unknown bound, or (possibly cv-qualified)
7542 void, or a complete type, returns true, otherwise false. */
7545 check_trait_type (tree type
)
7547 if (type
== NULL_TREE
)
7550 if (TREE_CODE (type
) == TREE_LIST
)
7551 return (check_trait_type (TREE_VALUE (type
))
7552 && check_trait_type (TREE_CHAIN (type
)));
7554 if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
)
7555 && COMPLETE_TYPE_P (TREE_TYPE (type
)))
7558 if (VOID_TYPE_P (type
))
7561 return !!complete_type_or_else (strip_array_types (type
), NULL_TREE
);
7564 /* Process a trait expression. */
7567 finish_trait_expr (cp_trait_kind kind
, tree type1
, tree type2
)
7569 if (type1
== error_mark_node
7570 || type2
== error_mark_node
)
7571 return error_mark_node
;
7573 if (processing_template_decl
)
7575 tree trait_expr
= make_node (TRAIT_EXPR
);
7576 TREE_TYPE (trait_expr
) = boolean_type_node
;
7577 TRAIT_EXPR_TYPE1 (trait_expr
) = type1
;
7578 TRAIT_EXPR_TYPE2 (trait_expr
) = type2
;
7579 TRAIT_EXPR_KIND (trait_expr
) = kind
;
7585 case CPTK_HAS_NOTHROW_ASSIGN
:
7586 case CPTK_HAS_TRIVIAL_ASSIGN
:
7587 case CPTK_HAS_NOTHROW_CONSTRUCTOR
:
7588 case CPTK_HAS_TRIVIAL_CONSTRUCTOR
:
7589 case CPTK_HAS_NOTHROW_COPY
:
7590 case CPTK_HAS_TRIVIAL_COPY
:
7591 case CPTK_HAS_TRIVIAL_DESTRUCTOR
:
7592 case CPTK_HAS_VIRTUAL_DESTRUCTOR
:
7593 case CPTK_IS_ABSTRACT
:
7596 case CPTK_IS_LITERAL_TYPE
:
7598 case CPTK_IS_POLYMORPHIC
:
7599 case CPTK_IS_STD_LAYOUT
:
7600 case CPTK_IS_TRIVIAL
:
7601 case CPTK_IS_TRIVIALLY_COPYABLE
:
7602 if (!check_trait_type (type1
))
7603 return error_mark_node
;
7606 case CPTK_IS_TRIVIALLY_ASSIGNABLE
:
7607 case CPTK_IS_TRIVIALLY_CONSTRUCTIBLE
:
7608 if (!check_trait_type (type1
)
7609 || !check_trait_type (type2
))
7610 return error_mark_node
;
7613 case CPTK_IS_BASE_OF
:
7614 if (NON_UNION_CLASS_TYPE_P (type1
) && NON_UNION_CLASS_TYPE_P (type2
)
7615 && !same_type_ignoring_top_level_qualifiers_p (type1
, type2
)
7616 && !complete_type_or_else (type2
, NULL_TREE
))
7617 /* We already issued an error. */
7618 return error_mark_node
;
7630 return (trait_expr_value (kind
, type1
, type2
)
7631 ? boolean_true_node
: boolean_false_node
);
7634 /* Do-nothing variants of functions to handle pragma FLOAT_CONST_DECIMAL64,
7635 which is ignored for C++. */
7638 set_float_const_decimal64 (void)
7643 clear_float_const_decimal64 (void)
7648 float_const_decimal64_p (void)
7654 /* Return true if T designates the implied `this' parameter. */
7657 is_this_parameter (tree t
)
7659 if (!DECL_P (t
) || DECL_NAME (t
) != this_identifier
)
7661 gcc_assert (TREE_CODE (t
) == PARM_DECL
|| is_capture_proxy (t
));
7665 /* Insert the deduced return type for an auto function. */
7668 apply_deduced_return_type (tree fco
, tree return_type
)
7672 if (return_type
== error_mark_node
)
7675 if (LAMBDA_FUNCTION_P (fco
))
7677 tree lambda
= CLASSTYPE_LAMBDA_EXPR (current_class_type
);
7678 LAMBDA_EXPR_RETURN_TYPE (lambda
) = return_type
;
7681 if (DECL_CONV_FN_P (fco
))
7682 DECL_NAME (fco
) = mangle_conv_op_name_for_type (return_type
);
7684 TREE_TYPE (fco
) = change_return_type (return_type
, TREE_TYPE (fco
));
7686 result
= DECL_RESULT (fco
);
7687 if (result
== NULL_TREE
)
7689 if (TREE_TYPE (result
) == return_type
)
7692 /* We already have a DECL_RESULT from start_preparsed_function.
7693 Now we need to redo the work it and allocate_struct_function
7694 did to reflect the new type. */
7695 gcc_assert (current_function_decl
== fco
);
7696 result
= build_decl (input_location
, RESULT_DECL
, NULL_TREE
,
7697 TYPE_MAIN_VARIANT (return_type
));
7698 DECL_ARTIFICIAL (result
) = 1;
7699 DECL_IGNORED_P (result
) = 1;
7700 cp_apply_type_quals_to_decl (cp_type_quals (return_type
),
7703 DECL_RESULT (fco
) = result
;
7705 if (!processing_template_decl
)
7707 if (!VOID_TYPE_P (TREE_TYPE (result
)))
7708 complete_type_or_else (TREE_TYPE (result
), NULL_TREE
);
7709 bool aggr
= aggregate_value_p (result
, fco
);
7710 #ifdef PCC_STATIC_STRUCT_RETURN
7711 cfun
->returns_pcc_struct
= aggr
;
7713 cfun
->returns_struct
= aggr
;
7718 /* DECL is a local variable or parameter from the surrounding scope of a
7719 lambda-expression. Returns the decltype for a use of the capture field
7720 for DECL even if it hasn't been captured yet. */
7723 capture_decltype (tree decl
)
7725 tree lam
= CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (current_function_decl
));
7726 /* FIXME do lookup instead of list walk? */
7727 tree cap
= value_member (decl
, LAMBDA_EXPR_CAPTURE_LIST (lam
));
7731 type
= TREE_TYPE (TREE_PURPOSE (cap
));
7733 switch (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lam
))
7736 error ("%qD is not captured", decl
);
7737 return error_mark_node
;
7740 type
= TREE_TYPE (decl
);
7741 if (TREE_CODE (type
) == REFERENCE_TYPE
7742 && TREE_CODE (TREE_TYPE (type
)) != FUNCTION_TYPE
)
7743 type
= TREE_TYPE (type
);
7746 case CPLD_REFERENCE
:
7747 type
= TREE_TYPE (decl
);
7748 if (TREE_CODE (type
) != REFERENCE_TYPE
)
7749 type
= build_reference_type (TREE_TYPE (decl
));
7756 if (TREE_CODE (type
) != REFERENCE_TYPE
)
7758 if (!LAMBDA_EXPR_MUTABLE_P (lam
))
7759 type
= cp_build_qualified_type (type
, (cp_type_quals (type
)
7761 type
= build_reference_type (type
);
7766 #include "gt-cp-semantics.h"