1 /* C++-specific tree lowering bits; see also c-gimplify.c and tree-gimple.c.
3 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4 Free Software Foundation, Inc.
5 Contributed by Jason Merrill <jason@redhat.com>
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
31 #include "tree-iterator.h"
34 #include "pointer-set.h"
37 /* Local declarations. */
39 enum bc_t { bc_break = 0, bc_continue = 1 };
41 /* Stack of labels which are targets for "break" or "continue",
42 linked through TREE_CHAIN. */
43 static tree bc_label[2];
45 /* Begin a scope which can be exited by a break or continue statement. BC
48 Just creates a label and pushes it into the current context. */
51 begin_bc_block (enum bc_t bc)
53 tree label = create_artificial_label ();
54 TREE_CHAIN (label) = bc_label[bc];
59 /* Finish a scope which can be exited by a break or continue statement.
60 LABEL was returned from the most recent call to begin_bc_block. BODY is
61 an expression for the contents of the scope.
63 If we saw a break (or continue) in the scope, append a LABEL_EXPR to
64 body. Otherwise, just forget the label. */
67 finish_bc_block (enum bc_t bc, tree label, gimple_seq body)
69 gcc_assert (label == bc_label[bc]);
71 if (TREE_USED (label))
73 gimple_seq_add_stmt (&body, gimple_build_label (label));
76 bc_label[bc] = TREE_CHAIN (label);
77 TREE_CHAIN (label) = NULL_TREE;
81 /* Get the LABEL_EXPR to represent a break or continue statement
82 in the current block scope. BC indicates which. */
85 get_bc_label (enum bc_t bc)
87 tree label = bc_label[bc];
89 if (label == NULL_TREE)
92 error ("break statement not within loop or switch");
94 error ("continue statement not within loop or switch");
99 /* Mark the label used for finish_bc_block. */
100 TREE_USED (label) = 1;
104 /* Genericize a TRY_BLOCK. */
107 genericize_try_block (tree *stmt_p)
109 tree body = TRY_STMTS (*stmt_p);
110 tree cleanup = TRY_HANDLERS (*stmt_p);
112 *stmt_p = build2 (TRY_CATCH_EXPR, void_type_node, body, cleanup);
115 /* Genericize a HANDLER by converting to a CATCH_EXPR. */
118 genericize_catch_block (tree *stmt_p)
120 tree type = HANDLER_TYPE (*stmt_p);
121 tree body = HANDLER_BODY (*stmt_p);
123 /* FIXME should the caught type go in TREE_TYPE? */
124 *stmt_p = build2 (CATCH_EXPR, void_type_node, type, body);
127 /* A terser interface for building a representation of an exception
131 build_gimple_eh_filter_tree (tree body, tree allowed, tree failure)
135 /* FIXME should the allowed types go in TREE_TYPE? */
136 t = build2 (EH_FILTER_EXPR, void_type_node, allowed, NULL_TREE);
137 append_to_statement_list (failure, &EH_FILTER_FAILURE (t));
139 t = build2 (TRY_CATCH_EXPR, void_type_node, NULL_TREE, t);
140 append_to_statement_list (body, &TREE_OPERAND (t, 0));
145 /* Genericize an EH_SPEC_BLOCK by converting it to a
146 TRY_CATCH_EXPR/EH_FILTER_EXPR pair. */
149 genericize_eh_spec_block (tree *stmt_p)
151 tree body = EH_SPEC_STMTS (*stmt_p);
152 tree allowed = EH_SPEC_RAISES (*stmt_p);
153 tree failure = build_call_n (call_unexpected_node, 1, build_exc_ptr ());
155 *stmt_p = build_gimple_eh_filter_tree (body, allowed, failure);
158 /* Genericize an IF_STMT by turning it into a COND_EXPR. */
161 genericize_if_stmt (tree *stmt_p)
163 tree stmt, cond, then_, else_;
164 location_t locus = EXPR_LOCATION (*stmt_p);
167 cond = IF_COND (stmt);
168 then_ = THEN_CLAUSE (stmt);
169 else_ = ELSE_CLAUSE (stmt);
172 then_ = build_empty_stmt ();
174 else_ = build_empty_stmt ();
176 if (integer_nonzerop (cond) && !TREE_SIDE_EFFECTS (else_))
178 else if (integer_zerop (cond) && !TREE_SIDE_EFFECTS (then_))
181 stmt = build3 (COND_EXPR, void_type_node, cond, then_, else_);
182 if (CAN_HAVE_LOCATION_P (stmt) && !EXPR_HAS_LOCATION (stmt))
183 SET_EXPR_LOCATION (stmt, locus);
187 /* Build a generic representation of one of the C loop forms. COND is the
188 loop condition or NULL_TREE. BODY is the (possibly compound) statement
189 controlled by the loop. INCR is the increment expression of a for-loop,
190 or NULL_TREE. COND_IS_FIRST indicates whether the condition is
191 evaluated before the loop body as in while and for loops, or after the
192 loop body as in do-while loops. */
195 gimplify_cp_loop (tree cond, tree body, tree incr, bool cond_is_first)
197 gimple top, entry, stmt;
198 gimple_seq stmt_list, body_seq, incr_seq, exit_seq;
199 tree cont_block, break_block;
200 location_t stmt_locus;
202 stmt_locus = input_location;
209 break_block = begin_bc_block (bc_break);
210 cont_block = begin_bc_block (bc_continue);
212 /* If condition is zero don't generate a loop construct. */
213 if (cond && integer_zerop (cond))
218 stmt = gimple_build_goto (get_bc_label (bc_break));
219 gimple_set_location (stmt, stmt_locus);
220 gimple_seq_add_stmt (&stmt_list, stmt);
225 /* If we use a LOOP_EXPR here, we have to feed the whole thing
226 back through the main gimplifier to lower it. Given that we
227 have to gimplify the loop body NOW so that we can resolve
228 break/continue stmts, seems easier to just expand to gotos. */
229 top = gimple_build_label (create_artificial_label ());
231 /* If we have an exit condition, then we build an IF with gotos either
232 out of the loop, or to the top of it. If there's no exit condition,
233 then we just build a jump back to the top. */
234 if (cond && !integer_nonzerop (cond))
236 if (cond != error_mark_node)
238 gimplify_expr (&cond, &exit_seq, NULL, is_gimple_val, fb_rvalue);
239 stmt = gimple_build_cond (NE_EXPR, cond,
240 build_int_cst (TREE_TYPE (cond), 0),
241 gimple_label_label (top),
242 get_bc_label (bc_break));
243 gimple_seq_add_stmt (&exit_seq, stmt);
250 entry = gimple_build_label (create_artificial_label ());
251 stmt = gimple_build_goto (gimple_label_label (entry));
254 stmt = gimple_build_goto (get_bc_label (bc_continue));
255 gimple_set_location (stmt, stmt_locus);
256 gimple_seq_add_stmt (&stmt_list, stmt);
261 stmt = gimple_build_goto (gimple_label_label (top));
262 gimple_seq_add_stmt (&exit_seq, stmt);
266 gimplify_stmt (&body, &body_seq);
267 gimplify_stmt (&incr, &incr_seq);
269 body_seq = finish_bc_block (bc_continue, cont_block, body_seq);
271 gimple_seq_add_stmt (&stmt_list, top);
272 gimple_seq_add_seq (&stmt_list, body_seq);
273 gimple_seq_add_seq (&stmt_list, incr_seq);
274 gimple_seq_add_stmt (&stmt_list, entry);
275 gimple_seq_add_seq (&stmt_list, exit_seq);
277 annotate_all_with_location (stmt_list, stmt_locus);
279 return finish_bc_block (bc_break, break_block, stmt_list);
282 /* Gimplify a FOR_STMT node. Move the stuff in the for-init-stmt into the
283 prequeue and hand off to gimplify_cp_loop. */
286 gimplify_for_stmt (tree *stmt_p, gimple_seq *pre_p)
290 if (FOR_INIT_STMT (stmt))
291 gimplify_and_add (FOR_INIT_STMT (stmt), pre_p);
293 gimple_seq_add_seq (pre_p,
294 gimplify_cp_loop (FOR_COND (stmt), FOR_BODY (stmt),
295 FOR_EXPR (stmt), 1));
299 /* Gimplify a WHILE_STMT node. */
302 gimplify_while_stmt (tree *stmt_p, gimple_seq *pre_p)
305 gimple_seq_add_seq (pre_p,
306 gimplify_cp_loop (WHILE_COND (stmt), WHILE_BODY (stmt),
311 /* Gimplify a DO_STMT node. */
314 gimplify_do_stmt (tree *stmt_p, gimple_seq *pre_p)
317 gimple_seq_add_seq (pre_p,
318 gimplify_cp_loop (DO_COND (stmt), DO_BODY (stmt),
323 /* Genericize a SWITCH_STMT by turning it into a SWITCH_EXPR. */
326 gimplify_switch_stmt (tree *stmt_p, gimple_seq *pre_p)
329 tree break_block, body, t;
330 location_t stmt_locus = input_location;
331 gimple_seq seq = NULL;
333 break_block = begin_bc_block (bc_break);
335 body = SWITCH_STMT_BODY (stmt);
337 body = build_empty_stmt ();
339 t = build3 (SWITCH_EXPR, SWITCH_STMT_TYPE (stmt),
340 SWITCH_STMT_COND (stmt), body, NULL_TREE);
341 SET_EXPR_LOCATION (t, stmt_locus);
342 gimplify_and_add (t, &seq);
344 seq = finish_bc_block (bc_break, break_block, seq);
345 gimple_seq_add_seq (pre_p, seq);
349 /* Hook into the middle of gimplifying an OMP_FOR node. This is required
350 in order to properly gimplify CONTINUE statements. Here we merely
351 manage the continue stack; the rest of the job is performed by the
352 regular gimplifier. */
354 static enum gimplify_status
355 cp_gimplify_omp_for (tree *expr_p, gimple_seq *pre_p)
357 tree for_stmt = *expr_p;
360 gimple_seq seq = NULL;
362 /* Protect ourselves from recursion. */
363 if (OMP_FOR_GIMPLIFYING_P (for_stmt))
365 OMP_FOR_GIMPLIFYING_P (for_stmt) = 1;
367 /* Note that while technically the continue label is enabled too soon
368 here, we should have already diagnosed invalid continues nested within
369 statement expressions within the INIT, COND, or INCR expressions. */
370 cont_block = begin_bc_block (bc_continue);
372 gimplify_and_add (for_stmt, &seq);
373 stmt = gimple_seq_last_stmt (seq);
374 if (gimple_code (stmt) == GIMPLE_OMP_FOR)
375 gimple_omp_set_body (stmt, finish_bc_block (bc_continue, cont_block,
376 gimple_omp_body (stmt)));
378 seq = finish_bc_block (bc_continue, cont_block, seq);
379 gimple_seq_add_seq (pre_p, seq);
381 OMP_FOR_GIMPLIFYING_P (for_stmt) = 0;
386 /* Gimplify an EXPR_STMT node. */
389 gimplify_expr_stmt (tree *stmt_p)
391 tree stmt = EXPR_STMT_EXPR (*stmt_p);
393 if (stmt == error_mark_node)
396 /* Gimplification of a statement expression will nullify the
397 statement if all its side effects are moved to *PRE_P and *POST_P.
399 In this case we will not want to emit the gimplified statement.
400 However, we may still want to emit a warning, so we do that before
402 if (stmt && warn_unused_value)
404 if (!TREE_SIDE_EFFECTS (stmt))
406 if (!IS_EMPTY_STMT (stmt)
407 && !VOID_TYPE_P (TREE_TYPE (stmt))
408 && !TREE_NO_WARNING (stmt))
409 warning (OPT_Wunused_value, "statement with no effect");
412 warn_if_unused_value (stmt, input_location);
415 if (stmt == NULL_TREE)
416 stmt = alloc_stmt_list ();
421 /* Gimplify initialization from an AGGR_INIT_EXPR. */
424 cp_gimplify_init_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
426 tree from = TREE_OPERAND (*expr_p, 1);
427 tree to = TREE_OPERAND (*expr_p, 0);
429 tree slot = NULL_TREE;
431 /* What about code that pulls out the temp and uses it elsewhere? I
432 think that such code never uses the TARGET_EXPR as an initializer. If
433 I'm wrong, we'll abort because the temp won't have any RTL. In that
434 case, I guess we'll need to replace references somehow. */
435 if (TREE_CODE (from) == TARGET_EXPR)
437 slot = TARGET_EXPR_SLOT (from);
438 from = TARGET_EXPR_INITIAL (from);
441 /* Look through any COMPOUND_EXPRs, since build_compound_expr pushes them
442 inside the TARGET_EXPR. */
445 tree sub = TREE_CODE (t) == COMPOUND_EXPR ? TREE_OPERAND (t, 0) : t;
447 /* If we are initializing from an AGGR_INIT_EXPR, drop the INIT_EXPR and
448 replace the slot operand with our target.
450 Should we add a target parm to gimplify_expr instead? No, as in this
451 case we want to replace the INIT_EXPR. */
452 if (TREE_CODE (sub) == AGGR_INIT_EXPR)
454 gimplify_expr (&to, pre_p, post_p, is_gimple_lvalue, fb_lvalue);
455 AGGR_INIT_EXPR_SLOT (sub) = to;
458 /* The initialization is now a side-effect, so the container can
461 TREE_TYPE (from) = void_type_node;
463 else if (TREE_CODE (sub) == INIT_EXPR
464 && TREE_OPERAND (sub, 0) == slot)
466 /* An INIT_EXPR under TARGET_EXPR created by build_value_init,
467 will be followed by an AGGR_INIT_EXPR. */
468 gimplify_expr (&to, pre_p, post_p, is_gimple_lvalue, fb_lvalue);
469 TREE_OPERAND (sub, 0) = to;
475 t = TREE_OPERAND (t, 1);
480 /* Gimplify a MUST_NOT_THROW_EXPR. */
482 static enum gimplify_status
483 gimplify_must_not_throw_expr (tree *expr_p, gimple_seq *pre_p)
486 tree temp = voidify_wrapper_expr (stmt, NULL);
487 tree body = TREE_OPERAND (stmt, 0);
489 stmt = build_gimple_eh_filter_tree (body, NULL_TREE,
490 build_call_n (terminate_node, 0));
492 gimplify_and_add (stmt, pre_p);
503 /* Do C++-specific gimplification. Args are as for gimplify_expr. */
506 cp_gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
508 int saved_stmts_are_full_exprs_p = 0;
509 enum tree_code code = TREE_CODE (*expr_p);
510 enum gimplify_status ret;
512 VEC(gimple, heap) *bind_expr_stack = NULL;
514 if (STATEMENT_CODE_P (code))
516 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
517 current_stmt_tree ()->stmts_are_full_exprs_p
518 = STMT_IS_FULL_EXPR_P (*expr_p);
524 *expr_p = cplus_expand_constant (*expr_p);
529 simplify_aggr_init_expr (expr_p);
534 /* FIXME communicate throw type to back end, probably by moving
535 THROW_EXPR into ../tree.def. */
536 *expr_p = TREE_OPERAND (*expr_p, 0);
540 case MUST_NOT_THROW_EXPR:
541 ret = gimplify_must_not_throw_expr (expr_p, pre_p);
544 /* We used to do this for MODIFY_EXPR as well, but that's unsafe; the
545 LHS of an assignment might also be involved in the RHS, as in bug
548 cp_gimplify_init_expr (expr_p, pre_p, post_p);
552 case EMPTY_CLASS_EXPR:
553 /* We create an empty CONSTRUCTOR with RECORD_TYPE. */
554 *expr_p = build_constructor (TREE_TYPE (*expr_p), NULL);
559 *expr_p = BASELINK_FUNCTIONS (*expr_p);
564 genericize_try_block (expr_p);
569 genericize_catch_block (expr_p);
574 genericize_eh_spec_block (expr_p);
579 /* Get the innermost inclosing GIMPLE_BIND that has a non NULL
580 BLOCK, and append an IMPORTED_DECL to its
581 BLOCK_VARS chained list. */
583 bind_expr_stack = gimple_bind_expr_stack ();
587 for (i = VEC_length (gimple, bind_expr_stack) - 1; i >= 0; i--)
588 if ((block = gimple_bind_block (VEC_index (gimple,
595 tree using_directive;
596 gcc_assert (TREE_OPERAND (*expr_p,0)
597 && NAMESPACE_DECL_CHECK (TREE_OPERAND (*expr_p, 0)));
599 using_directive = make_node (IMPORTED_DECL);
600 TREE_TYPE (using_directive) = void_type_node;
602 IMPORTED_DECL_ASSOCIATED_DECL (using_directive)
603 = TREE_OPERAND (*expr_p, 0);
604 DECL_NAME (using_directive)
605 = DECL_NAME (TREE_OPERAND (*expr_p, 0));
606 TREE_CHAIN (using_directive) = BLOCK_VARS (block);
607 BLOCK_VARS (block) = using_directive;
609 /* The USING_STMT won't appear in GIMPLE. */
615 gimplify_for_stmt (expr_p, pre_p);
620 gimplify_while_stmt (expr_p, pre_p);
625 gimplify_do_stmt (expr_p, pre_p);
630 gimplify_switch_stmt (expr_p, pre_p);
635 ret = cp_gimplify_omp_for (expr_p, pre_p);
639 gimple_seq_add_stmt (pre_p, gimple_build_predict (PRED_CONTINUE, NOT_TAKEN));
640 gimple_seq_add_stmt (pre_p, gimple_build_goto (get_bc_label (bc_continue)));
646 gimple_seq_add_stmt (pre_p, gimple_build_goto (get_bc_label (bc_break)));
652 gimplify_expr_stmt (expr_p);
656 case UNARY_PLUS_EXPR:
658 tree arg = TREE_OPERAND (*expr_p, 0);
659 tree type = TREE_TYPE (*expr_p);
660 *expr_p = (TREE_TYPE (arg) != type) ? fold_convert (type, arg)
667 ret = c_gimplify_expr (expr_p, pre_p, post_p);
671 /* Restore saved state. */
672 if (STATEMENT_CODE_P (code))
673 current_stmt_tree ()->stmts_are_full_exprs_p
674 = saved_stmts_are_full_exprs_p;
680 is_invisiref_parm (const_tree t)
682 return ((TREE_CODE (t) == PARM_DECL || TREE_CODE (t) == RESULT_DECL)
683 && DECL_BY_REFERENCE (t));
686 /* Return true if the uid in both int tree maps are equal. */
689 cxx_int_tree_map_eq (const void *va, const void *vb)
691 const struct cxx_int_tree_map *a = (const struct cxx_int_tree_map *) va;
692 const struct cxx_int_tree_map *b = (const struct cxx_int_tree_map *) vb;
693 return (a->uid == b->uid);
696 /* Hash a UID in a cxx_int_tree_map. */
699 cxx_int_tree_map_hash (const void *item)
701 return ((const struct cxx_int_tree_map *)item)->uid;
704 /* Perform any pre-gimplification lowering of C++ front end trees to
708 cp_genericize_r (tree *stmt_p, int *walk_subtrees, void *data)
711 struct pointer_set_t *p_set = (struct pointer_set_t*) data;
713 if (is_invisiref_parm (stmt)
714 /* Don't dereference parms in a thunk, pass the references through. */
715 && !(DECL_THUNK_P (current_function_decl)
716 && TREE_CODE (stmt) == PARM_DECL))
718 *stmt_p = convert_from_reference (stmt);
723 /* Map block scope extern declarations to visible declarations with the
724 same name and type in outer scopes if any. */
725 if (cp_function_chain->extern_decl_map
726 && (TREE_CODE (stmt) == FUNCTION_DECL || TREE_CODE (stmt) == VAR_DECL)
727 && DECL_EXTERNAL (stmt))
729 struct cxx_int_tree_map *h, in;
730 in.uid = DECL_UID (stmt);
731 h = (struct cxx_int_tree_map *)
732 htab_find_with_hash (cp_function_chain->extern_decl_map,
742 /* Other than invisiref parms, don't walk the same tree twice. */
743 if (pointer_set_contains (p_set, stmt))
749 if (TREE_CODE (stmt) == ADDR_EXPR
750 && is_invisiref_parm (TREE_OPERAND (stmt, 0)))
752 *stmt_p = convert (TREE_TYPE (stmt), TREE_OPERAND (stmt, 0));
755 else if (TREE_CODE (stmt) == RETURN_EXPR
756 && TREE_OPERAND (stmt, 0)
757 && is_invisiref_parm (TREE_OPERAND (stmt, 0)))
758 /* Don't dereference an invisiref RESULT_DECL inside a RETURN_EXPR. */
760 else if (TREE_CODE (stmt) == OMP_CLAUSE)
761 switch (OMP_CLAUSE_CODE (stmt))
763 case OMP_CLAUSE_LASTPRIVATE:
764 /* Don't dereference an invisiref in OpenMP clauses. */
765 if (is_invisiref_parm (OMP_CLAUSE_DECL (stmt)))
768 if (OMP_CLAUSE_LASTPRIVATE_STMT (stmt))
769 cp_walk_tree (&OMP_CLAUSE_LASTPRIVATE_STMT (stmt),
770 cp_genericize_r, p_set, NULL);
773 case OMP_CLAUSE_PRIVATE:
774 case OMP_CLAUSE_SHARED:
775 case OMP_CLAUSE_FIRSTPRIVATE:
776 case OMP_CLAUSE_COPYIN:
777 case OMP_CLAUSE_COPYPRIVATE:
778 /* Don't dereference an invisiref in OpenMP clauses. */
779 if (is_invisiref_parm (OMP_CLAUSE_DECL (stmt)))
782 case OMP_CLAUSE_REDUCTION:
783 gcc_assert (!is_invisiref_parm (OMP_CLAUSE_DECL (stmt)));
788 else if (IS_TYPE_OR_DECL_P (stmt))
791 /* Due to the way voidify_wrapper_expr is written, we don't get a chance
792 to lower this construct before scanning it, so we need to lower these
793 before doing anything else. */
794 else if (TREE_CODE (stmt) == CLEANUP_STMT)
795 *stmt_p = build2 (CLEANUP_EH_ONLY (stmt) ? TRY_CATCH_EXPR
799 CLEANUP_EXPR (stmt));
801 else if (TREE_CODE (stmt) == IF_STMT)
803 genericize_if_stmt (stmt_p);
804 /* *stmt_p has changed, tail recurse to handle it again. */
805 return cp_genericize_r (stmt_p, walk_subtrees, data);
808 /* COND_EXPR might have incompatible types in branches if one or both
809 arms are bitfields. Fix it up now. */
810 else if (TREE_CODE (stmt) == COND_EXPR)
813 = (TREE_OPERAND (stmt, 1)
814 ? is_bitfield_expr_with_lowered_type (TREE_OPERAND (stmt, 1))
817 = (TREE_OPERAND (stmt, 2)
818 ? is_bitfield_expr_with_lowered_type (TREE_OPERAND (stmt, 2))
821 && !useless_type_conversion_p (TREE_TYPE (stmt),
822 TREE_TYPE (TREE_OPERAND (stmt, 1))))
824 TREE_OPERAND (stmt, 1)
825 = fold_convert (type_left, TREE_OPERAND (stmt, 1));
826 gcc_assert (useless_type_conversion_p (TREE_TYPE (stmt),
830 && !useless_type_conversion_p (TREE_TYPE (stmt),
831 TREE_TYPE (TREE_OPERAND (stmt, 2))))
833 TREE_OPERAND (stmt, 2)
834 = fold_convert (type_right, TREE_OPERAND (stmt, 2));
835 gcc_assert (useless_type_conversion_p (TREE_TYPE (stmt),
840 pointer_set_insert (p_set, *stmt_p);
846 cp_genericize (tree fndecl)
849 struct pointer_set_t *p_set;
851 /* Fix up the types of parms passed by invisible reference. */
852 for (t = DECL_ARGUMENTS (fndecl); t; t = TREE_CHAIN (t))
853 if (TREE_ADDRESSABLE (TREE_TYPE (t)))
855 /* If a function's arguments are copied to create a thunk,
856 then DECL_BY_REFERENCE will be set -- but the type of the
857 argument will be a pointer type, so we will never get
859 gcc_assert (!DECL_BY_REFERENCE (t));
860 gcc_assert (DECL_ARG_TYPE (t) != TREE_TYPE (t));
861 TREE_TYPE (t) = DECL_ARG_TYPE (t);
862 DECL_BY_REFERENCE (t) = 1;
863 TREE_ADDRESSABLE (t) = 0;
867 /* Do the same for the return value. */
868 if (TREE_ADDRESSABLE (TREE_TYPE (DECL_RESULT (fndecl))))
870 t = DECL_RESULT (fndecl);
871 TREE_TYPE (t) = build_reference_type (TREE_TYPE (t));
872 DECL_BY_REFERENCE (t) = 1;
873 TREE_ADDRESSABLE (t) = 0;
877 /* If we're a clone, the body is already GIMPLE. */
878 if (DECL_CLONED_FUNCTION_P (fndecl))
881 /* We do want to see every occurrence of the parms, so we can't just use
882 walk_tree's hash functionality. */
883 p_set = pointer_set_create ();
884 cp_walk_tree (&DECL_SAVED_TREE (fndecl), cp_genericize_r, p_set, NULL);
885 pointer_set_destroy (p_set);
887 /* Do everything else. */
888 c_genericize (fndecl);
890 gcc_assert (bc_label[bc_break] == NULL);
891 gcc_assert (bc_label[bc_continue] == NULL);
894 /* Build code to apply FN to each member of ARG1 and ARG2. FN may be
895 NULL if there is in fact nothing to do. ARG2 may be null if FN
896 actually only takes one argument. */
899 cxx_omp_clause_apply_fn (tree fn, tree arg1, tree arg2)
901 tree defparm, parm, t;
909 nargs = list_length (DECL_ARGUMENTS (fn));
910 argarray = (tree *) alloca (nargs * sizeof (tree));
912 defparm = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (fn)));
914 defparm = TREE_CHAIN (defparm);
916 if (TREE_CODE (TREE_TYPE (arg1)) == ARRAY_TYPE)
918 tree inner_type = TREE_TYPE (arg1);
919 tree start1, end1, p1;
920 tree start2 = NULL, p2 = NULL;
921 tree ret = NULL, lab;
927 inner_type = TREE_TYPE (inner_type);
928 start1 = build4 (ARRAY_REF, inner_type, start1,
929 size_zero_node, NULL, NULL);
931 start2 = build4 (ARRAY_REF, inner_type, start2,
932 size_zero_node, NULL, NULL);
934 while (TREE_CODE (inner_type) == ARRAY_TYPE);
935 start1 = build_fold_addr_expr (start1);
937 start2 = build_fold_addr_expr (start2);
939 end1 = TYPE_SIZE_UNIT (TREE_TYPE (arg1));
940 end1 = build2 (POINTER_PLUS_EXPR, TREE_TYPE (start1), start1, end1);
942 p1 = create_tmp_var (TREE_TYPE (start1), NULL);
943 t = build2 (MODIFY_EXPR, TREE_TYPE (p1), p1, start1);
944 append_to_statement_list (t, &ret);
948 p2 = create_tmp_var (TREE_TYPE (start2), NULL);
949 t = build2 (MODIFY_EXPR, TREE_TYPE (p2), p2, start2);
950 append_to_statement_list (t, &ret);
953 lab = create_artificial_label ();
954 t = build1 (LABEL_EXPR, void_type_node, lab);
955 append_to_statement_list (t, &ret);
960 /* Handle default arguments. */
961 for (parm = defparm; parm && parm != void_list_node;
962 parm = TREE_CHAIN (parm), i++)
963 argarray[i] = convert_default_arg (TREE_VALUE (parm),
964 TREE_PURPOSE (parm), fn, i);
965 t = build_call_a (fn, i, argarray);
966 t = fold_convert (void_type_node, t);
967 t = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
968 append_to_statement_list (t, &ret);
970 t = TYPE_SIZE_UNIT (inner_type);
971 t = build2 (POINTER_PLUS_EXPR, TREE_TYPE (p1), p1, t);
972 t = build2 (MODIFY_EXPR, TREE_TYPE (p1), p1, t);
973 append_to_statement_list (t, &ret);
977 t = TYPE_SIZE_UNIT (inner_type);
978 t = build2 (POINTER_PLUS_EXPR, TREE_TYPE (p2), p2, t);
979 t = build2 (MODIFY_EXPR, TREE_TYPE (p2), p2, t);
980 append_to_statement_list (t, &ret);
983 t = build2 (NE_EXPR, boolean_type_node, p1, end1);
984 t = build3 (COND_EXPR, void_type_node, t, build_and_jump (&lab), NULL);
985 append_to_statement_list (t, &ret);
991 argarray[i++] = build_fold_addr_expr (arg1);
993 argarray[i++] = build_fold_addr_expr (arg2);
994 /* Handle default arguments. */
995 for (parm = defparm; parm && parm != void_list_node;
996 parm = TREE_CHAIN (parm), i++)
997 argarray[i] = convert_default_arg (TREE_VALUE (parm),
1000 t = build_call_a (fn, i, argarray);
1001 t = fold_convert (void_type_node, t);
1002 return fold_build_cleanup_point_expr (TREE_TYPE (t), t);
1006 /* Return code to initialize DECL with its default constructor, or
1007 NULL if there's nothing to do. */
1010 cxx_omp_clause_default_ctor (tree clause, tree decl,
1011 tree outer ATTRIBUTE_UNUSED)
1013 tree info = CP_OMP_CLAUSE_INFO (clause);
1017 ret = cxx_omp_clause_apply_fn (TREE_VEC_ELT (info, 0), decl, NULL);
1022 /* Return code to initialize DST with a copy constructor from SRC. */
1025 cxx_omp_clause_copy_ctor (tree clause, tree dst, tree src)
1027 tree info = CP_OMP_CLAUSE_INFO (clause);
1031 ret = cxx_omp_clause_apply_fn (TREE_VEC_ELT (info, 0), dst, src);
1033 ret = build2 (MODIFY_EXPR, TREE_TYPE (dst), dst, src);
1038 /* Similarly, except use an assignment operator instead. */
1041 cxx_omp_clause_assign_op (tree clause, tree dst, tree src)
1043 tree info = CP_OMP_CLAUSE_INFO (clause);
1047 ret = cxx_omp_clause_apply_fn (TREE_VEC_ELT (info, 2), dst, src);
1049 ret = build2 (MODIFY_EXPR, TREE_TYPE (dst), dst, src);
1054 /* Return code to destroy DECL. */
1057 cxx_omp_clause_dtor (tree clause, tree decl)
1059 tree info = CP_OMP_CLAUSE_INFO (clause);
1063 ret = cxx_omp_clause_apply_fn (TREE_VEC_ELT (info, 1), decl, NULL);
1068 /* True if OpenMP should privatize what this DECL points to rather
1069 than the DECL itself. */
1072 cxx_omp_privatize_by_reference (const_tree decl)
1074 return is_invisiref_parm (decl);
1077 /* True if OpenMP sharing attribute of DECL is predetermined. */
1079 enum omp_clause_default_kind
1080 cxx_omp_predetermined_sharing (tree decl)
1084 /* Static data members are predetermined as shared. */
1085 if (TREE_STATIC (decl))
1087 tree ctx = CP_DECL_CONTEXT (decl);
1088 if (TYPE_P (ctx) && MAYBE_CLASS_TYPE_P (ctx))
1089 return OMP_CLAUSE_DEFAULT_SHARED;
1092 type = TREE_TYPE (decl);
1093 if (TREE_CODE (type) == REFERENCE_TYPE)
1095 if (!is_invisiref_parm (decl))
1096 return OMP_CLAUSE_DEFAULT_UNSPECIFIED;
1097 type = TREE_TYPE (type);
1099 if (TREE_CODE (decl) == RESULT_DECL && DECL_NAME (decl))
1101 /* NVR doesn't preserve const qualification of the
1103 tree outer = outer_curly_brace_block (current_function_decl);
1107 for (var = BLOCK_VARS (outer); var; var = TREE_CHAIN (var))
1108 if (DECL_NAME (decl) == DECL_NAME (var)
1109 && (TYPE_MAIN_VARIANT (type)
1110 == TYPE_MAIN_VARIANT (TREE_TYPE (var))))
1112 if (TYPE_READONLY (TREE_TYPE (var)))
1113 type = TREE_TYPE (var);
1119 if (type == error_mark_node)
1120 return OMP_CLAUSE_DEFAULT_UNSPECIFIED;
1122 /* Variables with const-qualified type having no mutable member
1123 are predetermined shared. */
1124 if (TYPE_READONLY (type) && !cp_has_mutable_p (type))
1125 return OMP_CLAUSE_DEFAULT_SHARED;
1127 return OMP_CLAUSE_DEFAULT_UNSPECIFIED;
1130 /* Finalize an implicitly determined clause. */
1133 cxx_omp_finish_clause (tree c)
1135 tree decl, inner_type;
1136 bool make_shared = false;
1138 if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_FIRSTPRIVATE)
1141 decl = OMP_CLAUSE_DECL (c);
1142 decl = require_complete_type (decl);
1143 inner_type = TREE_TYPE (decl);
1144 if (decl == error_mark_node)
1146 else if (TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE)
1148 if (is_invisiref_parm (decl))
1149 inner_type = TREE_TYPE (inner_type);
1152 error ("%qE implicitly determined as %<firstprivate%> has reference type",
1158 /* We're interested in the base element, not arrays. */
1159 while (TREE_CODE (inner_type) == ARRAY_TYPE)
1160 inner_type = TREE_TYPE (inner_type);
1162 /* Check for special function availability by building a call to one.
1163 Save the results, because later we won't be in the right context
1164 for making these queries. */
1166 && CLASS_TYPE_P (inner_type)
1167 && cxx_omp_create_clause_info (c, inner_type, false, true, false))
1171 OMP_CLAUSE_CODE (c) = OMP_CLAUSE_SHARED;