1 /* Post reload partially redundant load elimination
2 Copyright (C) 2004-2015 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
24 #include "diagnostic-core.h"
26 #include "hash-table.h"
37 #include "hard-reg-set.h"
39 #include "insn-config.h"
43 #include "dominance.h"
46 #include "basic-block.h"
49 #include "statistics.h"
63 #include "tree-pass.h"
66 #include "gcse-common.h"
68 /* The following code implements gcse after reload, the purpose of this
69 pass is to cleanup redundant loads generated by reload and other
70 optimizations that come after gcse. It searches for simple inter-block
71 redundancies and tries to eliminate them by adding moves and loads
74 Perform partially redundant load elimination, try to eliminate redundant
75 loads created by the reload pass. We try to look for full or partial
76 redundant loads fed by one or more loads/stores in predecessor BBs,
77 and try adding loads to make them fully redundant. We also check if
78 it's worth adding loads to be able to delete the redundant load.
81 1. Build available expressions hash table:
82 For each load/store instruction, if the loaded/stored memory didn't
83 change until the end of the basic block add this memory expression to
85 2. Perform Redundancy elimination:
86 For each load instruction do the following:
87 perform partial redundancy elimination, check if it's worth adding
88 loads to make the load fully redundant. If so add loads and
89 register copies and delete the load.
90 3. Delete instructions made redundant in step 2.
93 If the loaded register is used/defined between load and some store,
94 look for some other free register between load and all its stores,
95 and replace the load with a copy from this register to the loaded
100 /* Keep statistics of this pass. */
108 /* We need to keep a hash table of expressions. The table entries are of
109 type 'struct expr', and for each expression there is a single linked
110 list of occurrences. */
112 /* Expression elements in the hash table. */
115 /* The expression (SET_SRC for expressions, PATTERN for assignments). */
118 /* The same hash for this entry. */
121 /* Index in the transparent bitmaps. */
122 unsigned int bitmap_index
;
124 /* List of available occurrence in basic blocks in the function. */
125 struct occr
*avail_occr
;
128 /* Hashtable helpers. */
130 struct expr_hasher
: typed_noop_remove
<expr
>
132 typedef expr
*value_type
;
133 typedef expr
*compare_type
;
134 static inline hashval_t
hash (const expr
*);
135 static inline bool equal (const expr
*, const expr
*);
139 /* Hash expression X.
140 DO_NOT_RECORD_P is a boolean indicating if a volatile operand is found
141 or if the expression contains something we don't want to insert in the
145 hash_expr (rtx x
, int *do_not_record_p
)
147 *do_not_record_p
= 0;
148 return hash_rtx (x
, GET_MODE (x
), do_not_record_p
,
149 NULL
, /*have_reg_qty=*/false);
152 /* Callback for hashtab.
153 Return the hash value for expression EXP. We don't actually hash
154 here, we just return the cached hash value. */
157 expr_hasher::hash (const expr
*exp
)
162 /* Callback for hashtab.
163 Return nonzero if exp1 is equivalent to exp2. */
166 expr_hasher::equal (const expr
*exp1
, const expr
*exp2
)
168 int equiv_p
= exp_equiv_p (exp1
->expr
, exp2
->expr
, 0, true);
170 gcc_assert (!equiv_p
|| exp1
->hash
== exp2
->hash
);
174 /* The table itself. */
175 static hash_table
<expr_hasher
> *expr_table
;
178 static struct obstack expr_obstack
;
180 /* Occurrence of an expression.
181 There is at most one occurrence per basic block. If a pattern appears
182 more than once, the last appearance is used. */
186 /* Next occurrence of this expression. */
188 /* The insn that computes the expression. */
190 /* Nonzero if this [anticipatable] occurrence has been deleted. */
194 static struct obstack occr_obstack
;
196 /* The following structure holds the information about the occurrences of
197 the redundant instructions. */
205 static struct obstack unoccr_obstack
;
207 /* Array where each element is the CUID if the insn that last set the hard
208 register with the number of the element, since the start of the current
211 This array is used during the building of the hash table (step 1) to
212 determine if a reg is killed before the end of a basic block.
214 It is also used when eliminating partial redundancies (step 2) to see
215 if a reg was modified since the start of a basic block. */
216 static int *reg_avail_info
;
218 /* A list of insns that may modify memory within the current basic block. */
222 struct modifies_mem
*next
;
224 static struct modifies_mem
*modifies_mem_list
;
226 /* The modifies_mem structs also go on an obstack, only this obstack is
227 freed each time after completing the analysis or transformations on
228 a basic block. So we allocate a dummy modifies_mem_obstack_bottom
229 object on the obstack to keep track of the bottom of the obstack. */
230 static struct obstack modifies_mem_obstack
;
231 static struct modifies_mem
*modifies_mem_obstack_bottom
;
233 /* Mapping of insn UIDs to CUIDs.
234 CUIDs are like UIDs except they increase monotonically in each basic
235 block, have no gaps, and only apply to real insns. */
236 static int *uid_cuid
;
237 #define INSN_CUID(INSN) (uid_cuid[INSN_UID (INSN)])
239 /* Bitmap of blocks which have memory stores. */
240 static bitmap modify_mem_list_set
;
242 /* Bitmap of blocks which have calls. */
243 static bitmap blocks_with_calls
;
245 /* Vector indexed by block # with a list of all the insns that
246 modify memory within the block. */
247 static vec
<rtx_insn
*> *modify_mem_list
;
249 /* Vector indexed by block # with a canonicalized list of insns
250 that modify memory in the block. */
251 static vec
<modify_pair
> *canon_modify_mem_list
;
253 /* Vector of simple bitmaps indexed by block number. Each component sbitmap
254 indicates which expressions are transparent through the block. */
255 static sbitmap
*transp
;
258 /* Helpers for memory allocation/freeing. */
259 static void alloc_mem (void);
260 static void free_mem (void);
262 /* Support for hash table construction and transformations. */
263 static bool oprs_unchanged_p (rtx
, rtx_insn
*, bool);
264 static void record_last_reg_set_info (rtx_insn
*, rtx
);
265 static void record_last_reg_set_info_regno (rtx_insn
*, int);
266 static void record_last_mem_set_info (rtx_insn
*);
267 static void record_last_set_info (rtx
, const_rtx
, void *);
268 static void record_opr_changes (rtx_insn
*);
270 static void find_mem_conflicts (rtx
, const_rtx
, void *);
271 static int load_killed_in_block_p (int, rtx
, bool);
272 static void reset_opr_set_tables (void);
274 /* Hash table support. */
275 static hashval_t
hash_expr (rtx
, int *);
276 static void insert_expr_in_table (rtx
, rtx_insn
*);
277 static struct expr
*lookup_expr_in_table (rtx
);
278 static void dump_hash_table (FILE *);
280 /* Helpers for eliminate_partially_redundant_load. */
281 static bool reg_killed_on_edge (rtx
, edge
);
282 static bool reg_used_on_edge (rtx
, edge
);
284 static rtx
get_avail_load_store_reg (rtx_insn
*);
286 static bool bb_has_well_behaved_predecessors (basic_block
);
287 static struct occr
* get_bb_avail_insn (basic_block
, struct occr
*, int);
288 static void hash_scan_set (rtx_insn
*);
289 static void compute_hash_table (void);
291 /* The work horses of this pass. */
292 static void eliminate_partially_redundant_load (basic_block
,
295 static void eliminate_partially_redundant_loads (void);
298 /* Allocate memory for the CUID mapping array and register/memory
308 /* Find the largest UID and create a mapping from UIDs to CUIDs. */
309 uid_cuid
= XCNEWVEC (int, get_max_uid () + 1);
311 FOR_EACH_BB_FN (bb
, cfun
)
312 FOR_BB_INSNS (bb
, insn
)
315 uid_cuid
[INSN_UID (insn
)] = i
++;
317 uid_cuid
[INSN_UID (insn
)] = i
;
320 /* Allocate the available expressions hash table. We don't want to
321 make the hash table too small, but unnecessarily making it too large
322 also doesn't help. The i/4 is a gcse.c relic, and seems like a
323 reasonable choice. */
324 expr_table
= new hash_table
<expr_hasher
> (MAX (i
/ 4, 13));
326 /* We allocate everything on obstacks because we often can roll back
327 the whole obstack to some point. Freeing obstacks is very fast. */
328 gcc_obstack_init (&expr_obstack
);
329 gcc_obstack_init (&occr_obstack
);
330 gcc_obstack_init (&unoccr_obstack
);
331 gcc_obstack_init (&modifies_mem_obstack
);
333 /* Working array used to track the last set for each register
334 in the current block. */
335 reg_avail_info
= (int *) xmalloc (FIRST_PSEUDO_REGISTER
* sizeof (int));
337 /* Put a dummy modifies_mem object on the modifies_mem_obstack, so we
338 can roll it back in reset_opr_set_tables. */
339 modifies_mem_obstack_bottom
=
340 (struct modifies_mem
*) obstack_alloc (&modifies_mem_obstack
,
341 sizeof (struct modifies_mem
));
343 blocks_with_calls
= BITMAP_ALLOC (NULL
);
344 modify_mem_list_set
= BITMAP_ALLOC (NULL
);
346 modify_mem_list
= (vec_rtx_heap
*) xcalloc (last_basic_block_for_fn (cfun
),
347 sizeof (vec_rtx_heap
));
348 canon_modify_mem_list
349 = (vec_modify_pair_heap
*) xcalloc (last_basic_block_for_fn (cfun
),
350 sizeof (vec_modify_pair_heap
));
353 /* Free memory allocated by alloc_mem. */
363 obstack_free (&expr_obstack
, NULL
);
364 obstack_free (&occr_obstack
, NULL
);
365 obstack_free (&unoccr_obstack
, NULL
);
366 obstack_free (&modifies_mem_obstack
, NULL
);
370 EXECUTE_IF_SET_IN_BITMAP (modify_mem_list_set
, 0, i
, bi
)
372 modify_mem_list
[i
].release ();
373 canon_modify_mem_list
[i
].release ();
376 BITMAP_FREE (blocks_with_calls
);
377 BITMAP_FREE (modify_mem_list_set
);
378 free (reg_avail_info
);
382 /* Insert expression X in INSN in the hash TABLE.
383 If it is already present, record it as the last occurrence in INSN's
387 insert_expr_in_table (rtx x
, rtx_insn
*insn
)
391 struct expr
*cur_expr
, **slot
;
392 struct occr
*avail_occr
, *last_occr
= NULL
;
394 hash
= hash_expr (x
, &do_not_record_p
);
396 /* Do not insert expression in the table if it contains volatile operands,
397 or if hash_expr determines the expression is something we don't want
398 to or can't handle. */
402 /* We anticipate that redundant expressions are rare, so for convenience
403 allocate a new hash table element here already and set its fields.
404 If we don't do this, we need a hack with a static struct expr. Anyway,
405 obstack_free is really fast and one more obstack_alloc doesn't hurt if
406 we're going to see more expressions later on. */
407 cur_expr
= (struct expr
*) obstack_alloc (&expr_obstack
,
408 sizeof (struct expr
));
410 cur_expr
->hash
= hash
;
411 cur_expr
->avail_occr
= NULL
;
413 slot
= expr_table
->find_slot_with_hash (cur_expr
, hash
, INSERT
);
417 /* The expression isn't found, so insert it. */
420 /* Anytime we add an entry to the table, record the index
421 of the new entry. The bitmap index starts counting
423 cur_expr
->bitmap_index
= expr_table
->elements () - 1;
427 /* The expression is already in the table, so roll back the
428 obstack and use the existing table entry. */
429 obstack_free (&expr_obstack
, cur_expr
);
433 /* Search for another occurrence in the same basic block. */
434 avail_occr
= cur_expr
->avail_occr
;
436 && BLOCK_FOR_INSN (avail_occr
->insn
) != BLOCK_FOR_INSN (insn
))
438 /* If an occurrence isn't found, save a pointer to the end of
440 last_occr
= avail_occr
;
441 avail_occr
= avail_occr
->next
;
445 /* Found another instance of the expression in the same basic block.
446 Prefer this occurrence to the currently recorded one. We want
447 the last one in the block and the block is scanned from start
449 avail_occr
->insn
= insn
;
452 /* First occurrence of this expression in this basic block. */
453 avail_occr
= (struct occr
*) obstack_alloc (&occr_obstack
,
454 sizeof (struct occr
));
456 /* First occurrence of this expression in any block? */
457 if (cur_expr
->avail_occr
== NULL
)
458 cur_expr
->avail_occr
= avail_occr
;
460 last_occr
->next
= avail_occr
;
462 avail_occr
->insn
= insn
;
463 avail_occr
->next
= NULL
;
464 avail_occr
->deleted_p
= 0;
469 /* Lookup pattern PAT in the expression hash table.
470 The result is a pointer to the table entry, or NULL if not found. */
473 lookup_expr_in_table (rtx pat
)
476 struct expr
**slot
, *tmp_expr
;
477 hashval_t hash
= hash_expr (pat
, &do_not_record_p
);
482 tmp_expr
= (struct expr
*) obstack_alloc (&expr_obstack
,
483 sizeof (struct expr
));
484 tmp_expr
->expr
= pat
;
485 tmp_expr
->hash
= hash
;
486 tmp_expr
->avail_occr
= NULL
;
488 slot
= expr_table
->find_slot_with_hash (tmp_expr
, hash
, INSERT
);
489 obstack_free (&expr_obstack
, tmp_expr
);
498 /* Dump all expressions and occurrences that are currently in the
499 expression hash table to FILE. */
501 /* This helper is called via htab_traverse. */
503 dump_expr_hash_table_entry (expr
**slot
, FILE *file
)
505 struct expr
*exprs
= *slot
;
508 fprintf (file
, "expr: ");
509 print_rtl (file
, exprs
->expr
);
510 fprintf (file
,"\nhashcode: %u\n", exprs
->hash
);
511 fprintf (file
,"list of occurrences:\n");
512 occr
= exprs
->avail_occr
;
515 rtx_insn
*insn
= occr
->insn
;
516 print_rtl_single (file
, insn
);
517 fprintf (file
, "\n");
520 fprintf (file
, "\n");
525 dump_hash_table (FILE *file
)
527 fprintf (file
, "\n\nexpression hash table\n");
528 fprintf (file
, "size %ld, %ld elements, %f collision/search ratio\n",
529 (long) expr_table
->size (),
530 (long) expr_table
->elements (),
531 expr_table
->collisions ());
532 if (expr_table
->elements () > 0)
534 fprintf (file
, "\n\ntable entries:\n");
535 expr_table
->traverse
<FILE *, dump_expr_hash_table_entry
> (file
);
537 fprintf (file
, "\n");
540 /* Return true if register X is recorded as being set by an instruction
541 whose CUID is greater than the one given. */
544 reg_changed_after_insn_p (rtx x
, int cuid
)
546 unsigned int regno
, end_regno
;
549 end_regno
= END_REGNO (x
);
551 if (reg_avail_info
[regno
] > cuid
)
553 while (++regno
< end_regno
);
557 /* Return nonzero if the operands of expression X are unchanged
558 1) from the start of INSN's basic block up to but not including INSN
559 if AFTER_INSN is false, or
560 2) from INSN to the end of INSN's basic block if AFTER_INSN is true. */
563 oprs_unchanged_p (rtx x
, rtx_insn
*insn
, bool after_insn
)
576 /* We are called after register allocation. */
577 gcc_assert (REGNO (x
) < FIRST_PSEUDO_REGISTER
);
579 return !reg_changed_after_insn_p (x
, INSN_CUID (insn
) - 1);
581 return !reg_changed_after_insn_p (x
, 0);
584 if (load_killed_in_block_p (INSN_CUID (insn
), x
, after_insn
))
587 return oprs_unchanged_p (XEXP (x
, 0), insn
, after_insn
);
613 for (i
= GET_RTX_LENGTH (code
) - 1, fmt
= GET_RTX_FORMAT (code
); i
>= 0; i
--)
617 if (! oprs_unchanged_p (XEXP (x
, i
), insn
, after_insn
))
620 else if (fmt
[i
] == 'E')
621 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
622 if (! oprs_unchanged_p (XVECEXP (x
, i
, j
), insn
, after_insn
))
630 /* Used for communication between find_mem_conflicts and
631 load_killed_in_block_p. Nonzero if find_mem_conflicts finds a
632 conflict between two memory references.
633 This is a bit of a hack to work around the limitations of note_stores. */
634 static int mems_conflict_p
;
636 /* DEST is the output of an instruction. If it is a memory reference, and
637 possibly conflicts with the load found in DATA, then set mems_conflict_p
638 to a nonzero value. */
641 find_mem_conflicts (rtx dest
, const_rtx setter ATTRIBUTE_UNUSED
,
644 rtx mem_op
= (rtx
) data
;
646 while (GET_CODE (dest
) == SUBREG
647 || GET_CODE (dest
) == ZERO_EXTRACT
648 || GET_CODE (dest
) == STRICT_LOW_PART
)
649 dest
= XEXP (dest
, 0);
651 /* If DEST is not a MEM, then it will not conflict with the load. Note
652 that function calls are assumed to clobber memory, but are handled
657 if (true_dependence (dest
, GET_MODE (dest
), mem_op
))
662 /* Return nonzero if the expression in X (a memory reference) is killed
663 in the current basic block before (if AFTER_INSN is false) or after
664 (if AFTER_INSN is true) the insn with the CUID in UID_LIMIT.
666 This function assumes that the modifies_mem table is flushed when
667 the hash table construction or redundancy elimination phases start
668 processing a new basic block. */
671 load_killed_in_block_p (int uid_limit
, rtx x
, bool after_insn
)
673 struct modifies_mem
*list_entry
= modifies_mem_list
;
677 rtx_insn
*setter
= list_entry
->insn
;
679 /* Ignore entries in the list that do not apply. */
681 && INSN_CUID (setter
) < uid_limit
)
683 && INSN_CUID (setter
) > uid_limit
))
685 list_entry
= list_entry
->next
;
689 /* If SETTER is a call everything is clobbered. Note that calls
690 to pure functions are never put on the list, so we need not
695 /* SETTER must be an insn of some kind that sets memory. Call
696 note_stores to examine each hunk of memory that is modified.
697 It will set mems_conflict_p to nonzero if there may be a
698 conflict between X and SETTER. */
700 note_stores (PATTERN (setter
), find_mem_conflicts
, x
);
704 list_entry
= list_entry
->next
;
710 /* Record register first/last/block set information for REGNO in INSN. */
713 record_last_reg_set_info (rtx_insn
*insn
, rtx reg
)
715 unsigned int regno
, end_regno
;
718 end_regno
= END_REGNO (reg
);
720 reg_avail_info
[regno
] = INSN_CUID (insn
);
721 while (++regno
< end_regno
);
725 record_last_reg_set_info_regno (rtx_insn
*insn
, int regno
)
727 reg_avail_info
[regno
] = INSN_CUID (insn
);
731 /* Record memory modification information for INSN. We do not actually care
732 about the memory location(s) that are set, or even how they are set (consider
733 a CALL_INSN). We merely need to record which insns modify memory. */
736 record_last_mem_set_info (rtx_insn
*insn
)
738 struct modifies_mem
*list_entry
;
740 list_entry
= (struct modifies_mem
*) obstack_alloc (&modifies_mem_obstack
,
741 sizeof (struct modifies_mem
));
742 list_entry
->insn
= insn
;
743 list_entry
->next
= modifies_mem_list
;
744 modifies_mem_list
= list_entry
;
746 record_last_mem_set_info_common (insn
, modify_mem_list
,
747 canon_modify_mem_list
,
752 /* Called from compute_hash_table via note_stores to handle one
753 SET or CLOBBER in an insn. DATA is really the instruction in which
754 the SET is taking place. */
757 record_last_set_info (rtx dest
, const_rtx setter ATTRIBUTE_UNUSED
, void *data
)
759 rtx_insn
*last_set_insn
= (rtx_insn
*) data
;
761 if (GET_CODE (dest
) == SUBREG
)
762 dest
= SUBREG_REG (dest
);
765 record_last_reg_set_info (last_set_insn
, dest
);
766 else if (MEM_P (dest
))
768 /* Ignore pushes, they don't clobber memory. They may still
769 clobber the stack pointer though. Some targets do argument
770 pushes without adding REG_INC notes. See e.g. PR25196,
771 where a pushsi2 on i386 doesn't have REG_INC notes. Note
772 such changes here too. */
773 if (! push_operand (dest
, GET_MODE (dest
)))
774 record_last_mem_set_info (last_set_insn
);
776 record_last_reg_set_info_regno (last_set_insn
, STACK_POINTER_REGNUM
);
781 /* Reset tables used to keep track of what's still available since the
782 start of the block. */
785 reset_opr_set_tables (void)
787 memset (reg_avail_info
, 0, FIRST_PSEUDO_REGISTER
* sizeof (int));
788 obstack_free (&modifies_mem_obstack
, modifies_mem_obstack_bottom
);
789 modifies_mem_list
= NULL
;
793 /* Record things set by INSN.
794 This data is used by oprs_unchanged_p. */
797 record_opr_changes (rtx_insn
*insn
)
801 /* Find all stores and record them. */
802 note_stores (PATTERN (insn
), record_last_set_info
, insn
);
804 /* Also record autoincremented REGs for this insn as changed. */
805 for (note
= REG_NOTES (insn
); note
; note
= XEXP (note
, 1))
806 if (REG_NOTE_KIND (note
) == REG_INC
)
807 record_last_reg_set_info (insn
, XEXP (note
, 0));
809 /* Finally, if this is a call, record all call clobbers. */
814 hard_reg_set_iterator hrsi
;
815 EXECUTE_IF_SET_IN_HARD_REG_SET (regs_invalidated_by_call
, 0, regno
, hrsi
)
816 record_last_reg_set_info_regno (insn
, regno
);
818 for (link
= CALL_INSN_FUNCTION_USAGE (insn
); link
; link
= XEXP (link
, 1))
819 if (GET_CODE (XEXP (link
, 0)) == CLOBBER
)
821 x
= XEXP (XEXP (link
, 0), 0);
824 gcc_assert (HARD_REGISTER_P (x
));
825 record_last_reg_set_info (insn
, x
);
829 if (! RTL_CONST_OR_PURE_CALL_P (insn
))
830 record_last_mem_set_info (insn
);
835 /* Scan the pattern of INSN and add an entry to the hash TABLE.
836 After reload we are interested in loads/stores only. */
839 hash_scan_set (rtx_insn
*insn
)
841 rtx pat
= PATTERN (insn
);
842 rtx src
= SET_SRC (pat
);
843 rtx dest
= SET_DEST (pat
);
845 /* We are only interested in loads and stores. */
846 if (! MEM_P (src
) && ! MEM_P (dest
))
849 /* Don't mess with jumps and nops. */
850 if (JUMP_P (insn
) || set_noop_p (pat
))
855 if (/* Don't CSE something if we can't do a reg/reg copy. */
856 can_copy_p (GET_MODE (dest
))
857 /* Is SET_SRC something we want to gcse? */
858 && general_operand (src
, GET_MODE (src
))
860 /* Never consider insns touching the register stack. It may
861 create situations that reg-stack cannot handle (e.g. a stack
862 register live across an abnormal edge). */
863 && (REGNO (dest
) < FIRST_STACK_REG
|| REGNO (dest
) > LAST_STACK_REG
)
865 /* An expression is not available if its operands are
866 subsequently modified, including this insn. */
867 && oprs_unchanged_p (src
, insn
, true))
869 insert_expr_in_table (src
, insn
);
872 else if (REG_P (src
))
874 /* Only record sets of pseudo-regs in the hash table. */
875 if (/* Don't CSE something if we can't do a reg/reg copy. */
876 can_copy_p (GET_MODE (src
))
877 /* Is SET_DEST something we want to gcse? */
878 && general_operand (dest
, GET_MODE (dest
))
880 /* As above for STACK_REGS. */
881 && (REGNO (src
) < FIRST_STACK_REG
|| REGNO (src
) > LAST_STACK_REG
)
883 && ! (flag_float_store
&& FLOAT_MODE_P (GET_MODE (dest
)))
884 /* Check if the memory expression is killed after insn. */
885 && ! load_killed_in_block_p (INSN_CUID (insn
) + 1, dest
, true)
886 && oprs_unchanged_p (XEXP (dest
, 0), insn
, true))
888 insert_expr_in_table (dest
, insn
);
894 /* Create hash table of memory expressions available at end of basic
895 blocks. Basically you should think of this hash table as the
896 representation of AVAIL_OUT. This is the set of expressions that
897 is generated in a basic block and not killed before the end of the
898 same basic block. Notice that this is really a local computation. */
901 compute_hash_table (void)
905 FOR_EACH_BB_FN (bb
, cfun
)
909 /* First pass over the instructions records information used to
910 determine when registers and memory are last set.
911 Since we compute a "local" AVAIL_OUT, reset the tables that
912 help us keep track of what has been modified since the start
914 reset_opr_set_tables ();
915 FOR_BB_INSNS (bb
, insn
)
918 record_opr_changes (insn
);
921 /* The next pass actually builds the hash table. */
922 FOR_BB_INSNS (bb
, insn
)
923 if (INSN_P (insn
) && GET_CODE (PATTERN (insn
)) == SET
)
924 hash_scan_set (insn
);
929 /* Check if register REG is killed in any insn waiting to be inserted on
930 edge E. This function is required to check that our data flow analysis
931 is still valid prior to commit_edge_insertions. */
934 reg_killed_on_edge (rtx reg
, edge e
)
938 for (insn
= e
->insns
.r
; insn
; insn
= NEXT_INSN (insn
))
939 if (INSN_P (insn
) && reg_set_p (reg
, insn
))
945 /* Similar to above - check if register REG is used in any insn waiting
946 to be inserted on edge E.
947 Assumes no such insn can be a CALL_INSN; if so call reg_used_between_p
948 with PREV(insn),NEXT(insn) instead of calling reg_overlap_mentioned_p. */
951 reg_used_on_edge (rtx reg
, edge e
)
955 for (insn
= e
->insns
.r
; insn
; insn
= NEXT_INSN (insn
))
956 if (INSN_P (insn
) && reg_overlap_mentioned_p (reg
, PATTERN (insn
)))
962 /* Return the loaded/stored register of a load/store instruction. */
965 get_avail_load_store_reg (rtx_insn
*insn
)
967 if (REG_P (SET_DEST (PATTERN (insn
))))
969 return SET_DEST (PATTERN (insn
));
973 gcc_assert (REG_P (SET_SRC (PATTERN (insn
))));
974 return SET_SRC (PATTERN (insn
));
978 /* Return nonzero if the predecessors of BB are "well behaved". */
981 bb_has_well_behaved_predecessors (basic_block bb
)
986 if (EDGE_COUNT (bb
->preds
) == 0)
989 FOR_EACH_EDGE (pred
, ei
, bb
->preds
)
991 if ((pred
->flags
& EDGE_ABNORMAL
) && EDGE_CRITICAL_P (pred
))
994 if ((pred
->flags
& EDGE_ABNORMAL_CALL
) && cfun
->has_nonlocal_label
)
997 if (tablejump_p (BB_END (pred
->src
), NULL
, NULL
))
1004 /* Search for the occurrences of expression in BB. */
1007 get_bb_avail_insn (basic_block bb
, struct occr
*orig_occr
, int bitmap_index
)
1009 struct occr
*occr
= orig_occr
;
1011 for (; occr
!= NULL
; occr
= occr
->next
)
1012 if (BLOCK_FOR_INSN (occr
->insn
) == bb
)
1015 /* If we could not find an occurrence in BB, see if BB
1016 has a single predecessor with an occurrence that is
1017 transparent through BB. */
1018 if (single_pred_p (bb
)
1019 && bitmap_bit_p (transp
[bb
->index
], bitmap_index
)
1020 && (occr
= get_bb_avail_insn (single_pred (bb
), orig_occr
, bitmap_index
)))
1022 rtx avail_reg
= get_avail_load_store_reg (occr
->insn
);
1023 if (!reg_set_between_p (avail_reg
,
1024 PREV_INSN (BB_HEAD (bb
)),
1025 NEXT_INSN (BB_END (bb
)))
1026 && !reg_killed_on_edge (avail_reg
, single_pred_edge (bb
)))
1034 /* This helper is called via htab_traverse. */
1036 compute_expr_transp (expr
**slot
, FILE *dump_file ATTRIBUTE_UNUSED
)
1038 struct expr
*expr
= *slot
;
1040 compute_transp (expr
->expr
, expr
->bitmap_index
, transp
,
1041 blocks_with_calls
, modify_mem_list_set
,
1042 canon_modify_mem_list
);
1046 /* This handles the case where several stores feed a partially redundant
1047 load. It checks if the redundancy elimination is possible and if it's
1050 Redundancy elimination is possible if,
1051 1) None of the operands of an insn have been modified since the start
1052 of the current basic block.
1053 2) In any predecessor of the current basic block, the same expression
1056 See the function body for the heuristics that determine if eliminating
1057 a redundancy is also worth doing, assuming it is possible. */
1060 eliminate_partially_redundant_load (basic_block bb
, rtx_insn
*insn
,
1064 rtx_insn
*avail_insn
= NULL
;
1067 struct occr
*a_occr
;
1068 struct unoccr
*occr
, *avail_occrs
= NULL
;
1069 struct unoccr
*unoccr
, *unavail_occrs
= NULL
, *rollback_unoccr
= NULL
;
1071 gcov_type ok_count
= 0; /* Redundant load execution count. */
1072 gcov_type critical_count
= 0; /* Execution count of critical edges. */
1074 bool critical_edge_split
= false;
1076 /* The execution count of the loads to be added to make the
1077 load fully redundant. */
1078 gcov_type not_ok_count
= 0;
1079 basic_block pred_bb
;
1081 pat
= PATTERN (insn
);
1082 dest
= SET_DEST (pat
);
1084 /* Check that the loaded register is not used, set, or killed from the
1085 beginning of the block. */
1086 if (reg_changed_after_insn_p (dest
, 0)
1087 || reg_used_between_p (dest
, PREV_INSN (BB_HEAD (bb
)), insn
))
1090 /* Check potential for replacing load with copy for predecessors. */
1091 FOR_EACH_EDGE (pred
, ei
, bb
->preds
)
1093 rtx_insn
*next_pred_bb_end
;
1096 avail_reg
= NULL_RTX
;
1097 pred_bb
= pred
->src
;
1098 for (a_occr
= get_bb_avail_insn (pred_bb
,
1100 expr
->bitmap_index
);
1102 a_occr
= get_bb_avail_insn (pred_bb
,
1104 expr
->bitmap_index
))
1106 /* Check if the loaded register is not used. */
1107 avail_insn
= a_occr
->insn
;
1108 avail_reg
= get_avail_load_store_reg (avail_insn
);
1109 gcc_assert (avail_reg
);
1111 /* Make sure we can generate a move from register avail_reg to
1113 rtx_insn
*move
= gen_move_insn (copy_rtx (dest
),
1114 copy_rtx (avail_reg
));
1115 extract_insn (move
);
1116 if (! constrain_operands (1, get_preferred_alternatives (insn
,
1118 || reg_killed_on_edge (avail_reg
, pred
)
1119 || reg_used_on_edge (dest
, pred
))
1124 next_pred_bb_end
= NEXT_INSN (BB_END (BLOCK_FOR_INSN (avail_insn
)));
1125 if (!reg_set_between_p (avail_reg
, avail_insn
, next_pred_bb_end
))
1126 /* AVAIL_INSN remains non-null. */
1132 if (EDGE_CRITICAL_P (pred
))
1133 critical_count
+= pred
->count
;
1135 if (avail_insn
!= NULL_RTX
)
1138 ok_count
+= pred
->count
;
1139 if (! set_noop_p (PATTERN (gen_move_insn (copy_rtx (dest
),
1140 copy_rtx (avail_reg
)))))
1142 /* Check if there is going to be a split. */
1143 if (EDGE_CRITICAL_P (pred
))
1144 critical_edge_split
= true;
1146 else /* Its a dead move no need to generate. */
1148 occr
= (struct unoccr
*) obstack_alloc (&unoccr_obstack
,
1149 sizeof (struct unoccr
));
1150 occr
->insn
= avail_insn
;
1152 occr
->next
= avail_occrs
;
1154 if (! rollback_unoccr
)
1155 rollback_unoccr
= occr
;
1159 /* Adding a load on a critical edge will cause a split. */
1160 if (EDGE_CRITICAL_P (pred
))
1161 critical_edge_split
= true;
1162 not_ok_count
+= pred
->count
;
1163 unoccr
= (struct unoccr
*) obstack_alloc (&unoccr_obstack
,
1164 sizeof (struct unoccr
));
1165 unoccr
->insn
= NULL
;
1166 unoccr
->pred
= pred
;
1167 unoccr
->next
= unavail_occrs
;
1168 unavail_occrs
= unoccr
;
1169 if (! rollback_unoccr
)
1170 rollback_unoccr
= unoccr
;
1174 if (/* No load can be replaced by copy. */
1176 /* Prevent exploding the code. */
1177 || (optimize_bb_for_size_p (bb
) && npred_ok
> 1)
1178 /* If we don't have profile information we cannot tell if splitting
1179 a critical edge is profitable or not so don't do it. */
1180 || ((! profile_info
|| ! flag_branch_probabilities
1181 || targetm
.cannot_modify_jumps_p ())
1182 && critical_edge_split
))
1185 /* Check if it's worth applying the partial redundancy elimination. */
1186 if (ok_count
< GCSE_AFTER_RELOAD_PARTIAL_FRACTION
* not_ok_count
)
1188 if (ok_count
< GCSE_AFTER_RELOAD_CRITICAL_FRACTION
* critical_count
)
1191 /* Generate moves to the loaded register from where
1192 the memory is available. */
1193 for (occr
= avail_occrs
; occr
; occr
= occr
->next
)
1195 avail_insn
= occr
->insn
;
1197 /* Set avail_reg to be the register having the value of the
1199 avail_reg
= get_avail_load_store_reg (avail_insn
);
1200 gcc_assert (avail_reg
);
1202 insert_insn_on_edge (gen_move_insn (copy_rtx (dest
),
1203 copy_rtx (avail_reg
)),
1205 stats
.moves_inserted
++;
1209 "generating move from %d to %d on edge from %d to %d\n",
1216 /* Regenerate loads where the memory is unavailable. */
1217 for (unoccr
= unavail_occrs
; unoccr
; unoccr
= unoccr
->next
)
1219 pred
= unoccr
->pred
;
1220 insert_insn_on_edge (copy_insn (PATTERN (insn
)), pred
);
1221 stats
.copies_inserted
++;
1226 "generating on edge from %d to %d a copy of load: ",
1229 print_rtl (dump_file
, PATTERN (insn
));
1230 fprintf (dump_file
, "\n");
1234 /* Delete the insn if it is not available in this block and mark it
1235 for deletion if it is available. If insn is available it may help
1236 discover additional redundancies, so mark it for later deletion. */
1237 for (a_occr
= get_bb_avail_insn (bb
, expr
->avail_occr
, expr
->bitmap_index
);
1238 a_occr
&& (a_occr
->insn
!= insn
);
1239 a_occr
= get_bb_avail_insn (bb
, a_occr
->next
, expr
->bitmap_index
))
1244 stats
.insns_deleted
++;
1248 fprintf (dump_file
, "deleting insn:\n");
1249 print_rtl_single (dump_file
, insn
);
1250 fprintf (dump_file
, "\n");
1255 a_occr
->deleted_p
= 1;
1258 if (rollback_unoccr
)
1259 obstack_free (&unoccr_obstack
, rollback_unoccr
);
1262 /* Performing the redundancy elimination as described before. */
1265 eliminate_partially_redundant_loads (void)
1270 /* Note we start at block 1. */
1272 if (ENTRY_BLOCK_PTR_FOR_FN (cfun
)->next_bb
== EXIT_BLOCK_PTR_FOR_FN (cfun
))
1276 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->next_bb
->next_bb
,
1277 EXIT_BLOCK_PTR_FOR_FN (cfun
),
1280 /* Don't try anything on basic blocks with strange predecessors. */
1281 if (! bb_has_well_behaved_predecessors (bb
))
1284 /* Do not try anything on cold basic blocks. */
1285 if (optimize_bb_for_size_p (bb
))
1288 /* Reset the table of things changed since the start of the current
1290 reset_opr_set_tables ();
1292 /* Look at all insns in the current basic block and see if there are
1293 any loads in it that we can record. */
1294 FOR_BB_INSNS (bb
, insn
)
1296 /* Is it a load - of the form (set (reg) (mem))? */
1297 if (NONJUMP_INSN_P (insn
)
1298 && GET_CODE (PATTERN (insn
)) == SET
1299 && REG_P (SET_DEST (PATTERN (insn
)))
1300 && MEM_P (SET_SRC (PATTERN (insn
))))
1302 rtx pat
= PATTERN (insn
);
1303 rtx src
= SET_SRC (pat
);
1306 if (!MEM_VOLATILE_P (src
)
1307 && GET_MODE (src
) != BLKmode
1308 && general_operand (src
, GET_MODE (src
))
1309 /* Are the operands unchanged since the start of the
1311 && oprs_unchanged_p (src
, insn
, false)
1312 && !(cfun
->can_throw_non_call_exceptions
&& may_trap_p (src
))
1313 && !side_effects_p (src
)
1314 /* Is the expression recorded? */
1315 && (expr
= lookup_expr_in_table (src
)) != NULL
)
1317 /* We now have a load (insn) and an available memory at
1318 its BB start (expr). Try to remove the loads if it is
1320 eliminate_partially_redundant_load (bb
, insn
, expr
);
1324 /* Keep track of everything modified by this insn, so that we
1325 know what has been modified since the start of the current
1328 record_opr_changes (insn
);
1332 commit_edge_insertions ();
1335 /* Go over the expression hash table and delete insns that were
1336 marked for later deletion. */
1338 /* This helper is called via htab_traverse. */
1340 delete_redundant_insns_1 (expr
**slot
, void *data ATTRIBUTE_UNUSED
)
1342 struct expr
*exprs
= *slot
;
1345 for (occr
= exprs
->avail_occr
; occr
!= NULL
; occr
= occr
->next
)
1347 if (occr
->deleted_p
&& dbg_cnt (gcse2_delete
))
1349 delete_insn (occr
->insn
);
1350 stats
.insns_deleted
++;
1354 fprintf (dump_file
, "deleting insn:\n");
1355 print_rtl_single (dump_file
, occr
->insn
);
1356 fprintf (dump_file
, "\n");
1365 delete_redundant_insns (void)
1367 expr_table
->traverse
<void *, delete_redundant_insns_1
> (NULL
);
1369 fprintf (dump_file
, "\n");
1372 /* Main entry point of the GCSE after reload - clean some redundant loads
1376 gcse_after_reload_main (rtx f ATTRIBUTE_UNUSED
)
1379 memset (&stats
, 0, sizeof (stats
));
1381 /* Allocate memory for this pass.
1382 Also computes and initializes the insns' CUIDs. */
1385 /* We need alias analysis. */
1386 init_alias_analysis ();
1388 compute_hash_table ();
1391 dump_hash_table (dump_file
);
1393 if (expr_table
->elements () > 0)
1395 /* Knowing which MEMs are transparent through a block can signifiantly
1396 increase the number of redundant loads found. So compute transparency
1397 information for each memory expression in the hash table. */
1399 /* This can not be part of the normal allocation routine because
1400 we have to know the number of elements in the hash table. */
1401 transp
= sbitmap_vector_alloc (last_basic_block_for_fn (cfun
),
1402 expr_table
->elements ());
1403 bitmap_vector_ones (transp
, last_basic_block_for_fn (cfun
));
1404 expr_table
->traverse
<FILE *, compute_expr_transp
> (dump_file
);
1405 eliminate_partially_redundant_loads ();
1406 delete_redundant_insns ();
1407 sbitmap_vector_free (transp
);
1411 fprintf (dump_file
, "GCSE AFTER RELOAD stats:\n");
1412 fprintf (dump_file
, "copies inserted: %d\n", stats
.copies_inserted
);
1413 fprintf (dump_file
, "moves inserted: %d\n", stats
.moves_inserted
);
1414 fprintf (dump_file
, "insns deleted: %d\n", stats
.insns_deleted
);
1415 fprintf (dump_file
, "\n\n");
1418 statistics_counter_event (cfun
, "copies inserted",
1419 stats
.copies_inserted
);
1420 statistics_counter_event (cfun
, "moves inserted",
1421 stats
.moves_inserted
);
1422 statistics_counter_event (cfun
, "insns deleted",
1423 stats
.insns_deleted
);
1426 /* We are finished with alias. */
1427 end_alias_analysis ();
1435 rest_of_handle_gcse2 (void)
1437 gcse_after_reload_main (get_insns ());
1438 rebuild_jump_labels (get_insns ());
1444 const pass_data pass_data_gcse2
=
1446 RTL_PASS
, /* type */
1448 OPTGROUP_NONE
, /* optinfo_flags */
1449 TV_GCSE_AFTER_RELOAD
, /* tv_id */
1450 0, /* properties_required */
1451 0, /* properties_provided */
1452 0, /* properties_destroyed */
1453 0, /* todo_flags_start */
1454 0, /* todo_flags_finish */
1457 class pass_gcse2
: public rtl_opt_pass
1460 pass_gcse2 (gcc::context
*ctxt
)
1461 : rtl_opt_pass (pass_data_gcse2
, ctxt
)
1464 /* opt_pass methods: */
1465 virtual bool gate (function
*fun
)
1467 return (optimize
> 0 && flag_gcse_after_reload
1468 && optimize_function_for_speed_p (fun
));
1471 virtual unsigned int execute (function
*) { return rest_of_handle_gcse2 (); }
1473 }; // class pass_gcse2
1478 make_pass_gcse2 (gcc::context
*ctxt
)
1480 return new pass_gcse2 (ctxt
);