1 /* Single entry single exit control flow regions.
2 Copyright (C) 2008, 2009, 2010, 2011
3 Free Software Foundation, Inc.
4 Contributed by Jan Sjodin <jan.sjodin@amd.com> and
5 Sebastian Pop <sebastian.pop@amd.com>.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
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"
26 #include "tree-pretty-print.h"
27 #include "tree-flow.h"
29 #include "tree-chrec.h"
30 #include "tree-data-ref.h"
31 #include "tree-scalar-evolution.h"
32 #include "tree-pass.h"
33 #include "value-prof.h"
36 /* Print to stderr the element ELT. */
39 debug_rename_elt (rename_map_elt elt
)
41 fprintf (stderr
, "(");
42 print_generic_expr (stderr
, elt
->old_name
, 0);
43 fprintf (stderr
, ", ");
44 print_generic_expr (stderr
, elt
->expr
, 0);
45 fprintf (stderr
, ")\n");
48 /* Helper function for debug_rename_map. */
51 debug_rename_map_1 (void **slot
, void *s ATTRIBUTE_UNUSED
)
53 struct rename_map_elt_s
*entry
= (struct rename_map_elt_s
*) *slot
;
54 debug_rename_elt (entry
);
58 /* Print to stderr all the elements of RENAME_MAP. */
61 debug_rename_map (htab_t rename_map
)
63 htab_traverse (rename_map
, debug_rename_map_1
, NULL
);
66 /* Computes a hash function for database element ELT. */
69 rename_map_elt_info (const void *elt
)
71 return SSA_NAME_VERSION (((const struct rename_map_elt_s
*) elt
)->old_name
);
74 /* Compares database elements E1 and E2. */
77 eq_rename_map_elts (const void *e1
, const void *e2
)
79 const struct rename_map_elt_s
*elt1
= (const struct rename_map_elt_s
*) e1
;
80 const struct rename_map_elt_s
*elt2
= (const struct rename_map_elt_s
*) e2
;
82 return (elt1
->old_name
== elt2
->old_name
);
87 /* Print to stderr the element ELT. */
90 debug_ivtype_elt (ivtype_map_elt elt
)
92 fprintf (stderr
, "(%s, ", elt
->cloog_iv
);
93 print_generic_expr (stderr
, elt
->type
, 0);
94 fprintf (stderr
, ")\n");
97 /* Helper function for debug_ivtype_map. */
100 debug_ivtype_map_1 (void **slot
, void *s ATTRIBUTE_UNUSED
)
102 struct ivtype_map_elt_s
*entry
= (struct ivtype_map_elt_s
*) *slot
;
103 debug_ivtype_elt (entry
);
107 /* Print to stderr all the elements of MAP. */
110 debug_ivtype_map (htab_t map
)
112 htab_traverse (map
, debug_ivtype_map_1
, NULL
);
115 /* Computes a hash function for database element ELT. */
118 ivtype_map_elt_info (const void *elt
)
120 return htab_hash_pointer (((const struct ivtype_map_elt_s
*) elt
)->cloog_iv
);
123 /* Compares database elements E1 and E2. */
126 eq_ivtype_map_elts (const void *e1
, const void *e2
)
128 const struct ivtype_map_elt_s
*elt1
= (const struct ivtype_map_elt_s
*) e1
;
129 const struct ivtype_map_elt_s
*elt2
= (const struct ivtype_map_elt_s
*) e2
;
131 return (elt1
->cloog_iv
== elt2
->cloog_iv
);
136 /* Record LOOP as occurring in REGION. */
139 sese_record_loop (sese region
, loop_p loop
)
141 if (sese_contains_loop (region
, loop
))
144 bitmap_set_bit (SESE_LOOPS (region
), loop
->num
);
145 VEC_safe_push (loop_p
, heap
, SESE_LOOP_NEST (region
), loop
);
148 /* Build the loop nests contained in REGION. Returns true when the
149 operation was successful. */
152 build_sese_loop_nests (sese region
)
156 struct loop
*loop0
, *loop1
;
159 if (bb_in_sese_p (bb
, region
))
161 struct loop
*loop
= bb
->loop_father
;
163 /* Only add loops if they are completely contained in the SCoP. */
164 if (loop
->header
== bb
165 && bb_in_sese_p (loop
->latch
, region
))
166 sese_record_loop (region
, loop
);
169 /* Make sure that the loops in the SESE_LOOP_NEST are ordered. It
170 can be the case that an inner loop is inserted before an outer
171 loop. To avoid this, semi-sort once. */
172 FOR_EACH_VEC_ELT (loop_p
, SESE_LOOP_NEST (region
), i
, loop0
)
174 if (VEC_length (loop_p
, SESE_LOOP_NEST (region
)) == i
+ 1)
177 loop1
= VEC_index (loop_p
, SESE_LOOP_NEST (region
), i
+ 1);
178 if (loop0
->num
> loop1
->num
)
180 VEC_replace (loop_p
, SESE_LOOP_NEST (region
), i
, loop1
);
181 VEC_replace (loop_p
, SESE_LOOP_NEST (region
), i
+ 1, loop0
);
186 /* For a USE in BB, if BB is outside REGION, mark the USE in the
190 sese_build_liveouts_use (sese region
, bitmap liveouts
, basic_block bb
,
196 if (TREE_CODE (use
) != SSA_NAME
)
199 ver
= SSA_NAME_VERSION (use
);
200 def_bb
= gimple_bb (SSA_NAME_DEF_STMT (use
));
203 || !bb_in_sese_p (def_bb
, region
)
204 || bb_in_sese_p (bb
, region
))
207 bitmap_set_bit (liveouts
, ver
);
210 /* Marks for rewrite all the SSA_NAMES defined in REGION and that are
211 used in BB that is outside of the REGION. */
214 sese_build_liveouts_bb (sese region
, bitmap liveouts
, basic_block bb
)
216 gimple_stmt_iterator bsi
;
222 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
223 for (bsi
= gsi_start_phis (e
->dest
); !gsi_end_p (bsi
); gsi_next (&bsi
))
224 sese_build_liveouts_use (region
, liveouts
, bb
,
225 PHI_ARG_DEF_FROM_EDGE (gsi_stmt (bsi
), e
));
227 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
229 gimple stmt
= gsi_stmt (bsi
);
231 if (is_gimple_debug (stmt
))
234 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_ALL_USES
)
235 sese_build_liveouts_use (region
, liveouts
, bb
, USE_FROM_PTR (use_p
));
239 /* For a USE in BB, return true if BB is outside REGION and it's not
240 in the LIVEOUTS set. */
243 sese_bad_liveouts_use (sese region
, bitmap liveouts
, basic_block bb
,
249 if (TREE_CODE (use
) != SSA_NAME
)
252 ver
= SSA_NAME_VERSION (use
);
254 /* If it's in liveouts, the variable will get a new PHI node, and
255 the debug use will be properly adjusted. */
256 if (bitmap_bit_p (liveouts
, ver
))
259 def_bb
= gimple_bb (SSA_NAME_DEF_STMT (use
));
262 || !bb_in_sese_p (def_bb
, region
)
263 || bb_in_sese_p (bb
, region
))
269 /* Reset debug stmts that reference SSA_NAMES defined in REGION that
270 are not marked as liveouts. */
273 sese_reset_debug_liveouts_bb (sese region
, bitmap liveouts
, basic_block bb
)
275 gimple_stmt_iterator bsi
;
279 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
281 gimple stmt
= gsi_stmt (bsi
);
283 if (!is_gimple_debug (stmt
))
286 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_ALL_USES
)
287 if (sese_bad_liveouts_use (region
, liveouts
, bb
,
288 USE_FROM_PTR (use_p
)))
290 gimple_debug_bind_reset_value (stmt
);
297 /* Build the LIVEOUTS of REGION: the set of variables defined inside
298 and used outside the REGION. */
301 sese_build_liveouts (sese region
, bitmap liveouts
)
306 sese_build_liveouts_bb (region
, liveouts
, bb
);
307 if (MAY_HAVE_DEBUG_STMTS
)
309 sese_reset_debug_liveouts_bb (region
, liveouts
, bb
);
312 /* Builds a new SESE region from edges ENTRY and EXIT. */
315 new_sese (edge entry
, edge exit
)
317 sese region
= XNEW (struct sese_s
);
319 SESE_ENTRY (region
) = entry
;
320 SESE_EXIT (region
) = exit
;
321 SESE_LOOPS (region
) = BITMAP_ALLOC (NULL
);
322 SESE_LOOP_NEST (region
) = VEC_alloc (loop_p
, heap
, 3);
323 SESE_ADD_PARAMS (region
) = true;
324 SESE_PARAMS (region
) = VEC_alloc (tree
, heap
, 3);
329 /* Deletes REGION. */
332 free_sese (sese region
)
334 if (SESE_LOOPS (region
))
335 SESE_LOOPS (region
) = BITMAP_ALLOC (NULL
);
337 VEC_free (tree
, heap
, SESE_PARAMS (region
));
338 VEC_free (loop_p
, heap
, SESE_LOOP_NEST (region
));
343 /* Add exit phis for USE on EXIT. */
346 sese_add_exit_phis_edge (basic_block exit
, tree use
, edge false_e
, edge true_e
)
348 gimple phi
= create_phi_node (NULL_TREE
, exit
);
349 create_new_def_for (use
, phi
, gimple_phi_result_ptr (phi
));
350 add_phi_arg (phi
, use
, false_e
, UNKNOWN_LOCATION
);
351 add_phi_arg (phi
, use
, true_e
, UNKNOWN_LOCATION
);
354 /* Insert in the block BB phi nodes for variables defined in REGION
355 and used outside the REGION. The code generation moves REGION in
356 the else clause of an "if (1)" and generates code in the then
357 clause that is at this point empty:
366 sese_insert_phis_for_liveouts (sese region
, basic_block bb
,
367 edge false_e
, edge true_e
)
371 bitmap liveouts
= BITMAP_ALLOC (NULL
);
373 update_ssa (TODO_update_ssa
);
375 sese_build_liveouts (region
, liveouts
);
376 EXECUTE_IF_SET_IN_BITMAP (liveouts
, 0, i
, bi
)
377 sese_add_exit_phis_edge (bb
, ssa_name (i
), false_e
, true_e
);
378 BITMAP_FREE (liveouts
);
380 update_ssa (TODO_update_ssa
);
383 /* Returns the first successor edge of BB with EDGE_TRUE_VALUE flag set. */
386 get_true_edge_from_guard_bb (basic_block bb
)
391 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
392 if (e
->flags
& EDGE_TRUE_VALUE
)
399 /* Returns the first successor edge of BB with EDGE_TRUE_VALUE flag cleared. */
402 get_false_edge_from_guard_bb (basic_block bb
)
407 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
408 if (!(e
->flags
& EDGE_TRUE_VALUE
))
415 /* Returns the expression associated to OLD_NAME in RENAME_MAP. */
418 get_rename (htab_t rename_map
, tree old_name
)
420 struct rename_map_elt_s tmp
;
423 gcc_assert (TREE_CODE (old_name
) == SSA_NAME
);
424 tmp
.old_name
= old_name
;
425 slot
= htab_find_slot (rename_map
, &tmp
, NO_INSERT
);
428 return ((rename_map_elt
) *slot
)->expr
;
433 /* Register in RENAME_MAP the rename tuple (OLD_NAME, EXPR). */
436 set_rename (htab_t rename_map
, tree old_name
, tree expr
)
438 struct rename_map_elt_s tmp
;
441 if (old_name
== expr
)
444 tmp
.old_name
= old_name
;
445 slot
= htab_find_slot (rename_map
, &tmp
, INSERT
);
452 *slot
= new_rename_map_elt (old_name
, expr
);
455 /* Renames the scalar uses of the statement COPY, using the
456 substitution map RENAME_MAP, inserting the gimplification code at
457 GSI_TGT, for the translation REGION, with the original copied
458 statement in LOOP, and using the induction variable renaming map
459 IV_MAP. Returns true when something has been renamed. GLOOG_ERROR
460 is set when the code generation cannot continue. */
463 rename_uses (gimple copy
, htab_t rename_map
, gimple_stmt_iterator
*gsi_tgt
,
464 sese region
, loop_p loop
, VEC (tree
, heap
) *iv_map
,
469 bool changed
= false;
471 if (is_gimple_debug (copy
))
473 if (gimple_debug_bind_p (copy
))
474 gimple_debug_bind_reset_value (copy
);
475 else if (gimple_debug_source_bind_p (copy
))
483 FOR_EACH_SSA_USE_OPERAND (use_p
, copy
, op_iter
, SSA_OP_ALL_USES
)
485 tree old_name
= USE_FROM_PTR (use_p
);
489 if (TREE_CODE (old_name
) != SSA_NAME
490 || !is_gimple_reg (old_name
)
491 || SSA_NAME_IS_DEFAULT_DEF (old_name
))
495 new_expr
= get_rename (rename_map
, old_name
);
498 tree type_old_name
= TREE_TYPE (old_name
);
499 tree type_new_expr
= TREE_TYPE (new_expr
);
501 if (type_old_name
!= type_new_expr
502 || (TREE_CODE (new_expr
) != SSA_NAME
503 && is_gimple_reg (old_name
)))
505 tree var
= create_tmp_var (type_old_name
, "var");
507 if (!useless_type_conversion_p (type_old_name
, type_new_expr
))
508 new_expr
= fold_convert (type_old_name
, new_expr
);
510 new_expr
= force_gimple_operand (new_expr
, &stmts
, true, var
);
511 gsi_insert_seq_before (gsi_tgt
, stmts
, GSI_SAME_STMT
);
514 replace_exp (use_p
, new_expr
);
518 scev
= scalar_evolution_in_region (region
, loop
, old_name
);
520 /* At this point we should know the exact scev for each
521 scalar SSA_NAME used in the scop: all the other scalar
522 SSA_NAMEs should have been translated out of SSA using
523 arrays with one element. */
524 if (chrec_contains_undetermined (scev
))
527 new_expr
= build_zero_cst (TREE_TYPE (old_name
));
530 new_expr
= chrec_apply_map (scev
, iv_map
);
532 /* The apply should produce an expression tree containing
533 the uses of the new induction variables. We should be
534 able to use new_expr instead of the old_name in the newly
535 generated loop nest. */
536 if (chrec_contains_undetermined (new_expr
)
537 || tree_contains_chrecs (new_expr
, NULL
))
540 new_expr
= build_zero_cst (TREE_TYPE (old_name
));
543 /* Replace the old_name with the new_expr. */
544 new_expr
= force_gimple_operand (unshare_expr (new_expr
), &stmts
,
547 gsi_insert_seq_before (gsi_tgt
, stmts
, GSI_SAME_STMT
);
548 replace_exp (use_p
, new_expr
);
550 if (TREE_CODE (new_expr
) == INTEGER_CST
551 && is_gimple_assign (copy
))
553 tree rhs
= gimple_assign_rhs1 (copy
);
555 if (TREE_CODE (rhs
) == ADDR_EXPR
)
556 recompute_tree_invariant_for_addr_expr (rhs
);
559 set_rename (rename_map
, old_name
, new_expr
);
565 /* Duplicates the statements of basic block BB into basic block NEW_BB
566 and compute the new induction variables according to the IV_MAP.
567 GLOOG_ERROR is set when the code generation cannot continue. */
570 graphite_copy_stmts_from_block (basic_block bb
, basic_block new_bb
,
572 VEC (tree
, heap
) *iv_map
, sese region
,
575 gimple_stmt_iterator gsi
, gsi_tgt
;
576 loop_p loop
= bb
->loop_father
;
578 gsi_tgt
= gsi_start_bb (new_bb
);
579 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
583 gimple stmt
= gsi_stmt (gsi
);
587 /* Do not copy labels or conditions. */
588 if (gimple_code (stmt
) == GIMPLE_LABEL
589 || gimple_code (stmt
) == GIMPLE_COND
)
592 /* Do not copy induction variables. */
593 if (is_gimple_assign (stmt
)
594 && (lhs
= gimple_assign_lhs (stmt
))
595 && TREE_CODE (lhs
) == SSA_NAME
596 && is_gimple_reg (lhs
)
597 && scev_analyzable_p (lhs
, region
))
600 /* Create a new copy of STMT and duplicate STMT's virtual
602 copy
= gimple_copy (stmt
);
603 gsi_insert_after (&gsi_tgt
, copy
, GSI_NEW_STMT
);
605 maybe_duplicate_eh_stmt (copy
, stmt
);
606 gimple_duplicate_stmt_histograms (cfun
, copy
, cfun
, stmt
);
608 /* Create new names for all the definitions created by COPY and
609 add replacement mappings for each new name. */
610 FOR_EACH_SSA_DEF_OPERAND (def_p
, copy
, op_iter
, SSA_OP_ALL_DEFS
)
612 tree old_name
= DEF_FROM_PTR (def_p
);
613 tree new_name
= create_new_def_for (old_name
, copy
, def_p
);
614 set_rename (rename_map
, old_name
, new_name
);
617 if (rename_uses (copy
, rename_map
, &gsi_tgt
, region
, loop
, iv_map
,
620 gcc_assert (gsi_stmt (gsi_tgt
) == copy
);
621 fold_stmt_inplace (&gsi_tgt
);
628 /* Copies BB and includes in the copied BB all the statements that can
629 be reached following the use-def chains from the memory accesses,
630 and returns the next edge following this new block. GLOOG_ERROR is
631 set when the code generation cannot continue. */
634 copy_bb_and_scalar_dependences (basic_block bb
, sese region
,
635 edge next_e
, VEC (tree
, heap
) *iv_map
,
638 basic_block new_bb
= split_edge (next_e
);
639 htab_t rename_map
= htab_create (10, rename_map_elt_info
,
640 eq_rename_map_elts
, free
);
642 next_e
= single_succ_edge (new_bb
);
643 graphite_copy_stmts_from_block (bb
, new_bb
, rename_map
, iv_map
, region
,
645 remove_phi_nodes (new_bb
);
646 htab_delete (rename_map
);
651 /* Returns the outermost loop in SCOP that contains BB. */
654 outermost_loop_in_sese (sese region
, basic_block bb
)
658 nest
= bb
->loop_father
;
659 while (loop_outer (nest
)
660 && loop_in_sese_p (loop_outer (nest
), region
))
661 nest
= loop_outer (nest
);
666 /* Sets the false region of an IF_REGION to REGION. */
669 if_region_set_false_region (ifsese if_region
, sese region
)
671 basic_block condition
= if_region_get_condition_block (if_region
);
672 edge false_edge
= get_false_edge_from_guard_bb (condition
);
673 basic_block dummy
= false_edge
->dest
;
674 edge entry_region
= SESE_ENTRY (region
);
675 edge exit_region
= SESE_EXIT (region
);
676 basic_block before_region
= entry_region
->src
;
677 basic_block last_in_region
= exit_region
->src
;
678 void **slot
= htab_find_slot_with_hash (current_loops
->exits
, exit_region
,
679 htab_hash_pointer (exit_region
),
682 entry_region
->flags
= false_edge
->flags
;
683 false_edge
->flags
= exit_region
->flags
;
685 redirect_edge_pred (entry_region
, condition
);
686 redirect_edge_pred (exit_region
, before_region
);
687 redirect_edge_pred (false_edge
, last_in_region
);
688 redirect_edge_succ (false_edge
, single_succ (dummy
));
689 delete_basic_block (dummy
);
691 exit_region
->flags
= EDGE_FALLTHRU
;
692 recompute_all_dominators ();
694 SESE_EXIT (region
) = false_edge
;
696 free (if_region
->false_region
);
697 if_region
->false_region
= region
;
701 struct loop_exit
*loop_exit
= ggc_alloc_cleared_loop_exit ();
703 memcpy (loop_exit
, *((struct loop_exit
**) slot
), sizeof (struct loop_exit
));
704 htab_clear_slot (current_loops
->exits
, slot
);
706 slot
= htab_find_slot_with_hash (current_loops
->exits
, false_edge
,
707 htab_hash_pointer (false_edge
),
709 loop_exit
->e
= false_edge
;
711 false_edge
->src
->loop_father
->exits
->next
= loop_exit
;
715 /* Creates an IFSESE with CONDITION on edge ENTRY. */
718 create_if_region_on_edge (edge entry
, tree condition
)
722 sese sese_region
= XNEW (struct sese_s
);
723 sese true_region
= XNEW (struct sese_s
);
724 sese false_region
= XNEW (struct sese_s
);
725 ifsese if_region
= XNEW (struct ifsese_s
);
726 edge exit
= create_empty_if_region_on_edge (entry
, condition
);
728 if_region
->region
= sese_region
;
729 if_region
->region
->entry
= entry
;
730 if_region
->region
->exit
= exit
;
732 FOR_EACH_EDGE (e
, ei
, entry
->dest
->succs
)
734 if (e
->flags
& EDGE_TRUE_VALUE
)
736 true_region
->entry
= e
;
737 true_region
->exit
= single_succ_edge (e
->dest
);
738 if_region
->true_region
= true_region
;
740 else if (e
->flags
& EDGE_FALSE_VALUE
)
742 false_region
->entry
= e
;
743 false_region
->exit
= single_succ_edge (e
->dest
);
744 if_region
->false_region
= false_region
;
751 /* Moves REGION in a condition expression:
759 move_sese_in_condition (sese region
)
761 basic_block pred_block
= split_edge (SESE_ENTRY (region
));
764 SESE_ENTRY (region
) = single_succ_edge (pred_block
);
765 if_region
= create_if_region_on_edge (single_pred_edge (pred_block
), integer_one_node
);
766 if_region_set_false_region (if_region
, region
);
771 /* Replaces the condition of the IF_REGION with CONDITION:
779 set_ifsese_condition (ifsese if_region
, tree condition
)
781 sese region
= if_region
->region
;
782 edge entry
= region
->entry
;
783 basic_block bb
= entry
->dest
;
784 gimple last
= last_stmt (bb
);
785 gimple_stmt_iterator gsi
= gsi_last_bb (bb
);
788 gcc_assert (gimple_code (last
) == GIMPLE_COND
);
790 gsi_remove (&gsi
, true);
791 gsi
= gsi_last_bb (bb
);
792 condition
= force_gimple_operand_gsi (&gsi
, condition
, true, NULL
,
793 false, GSI_NEW_STMT
);
794 cond_stmt
= gimple_build_cond_from_tree (condition
, NULL_TREE
, NULL_TREE
);
795 gsi
= gsi_last_bb (bb
);
796 gsi_insert_after (&gsi
, cond_stmt
, GSI_NEW_STMT
);
799 /* Returns the scalar evolution of T in REGION. Every variable that
800 is not defined in the REGION is considered a parameter. */
803 scalar_evolution_in_region (sese region
, loop_p loop
, tree t
)
806 struct loop
*def_loop
;
807 basic_block before
= block_before_sese (region
);
809 /* SCOP parameters. */
810 if (TREE_CODE (t
) == SSA_NAME
811 && !defined_in_sese_p (t
, region
))
814 if (TREE_CODE (t
) != SSA_NAME
815 || loop_in_sese_p (loop
, region
))
816 return instantiate_scev (before
, loop
,
817 analyze_scalar_evolution (loop
, t
));
819 def
= SSA_NAME_DEF_STMT (t
);
820 def_loop
= loop_containing_stmt (def
);
822 if (loop_in_sese_p (def_loop
, region
))
824 t
= analyze_scalar_evolution (def_loop
, t
);
825 def_loop
= superloop_at_depth (def_loop
, loop_depth (loop
) + 1);
826 t
= compute_overall_effect_of_inner_loop (def_loop
, t
);
830 return instantiate_scev (before
, loop
, t
);