1 /* RTL-based forward propagation pass for GNU compiler.
2 Copyright (C) 2005, 2006, 2007 Free Software Foundation, Inc.
3 Contributed by Paolo Bonzini and Steven Bosscher.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
31 #include "insn-config.h"
35 #include "basic-block.h"
40 #include "tree-pass.h"
43 /* This pass does simple forward propagation and simplification when an
44 operand of an insn can only come from a single def. This pass uses
45 df.c, so it is global. However, we only do limited analysis of
46 available expressions.
48 1) The pass tries to propagate the source of the def into the use,
49 and checks if the result is independent of the substituted value.
50 For example, the high word of a (zero_extend:DI (reg:SI M)) is always
51 zero, independent of the source register.
53 In particular, we propagate constants into the use site. Sometimes
54 RTL expansion did not put the constant in the same insn on purpose,
55 to satisfy a predicate, and the result will fail to be recognized;
56 but this happens rarely and in this case we can still create a
57 REG_EQUAL note. For multi-word operations, this
59 (set (subreg:SI (reg:DI 120) 0) (const_int 0))
60 (set (subreg:SI (reg:DI 120) 4) (const_int -1))
61 (set (subreg:SI (reg:DI 122) 0)
62 (ior:SI (subreg:SI (reg:DI 119) 0) (subreg:SI (reg:DI 120) 0)))
63 (set (subreg:SI (reg:DI 122) 4)
64 (ior:SI (subreg:SI (reg:DI 119) 4) (subreg:SI (reg:DI 120) 4)))
66 can be simplified to the much simpler
68 (set (subreg:SI (reg:DI 122) 0) (subreg:SI (reg:DI 119)))
69 (set (subreg:SI (reg:DI 122) 4) (const_int -1))
71 This particular propagation is also effective at putting together
72 complex addressing modes. We are more aggressive inside MEMs, in
73 that all definitions are propagated if the use is in a MEM; if the
74 result is a valid memory address we check address_cost to decide
75 whether the substitution is worthwhile.
77 2) The pass propagates register copies. This is not as effective as
78 the copy propagation done by CSE's canon_reg, which works by walking
79 the instruction chain, it can help the other transformations.
81 We should consider removing this optimization, and instead reorder the
82 RTL passes, because GCSE does this transformation too. With some luck,
83 the CSE pass at the end of rest_of_handle_gcse could also go away.
85 3) The pass looks for paradoxical subregs that are actually unnecessary.
88 (set (reg:QI 120) (subreg:QI (reg:SI 118) 0))
89 (set (reg:QI 121) (subreg:QI (reg:SI 119) 0))
90 (set (reg:SI 122) (plus:SI (subreg:SI (reg:QI 120) 0)
91 (subreg:SI (reg:QI 121) 0)))
93 are very common on machines that can only do word-sized operations.
94 For each use of a paradoxical subreg (subreg:WIDER (reg:NARROW N) 0),
95 if it has a single def and it is (subreg:NARROW (reg:WIDE M) 0),
96 we can replace the paradoxical subreg with simply (reg:WIDE M). The
97 above will simplify this to
99 (set (reg:QI 120) (subreg:QI (reg:SI 118) 0))
100 (set (reg:QI 121) (subreg:QI (reg:SI 119) 0))
101 (set (reg:SI 122) (plus:SI (reg:SI 118) (reg:SI 119)))
103 where the first two insns are now dead. */
106 static int num_changes
;
109 /* Do not try to replace constant addresses or addresses of local and
110 argument slots. These MEM expressions are made only once and inserted
111 in many instructions, as well as being used to control symbol table
112 output. It is not safe to clobber them.
114 There are some uncommon cases where the address is already in a register
115 for some reason, but we cannot take advantage of that because we have
116 no easy way to unshare the MEM. In addition, looking up all stack
117 addresses is costly. */
120 can_simplify_addr (rtx addr
)
124 if (CONSTANT_ADDRESS_P (addr
))
127 if (GET_CODE (addr
) == PLUS
)
128 reg
= XEXP (addr
, 0);
133 || (REGNO (reg
) != FRAME_POINTER_REGNUM
134 && REGNO (reg
) != HARD_FRAME_POINTER_REGNUM
135 && REGNO (reg
) != ARG_POINTER_REGNUM
));
138 /* Returns a canonical version of X for the address, from the point of view,
139 that all multiplications are represented as MULT instead of the multiply
140 by a power of 2 being represented as ASHIFT.
142 Every ASHIFT we find has been made by simplify_gen_binary and was not
143 there before, so it is not shared. So we can do this in place. */
146 canonicalize_address (rtx x
)
149 switch (GET_CODE (x
))
152 if (GET_CODE (XEXP (x
, 1)) == CONST_INT
153 && INTVAL (XEXP (x
, 1)) < GET_MODE_BITSIZE (GET_MODE (x
))
154 && INTVAL (XEXP (x
, 1)) >= 0)
156 HOST_WIDE_INT shift
= INTVAL (XEXP (x
, 1));
158 XEXP (x
, 1) = gen_int_mode ((HOST_WIDE_INT
) 1 << shift
,
166 if (GET_CODE (XEXP (x
, 0)) == PLUS
167 || GET_CODE (XEXP (x
, 0)) == ASHIFT
168 || GET_CODE (XEXP (x
, 0)) == CONST
)
169 canonicalize_address (XEXP (x
, 0));
183 /* OLD is a memory address. Return whether it is good to use NEW instead,
184 for a memory access in the given MODE. */
187 should_replace_address (rtx old
, rtx
new, enum machine_mode mode
)
191 if (rtx_equal_p (old
, new) || !memory_address_p (mode
, new))
194 /* Copy propagation is always ok. */
195 if (REG_P (old
) && REG_P (new))
198 /* Prefer the new address if it is less expensive. */
199 gain
= address_cost (old
, mode
) - address_cost (new, mode
);
201 /* If the addresses have equivalent cost, prefer the new address
202 if it has the highest `rtx_cost'. That has the potential of
203 eliminating the most insns without additional costs, and it
204 is the same that cse.c used to do. */
206 gain
= rtx_cost (new, SET
) - rtx_cost (old
, SET
);
211 /* Replace all occurrences of OLD in *PX with NEW and try to simplify the
212 resulting expression. Replace *PX with a new RTL expression if an
213 occurrence of OLD was found.
215 If CAN_APPEAR is true, we always return true; if it is false, we
216 can return false if, for at least one occurrence OLD, we failed to
217 collapse the result to a constant. For example, (mult:M (reg:M A)
218 (minus:M (reg:M B) (reg:M A))) may collapse to zero if replacing
219 (reg:M B) with (reg:M A).
221 CAN_APPEAR is disregarded inside MEMs: in that case, we always return
222 true if the simplification is a cheaper and valid memory address.
224 This is only a wrapper around simplify-rtx.c: do not add any pattern
225 matching code here. (The sole exception is the handling of LO_SUM, but
226 that is because there is no simplify_gen_* function for LO_SUM). */
229 propagate_rtx_1 (rtx
*px
, rtx old
, rtx
new, bool can_appear
)
231 rtx x
= *px
, tem
= NULL_RTX
, op0
, op1
, op2
;
232 enum rtx_code code
= GET_CODE (x
);
233 enum machine_mode mode
= GET_MODE (x
);
234 enum machine_mode op_mode
;
235 bool valid_ops
= true;
237 /* If X is OLD_RTX, return NEW_RTX. Otherwise, if this is an expression,
238 try to build a new expression from recursive substitution. */
246 switch (GET_RTX_CLASS (code
))
250 op_mode
= GET_MODE (op0
);
251 valid_ops
&= propagate_rtx_1 (&op0
, old
, new, can_appear
);
252 if (op0
== XEXP (x
, 0))
254 tem
= simplify_gen_unary (code
, mode
, op0
, op_mode
);
261 valid_ops
&= propagate_rtx_1 (&op0
, old
, new, can_appear
);
262 valid_ops
&= propagate_rtx_1 (&op1
, old
, new, can_appear
);
263 if (op0
== XEXP (x
, 0) && op1
== XEXP (x
, 1))
265 tem
= simplify_gen_binary (code
, mode
, op0
, op1
);
269 case RTX_COMM_COMPARE
:
272 op_mode
= GET_MODE (op0
) != VOIDmode
? GET_MODE (op0
) : GET_MODE (op1
);
273 valid_ops
&= propagate_rtx_1 (&op0
, old
, new, can_appear
);
274 valid_ops
&= propagate_rtx_1 (&op1
, old
, new, can_appear
);
275 if (op0
== XEXP (x
, 0) && op1
== XEXP (x
, 1))
277 tem
= simplify_gen_relational (code
, mode
, op_mode
, op0
, op1
);
281 case RTX_BITFIELD_OPS
:
285 op_mode
= GET_MODE (op0
);
286 valid_ops
&= propagate_rtx_1 (&op0
, old
, new, can_appear
);
287 valid_ops
&= propagate_rtx_1 (&op1
, old
, new, can_appear
);
288 valid_ops
&= propagate_rtx_1 (&op2
, old
, new, can_appear
);
289 if (op0
== XEXP (x
, 0) && op1
== XEXP (x
, 1) && op2
== XEXP (x
, 2))
291 if (op_mode
== VOIDmode
)
292 op_mode
= GET_MODE (op0
);
293 tem
= simplify_gen_ternary (code
, mode
, op_mode
, op0
, op1
, op2
);
297 /* The only case we try to handle is a SUBREG. */
301 valid_ops
&= propagate_rtx_1 (&op0
, old
, new, can_appear
);
302 if (op0
== XEXP (x
, 0))
304 tem
= simplify_gen_subreg (mode
, op0
, GET_MODE (SUBREG_REG (x
)),
310 if (code
== MEM
&& x
!= new)
315 /* There are some addresses that we cannot work on. */
316 if (!can_simplify_addr (op0
))
319 op0
= new_op0
= targetm
.delegitimize_address (op0
);
320 valid_ops
&= propagate_rtx_1 (&new_op0
, old
, new, true);
322 /* Dismiss transformation that we do not want to carry on. */
325 || !(GET_MODE (new_op0
) == GET_MODE (op0
)
326 || GET_MODE (new_op0
) == VOIDmode
))
329 canonicalize_address (new_op0
);
331 /* Copy propagations are always ok. Otherwise check the costs. */
332 if (!(REG_P (old
) && REG_P (new))
333 && !should_replace_address (op0
, new_op0
, GET_MODE (x
)))
336 tem
= replace_equiv_address_nv (x
, new_op0
);
339 else if (code
== LO_SUM
)
344 /* The only simplification we do attempts to remove references to op0
345 or make it constant -- in both cases, op0's invalidity will not
346 make the result invalid. */
347 propagate_rtx_1 (&op0
, old
, new, true);
348 valid_ops
&= propagate_rtx_1 (&op1
, old
, new, can_appear
);
349 if (op0
== XEXP (x
, 0) && op1
== XEXP (x
, 1))
352 /* (lo_sum (high x) x) -> x */
353 if (GET_CODE (op0
) == HIGH
&& rtx_equal_p (XEXP (op0
, 0), op1
))
356 tem
= gen_rtx_LO_SUM (mode
, op0
, op1
);
358 /* OP1 is likely not a legitimate address, otherwise there would have
359 been no LO_SUM. We want it to disappear if it is invalid, return
360 false in that case. */
361 return memory_address_p (mode
, tem
);
364 else if (code
== REG
)
366 if (rtx_equal_p (x
, old
))
378 /* No change, no trouble. */
384 /* The replacement we made so far is valid, if all of the recursive
385 replacements were valid, or we could simplify everything to
387 return valid_ops
|| can_appear
|| CONSTANT_P (tem
);
390 /* Replace all occurrences of OLD in X with NEW and try to simplify the
391 resulting expression (in mode MODE). Return a new expression if it is
392 a constant, otherwise X.
394 Simplifications where occurrences of NEW collapse to a constant are always
395 accepted. All simplifications are accepted if NEW is a pseudo too.
396 Otherwise, we accept simplifications that have a lower or equal cost. */
399 propagate_rtx (rtx x
, enum machine_mode mode
, rtx old
, rtx
new)
404 if (REG_P (new) && REGNO (new) < FIRST_PSEUDO_REGISTER
)
407 new = copy_rtx (new);
410 collapsed
= propagate_rtx_1 (&tem
, old
, new, REG_P (new) || CONSTANT_P (new));
411 if (tem
== x
|| !collapsed
)
414 /* gen_lowpart_common will not be able to process VOIDmode entities other
416 if (GET_MODE (tem
) == VOIDmode
&& GET_CODE (tem
) != CONST_INT
)
419 if (GET_MODE (tem
) == VOIDmode
)
420 tem
= rtl_hooks
.gen_lowpart_no_emit (mode
, tem
);
422 gcc_assert (GET_MODE (tem
) == mode
);
430 /* Return true if the register from reference REF is killed
431 between FROM to (but not including) TO. */
434 local_ref_killed_between_p (struct df_ref
* ref
, rtx from
, rtx to
)
438 for (insn
= from
; insn
!= to
; insn
= NEXT_INSN (insn
))
440 struct df_ref
**def_rec
;
444 for (def_rec
= DF_INSN_DEFS (insn
); *def_rec
; def_rec
++)
446 struct df_ref
*def
= *def_rec
;
447 if (DF_REF_REGNO (ref
) == DF_REF_REGNO (def
))
455 /* Check if the given DEF is available in INSN. This would require full
456 computation of available expressions; we check only restricted conditions:
457 - if DEF is the sole definition of its register, go ahead;
458 - in the same basic block, we check for no definitions killing the
459 definition of DEF_INSN;
460 - if USE's basic block has DEF's basic block as the sole predecessor,
461 we check if the definition is killed after DEF_INSN or before
462 TARGET_INSN insn, in their respective basic blocks. */
464 use_killed_between (struct df_ref
*use
, rtx def_insn
, rtx target_insn
)
466 basic_block def_bb
= BLOCK_FOR_INSN (def_insn
);
467 basic_block target_bb
= BLOCK_FOR_INSN (target_insn
);
471 /* In some obscure situations we can have a def reaching a use
472 that is _before_ the def. In other words the def does not
473 dominate the use even though the use and def are in the same
474 basic block. This can happen when a register may be used
475 uninitialized in a loop. In such cases, we must assume that
476 DEF is not available. */
477 if (def_bb
== target_bb
478 ? DF_INSN_LUID (def_insn
) >= DF_INSN_LUID (target_insn
)
479 : !dominated_by_p (CDI_DOMINATORS
, target_bb
, def_bb
))
482 /* Check if the reg in USE has only one definition. We already
483 know that this definition reaches use, or we wouldn't be here. */
484 regno
= DF_REF_REGNO (use
);
485 def
= DF_REG_DEF_CHAIN (regno
);
486 if (def
&& (def
->next_reg
== NULL
))
489 /* Check locally if we are in the same basic block. */
490 if (def_bb
== target_bb
)
491 return local_ref_killed_between_p (use
, def_insn
, target_insn
);
493 /* Finally, if DEF_BB is the sole predecessor of TARGET_BB. */
494 if (single_pred_p (target_bb
)
495 && single_pred (target_bb
) == def_bb
)
499 /* See if USE is killed between DEF_INSN and the last insn in the
500 basic block containing DEF_INSN. */
501 x
= df_bb_regno_last_def_find (def_bb
, regno
);
502 if (x
&& DF_INSN_LUID (x
->insn
) >= DF_INSN_LUID (def_insn
))
505 /* See if USE is killed between TARGET_INSN and the first insn in the
506 basic block containing TARGET_INSN. */
507 x
= df_bb_regno_first_def_find (target_bb
, regno
);
508 if (x
&& DF_INSN_LUID (x
->insn
) < DF_INSN_LUID (target_insn
))
514 /* Otherwise assume the worst case. */
519 /* for_each_rtx traversal function that returns 1 if BODY points to
520 a non-constant mem. */
523 varying_mem_p (rtx
*body
, void *data ATTRIBUTE_UNUSED
)
526 return MEM_P (x
) && !MEM_READONLY_P (x
);
529 /* Check if all uses in DEF_INSN can be used in TARGET_INSN. This
530 would require full computation of available expressions;
531 we check only restricted conditions, see use_killed_between. */
533 all_uses_available_at (rtx def_insn
, rtx target_insn
)
535 struct df_ref
**use_rec
;
536 rtx def_set
= single_set (def_insn
);
538 gcc_assert (def_set
);
540 /* If target_insn comes right after def_insn, which is very common
541 for addresses, we can use a quicker test. */
542 if (NEXT_INSN (def_insn
) == target_insn
543 && REG_P (SET_DEST (def_set
)))
545 rtx def_reg
= SET_DEST (def_set
);
547 /* If the insn uses the reg that it defines, the substitution is
549 for (use_rec
= DF_INSN_USES (def_insn
); *use_rec
; use_rec
++)
551 struct df_ref
*use
= *use_rec
;
552 if (rtx_equal_p (DF_REF_REG (use
), def_reg
))
555 for (use_rec
= DF_INSN_EQ_USES (def_insn
); *use_rec
; use_rec
++)
557 struct df_ref
*use
= *use_rec
;
558 if (rtx_equal_p (use
->reg
, def_reg
))
564 /* Look at all the uses of DEF_INSN, and see if they are not
565 killed between DEF_INSN and TARGET_INSN. */
566 for (use_rec
= DF_INSN_USES (def_insn
); *use_rec
; use_rec
++)
568 struct df_ref
*use
= *use_rec
;
569 if (use_killed_between (use
, def_insn
, target_insn
))
572 for (use_rec
= DF_INSN_EQ_USES (def_insn
); *use_rec
; use_rec
++)
574 struct df_ref
*use
= *use_rec
;
575 if (use_killed_between (use
, def_insn
, target_insn
))
580 /* We don't do any analysis of memories or aliasing. Reject any
581 instruction that involves references to non-constant memory. */
582 return !for_each_rtx (&SET_SRC (def_set
), varying_mem_p
, NULL
);
586 struct find_occurrence_data
592 /* Callback for for_each_rtx, used in find_occurrence.
593 See if PX is the rtx we have to find. Return 1 to stop for_each_rtx
594 if successful, or 0 to continue traversing otherwise. */
597 find_occurrence_callback (rtx
*px
, void *data
)
599 struct find_occurrence_data
*fod
= (struct find_occurrence_data
*) data
;
601 rtx find
= fod
->find
;
612 /* Return a pointer to one of the occurrences of register FIND in *PX. */
615 find_occurrence (rtx
*px
, rtx find
)
617 struct find_occurrence_data data
;
619 gcc_assert (REG_P (find
)
620 || (GET_CODE (find
) == SUBREG
621 && REG_P (SUBREG_REG (find
))));
625 for_each_rtx (px
, find_occurrence_callback
, &data
);
630 /* Inside INSN, the expression rooted at *LOC has been changed, moving some
631 uses from USE_VEC. Find those that are present, and create new items
632 in the data flow object of the pass. Mark any new uses as having the
635 update_df (rtx insn
, rtx
*loc
, struct df_ref
**use_rec
, enum df_ref_type type
,
638 bool changed
= false;
640 /* Add a use for the registers that were propagated. */
643 struct df_ref
*use
= *use_rec
;
644 struct df_ref
*orig_use
= use
, *new_use
;
647 rtx
*new_loc
= find_occurrence (loc
, DF_REF_REG (orig_use
));
653 if (DF_REF_FLAGS_IS_SET (orig_use
, DF_REF_SIGN_EXTRACT
| DF_REF_ZERO_EXTRACT
))
655 width
= DF_REF_WIDTH (orig_use
);
656 offset
= DF_REF_OFFSET (orig_use
);
659 /* Add a new insn use. Use the original type, because it says if the
660 use was within a MEM. */
661 new_use
= df_ref_create (DF_REF_REG (orig_use
), new_loc
,
662 insn
, BLOCK_FOR_INSN (insn
),
663 type
, DF_REF_FLAGS (orig_use
) | new_flags
, width
, offset
);
665 /* Set up the use-def chain. */
666 df_chain_copy (new_use
, DF_REF_CHAIN (orig_use
));
670 df_insn_rescan (insn
);
674 /* Try substituting NEW into LOC, which originated from forward propagation
675 of USE's value from DEF_INSN. SET_REG_EQUAL says whether we are
676 substituting the whole SET_SRC, so we can set a REG_EQUAL note if the
677 new insn is not recognized. Return whether the substitution was
681 try_fwprop_subst (struct df_ref
*use
, rtx
*loc
, rtx
new, rtx def_insn
, bool set_reg_equal
)
683 rtx insn
= DF_REF_INSN (use
);
684 enum df_ref_type type
= DF_REF_TYPE (use
);
685 int flags
= DF_REF_FLAGS (use
);
686 rtx set
= single_set (insn
);
687 int old_cost
= rtx_cost (SET_SRC (set
), SET
);
692 fprintf (dump_file
, "\nIn insn %d, replacing\n ", INSN_UID (insn
));
693 print_inline_rtx (dump_file
, *loc
, 2);
694 fprintf (dump_file
, "\n with ");
695 print_inline_rtx (dump_file
, new, 2);
696 fprintf (dump_file
, "\n");
699 validate_unshare_change (insn
, loc
, new, true);
700 if (!verify_changes (0))
703 fprintf (dump_file
, "Changes to insn %d not recognized\n",
708 else if (DF_REF_TYPE (use
) == DF_REF_REG_USE
709 && rtx_cost (SET_SRC (set
), SET
) > old_cost
)
712 fprintf (dump_file
, "Changes to insn %d not profitable\n",
720 fprintf (dump_file
, "Changed insn %d\n", INSN_UID (insn
));
726 confirm_change_group ();
730 if (!CONSTANT_P (new))
732 update_df (insn
, loc
, DF_INSN_USES (def_insn
), type
, flags
);
733 update_df (insn
, loc
, DF_INSN_EQ_USES (def_insn
), type
, flags
);
740 /* Can also record a simplified value in a REG_EQUAL note,
741 making a new one if one does not already exist.
742 Don't do this if the insn has a REG_RETVAL note, because the
743 combined presence means that the REG_EQUAL note refers to the
744 (full) contents of the libcall value. */
745 if (set_reg_equal
&& !find_reg_note (insn
, REG_RETVAL
, NULL_RTX
))
748 fprintf (dump_file
, " Setting REG_EQUAL note\n");
750 set_unique_reg_note (insn
, REG_EQUAL
, copy_rtx (new));
752 /* ??? Is this still necessary if we add the note through
753 set_unique_reg_note? */
754 if (!CONSTANT_P (new))
756 update_df (insn
, loc
, DF_INSN_USES (def_insn
),
757 type
, DF_REF_IN_NOTE
);
758 update_df (insn
, loc
, DF_INSN_EQ_USES (def_insn
),
759 type
, DF_REF_IN_NOTE
);
768 /* If USE is a paradoxical subreg, see if it can be replaced by a pseudo. */
771 forward_propagate_subreg (struct df_ref
*use
, rtx def_insn
, rtx def_set
)
773 rtx use_reg
= DF_REF_REG (use
);
776 /* Only consider paradoxical subregs... */
777 enum machine_mode use_mode
= GET_MODE (use_reg
);
778 if (GET_CODE (use_reg
) != SUBREG
779 || !REG_P (SET_DEST (def_set
))
780 || GET_MODE_SIZE (use_mode
)
781 <= GET_MODE_SIZE (GET_MODE (SUBREG_REG (use_reg
))))
784 /* If this is a paradoxical SUBREG, we have no idea what value the
785 extra bits would have. However, if the operand is equivalent to
786 a SUBREG whose operand is the same as our mode, and all the modes
787 are within a word, we can just use the inner operand because
788 these SUBREGs just say how to treat the register. */
789 use_insn
= DF_REF_INSN (use
);
790 src
= SET_SRC (def_set
);
791 if (GET_CODE (src
) == SUBREG
792 && REG_P (SUBREG_REG (src
))
793 && GET_MODE (SUBREG_REG (src
)) == use_mode
794 && subreg_lowpart_p (src
)
795 && all_uses_available_at (def_insn
, use_insn
))
796 return try_fwprop_subst (use
, DF_REF_LOC (use
), SUBREG_REG (src
),
802 /* Try to replace USE with SRC (defined in DEF_INSN) and simplify the
806 forward_propagate_and_simplify (struct df_ref
*use
, rtx def_insn
, rtx def_set
)
808 rtx use_insn
= DF_REF_INSN (use
);
809 rtx use_set
= single_set (use_insn
);
810 rtx src
, reg
, new, *loc
;
812 enum machine_mode mode
;
817 /* Do not propagate into PC, CC0, etc. */
818 if (GET_MODE (SET_DEST (use_set
)) == VOIDmode
)
821 /* If def and use are subreg, check if they match. */
822 reg
= DF_REF_REG (use
);
823 if (GET_CODE (reg
) == SUBREG
824 && GET_CODE (SET_DEST (def_set
)) == SUBREG
825 && (SUBREG_BYTE (SET_DEST (def_set
)) != SUBREG_BYTE (reg
)
826 || GET_MODE (SET_DEST (def_set
)) != GET_MODE (reg
)))
829 /* Check if the def had a subreg, but the use has the whole reg. */
830 if (REG_P (reg
) && GET_CODE (SET_DEST (def_set
)) == SUBREG
)
833 /* Check if the use has a subreg, but the def had the whole reg. Unlike the
834 previous case, the optimization is possible and often useful indeed. */
835 if (GET_CODE (reg
) == SUBREG
&& REG_P (SET_DEST (def_set
)))
836 reg
= SUBREG_REG (reg
);
838 /* Check if the substitution is valid (last, because it's the most
839 expensive check!). */
840 src
= SET_SRC (def_set
);
841 if (!CONSTANT_P (src
) && !all_uses_available_at (def_insn
, use_insn
))
844 /* Check if the def is loading something from the constant pool; in this
845 case we would undo optimization such as compress_float_constant.
846 Still, we can set a REG_EQUAL note. */
847 if (MEM_P (src
) && MEM_READONLY_P (src
))
849 rtx x
= avoid_constant_pool_reference (src
);
852 rtx note
= find_reg_note (use_insn
, REG_EQUAL
, NULL_RTX
);
853 rtx old
= note
? XEXP (note
, 0) : SET_SRC (use_set
);
854 rtx
new = simplify_replace_rtx (old
, src
, x
);
856 set_unique_reg_note (use_insn
, REG_EQUAL
, copy_rtx (new));
861 /* Else try simplifying. */
863 if (DF_REF_TYPE (use
) == DF_REF_REG_MEM_STORE
)
865 loc
= &SET_DEST (use_set
);
866 set_reg_equal
= false;
870 rtx note
= find_reg_note (use_insn
, REG_EQUAL
, NULL_RTX
);
871 if (DF_REF_FLAGS (use
) & DF_REF_IN_NOTE
)
872 loc
= &XEXP (note
, 0);
874 loc
= &SET_SRC (use_set
);
876 /* Do not replace an existing REG_EQUAL note if the insn is not
877 recognized. Either we're already replacing in the note, or
878 we'll separately try plugging the definition in the note and
880 set_reg_equal
= (note
== NULL_RTX
);
883 if (GET_MODE (*loc
) == VOIDmode
)
884 mode
= GET_MODE (SET_DEST (use_set
));
886 mode
= GET_MODE (*loc
);
888 new = propagate_rtx (*loc
, mode
, reg
, src
);
893 return try_fwprop_subst (use
, loc
, new, def_insn
, set_reg_equal
);
897 /* Given a use USE of an insn, if it has a single reaching
898 definition, try to forward propagate it into that insn. */
901 forward_propagate_into (struct df_ref
*use
)
903 struct df_link
*defs
;
905 rtx def_insn
, def_set
, use_insn
;
908 if (DF_REF_FLAGS (use
) & DF_REF_READ_WRITE
)
910 if (DF_REF_IS_ARTIFICIAL (use
))
913 /* Only consider uses that have a single definition. */
914 defs
= DF_REF_CHAIN (use
);
915 if (!defs
|| defs
->next
)
919 if (DF_REF_FLAGS (def
) & DF_REF_READ_WRITE
)
921 if (DF_REF_IS_ARTIFICIAL (def
))
924 /* Do not propagate loop invariant definitions inside the loop. */
925 if (DF_REF_BB (def
)->loop_father
!= DF_REF_BB (use
)->loop_father
)
928 /* Check if the use is still present in the insn! */
929 use_insn
= DF_REF_INSN (use
);
930 if (DF_REF_FLAGS (use
) & DF_REF_IN_NOTE
)
931 parent
= find_reg_note (use_insn
, REG_EQUAL
, NULL_RTX
);
933 parent
= PATTERN (use_insn
);
935 if (!loc_mentioned_in_p (DF_REF_LOC (use
), parent
))
938 def_insn
= DF_REF_INSN (def
);
939 if (multiple_sets (def_insn
))
941 def_set
= single_set (def_insn
);
945 /* Only try one kind of propagation. If two are possible, we'll
946 do it on the following iterations. */
947 if (!forward_propagate_and_simplify (use
, def_insn
, def_set
))
948 forward_propagate_subreg (use
, def_insn
, def_set
);
956 calculate_dominance_info (CDI_DOMINATORS
);
958 /* We do not always want to propagate into loops, so we have to find
959 loops and be careful about them. But we have to call flow_loops_find
960 before df_analyze, because flow_loops_find may introduce new jump
961 insns (sadly) if we are not working in cfglayout mode. */
962 loop_optimizer_init (0);
964 /* Now set up the dataflow problem (we only want use-def chains) and
965 put the dataflow solver to work. */
966 df_set_flags (DF_EQ_NOTES
);
967 df_chain_add_problem (DF_UD_CHAIN
);
969 df_maybe_reorganize_use_refs (DF_REF_ORDER_BY_INSN_WITH_NOTES
);
970 df_set_flags (DF_DEFER_INSN_RESCAN
);
976 loop_optimizer_finalize ();
978 free_dominance_info (CDI_DOMINATORS
);
980 delete_trivially_dead_insns (get_insns (), max_reg_num ());
984 "\nNumber of successful forward propagations: %d\n\n",
990 /* Main entry point. */
995 return optimize
> 0 && flag_forward_propagate
;
1005 /* Go through all the uses. update_df will create new ones at the
1006 end, and we'll go through them as well.
1008 Do not forward propagate addresses into loops until after unrolling.
1009 CSE did so because it was able to fix its own mess, but we are not. */
1011 for (i
= 0; i
< DF_USES_TABLE_SIZE (); i
++)
1013 struct df_ref
*use
= DF_USES_GET (i
);
1015 if (DF_REF_TYPE (use
) == DF_REF_REG_USE
1016 || DF_REF_BB (use
)->loop_father
== NULL
)
1017 forward_propagate_into (use
);
1024 struct rtl_opt_pass pass_rtl_fwprop
=
1028 "fwprop1", /* name */
1029 gate_fwprop
, /* gate */
1030 fwprop
, /* execute */
1033 0, /* static_pass_number */
1034 TV_FWPROP
, /* tv_id */
1035 0, /* properties_required */
1036 0, /* properties_provided */
1037 0, /* properties_destroyed */
1038 0, /* todo_flags_start */
1039 TODO_df_finish
| TODO_verify_rtl_sharing
|
1040 TODO_dump_func
/* todo_flags_finish */
1050 /* Go through all the uses. update_df will create new ones at the
1051 end, and we'll go through them as well. */
1052 df_set_flags (DF_DEFER_INSN_RESCAN
);
1054 for (i
= 0; i
< DF_USES_TABLE_SIZE (); i
++)
1056 struct df_ref
*use
= DF_USES_GET (i
);
1058 if (DF_REF_TYPE (use
) != DF_REF_REG_USE
1059 && DF_REF_BB (use
)->loop_father
!= NULL
)
1060 forward_propagate_into (use
);
1068 struct rtl_opt_pass pass_rtl_fwprop_addr
=
1072 "fwprop2", /* name */
1073 gate_fwprop
, /* gate */
1074 fwprop_addr
, /* execute */
1077 0, /* static_pass_number */
1078 TV_FWPROP
, /* tv_id */
1079 0, /* properties_required */
1080 0, /* properties_provided */
1081 0, /* properties_destroyed */
1082 0, /* todo_flags_start */
1083 TODO_df_finish
| TODO_verify_rtl_sharing
|
1084 TODO_dump_func
/* todo_flags_finish */