1 /* Post reload partially redundant load elimination
2 Copyright (C) 2004, 2005
3 Free Software Foundation, Inc.
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 2, 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 COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
24 #include "coretypes.h"
32 #include "hard-reg-set.h"
35 #include "insn-config.h"
37 #include "basic-block.h"
48 #include "tree-pass.h"
50 /* The following code implements gcse after reload, the purpose of this
51 pass is to cleanup redundant loads generated by reload and other
52 optimizations that come after gcse. It searches for simple inter-block
53 redundancies and tries to eliminate them by adding moves and loads
56 Perform partially redundant load elimination, try to eliminate redundant
57 loads created by the reload pass. We try to look for full or partial
58 redundant loads fed by one or more loads/stores in predecessor BBs,
59 and try adding loads to make them fully redundant. We also check if
60 it's worth adding loads to be able to delete the redundant load.
63 1. Build available expressions hash table:
64 For each load/store instruction, if the loaded/stored memory didn't
65 change until the end of the basic block add this memory expression to
67 2. Perform Redundancy elimination:
68 For each load instruction do the following:
69 perform partial redundancy elimination, check if it's worth adding
70 loads to make the load fully redundant. If so add loads and
71 register copies and delete the load.
72 3. Delete instructions made redundant in step 2.
75 If the loaded register is used/defined between load and some store,
76 look for some other free register between load and all its stores,
77 and replace the load with a copy from this register to the loaded
82 /* Keep statistics of this pass. */
90 /* We need to keep a hash table of expressions. The table entries are of
91 type 'struct expr', and for each expression there is a single linked
92 list of occurrences. */
94 /* The table itself. */
95 static htab_t expr_table;
97 /* Expression elements in the hash table. */
100 /* The expression (SET_SRC for expressions, PATTERN for assignments). */
103 /* The same hash for this entry. */
106 /* List of available occurrence in basic blocks in the function. */
107 struct occr *avail_occr;
110 static struct obstack expr_obstack;
112 /* Occurrence of an expression.
113 There is at most one occurrence per basic block. If a pattern appears
114 more than once, the last appearance is used. */
118 /* Next occurrence of this expression. */
120 /* The insn that computes the expression. */
122 /* Nonzero if this [anticipatable] occurrence has been deleted. */
126 static struct obstack occr_obstack;
128 /* The following structure holds the information about the occurrences of
129 the redundant instructions. */
137 static struct obstack unoccr_obstack;
139 /* Array where each element is the CUID if the insn that last set the hard
140 register with the number of the element, since the start of the current
143 This array is used during the building of the hash table (step 1) to
144 determine if a reg is killed before the end of a basic block.
146 It is also used when eliminating partial redundancies (step 2) to see
147 if a reg was modified since the start of a basic block. */
148 static int *reg_avail_info;
150 /* A list of insns that may modify memory within the current basic block. */
154 struct modifies_mem *next;
156 static struct modifies_mem *modifies_mem_list;
158 /* The modifies_mem structs also go on an obstack, only this obstack is
159 freed each time after completing the analysis or transformations on
160 a basic block. So we allocate a dummy modifies_mem_obstack_bottom
161 object on the obstack to keep track of the bottom of the obstack. */
162 static struct obstack modifies_mem_obstack;
163 static struct modifies_mem *modifies_mem_obstack_bottom;
165 /* Mapping of insn UIDs to CUIDs.
166 CUIDs are like UIDs except they increase monotonically in each basic
167 block, have no gaps, and only apply to real insns. */
168 static int *uid_cuid;
169 #define INSN_CUID(INSN) (uid_cuid[INSN_UID (INSN)])
172 /* Helpers for memory allocation/freeing. */
173 static void alloc_mem (void);
174 static void free_mem (void);
176 /* Support for hash table construction and transformations. */
177 static bool oprs_unchanged_p (rtx, rtx, bool);
178 static void record_last_reg_set_info (rtx, int);
179 static void record_last_mem_set_info (rtx);
180 static void record_last_set_info (rtx, rtx, void *);
181 static void record_opr_changes (rtx);
183 static void find_mem_conflicts (rtx, rtx, void *);
184 static int load_killed_in_block_p (int, rtx, bool);
185 static void reset_opr_set_tables (void);
187 /* Hash table support. */
188 static hashval_t hash_expr (rtx, int *);
189 static hashval_t hash_expr_for_htab (const void *);
190 static int expr_equiv_p (const void *, const void *);
191 static void insert_expr_in_table (rtx, rtx);
192 static struct expr *lookup_expr_in_table (rtx);
193 static int dump_hash_table_entry (void **, void *);
194 static void dump_hash_table (FILE *);
196 /* Helpers for eliminate_partially_redundant_load. */
197 static bool reg_killed_on_edge (rtx, edge);
198 static bool reg_used_on_edge (rtx, edge);
200 static rtx get_avail_load_store_reg (rtx);
202 static bool bb_has_well_behaved_predecessors (basic_block);
203 static struct occr* get_bb_avail_insn (basic_block, struct occr *);
204 static void hash_scan_set (rtx);
205 static void compute_hash_table (void);
207 /* The work horses of this pass. */
208 static void eliminate_partially_redundant_load (basic_block,
211 static void eliminate_partially_redundant_loads (void);
214 /* Allocate memory for the CUID mapping array and register/memory
224 /* Find the largest UID and create a mapping from UIDs to CUIDs. */
225 uid_cuid = XCNEWVEC (int, get_max_uid () + 1);
228 FOR_BB_INSNS (bb, insn)
231 uid_cuid[INSN_UID (insn)] = i++;
233 uid_cuid[INSN_UID (insn)] = i;
236 /* Allocate the available expressions hash table. We don't want to
237 make the hash table too small, but unnecessarily making it too large
238 also doesn't help. The i/4 is a gcse.c relic, and seems like a
239 reasonable choice. */
240 expr_table = htab_create (MAX (i / 4, 13),
241 hash_expr_for_htab, expr_equiv_p, NULL);
243 /* We allocate everything on obstacks because we often can roll back
244 the whole obstack to some point. Freeing obstacks is very fast. */
245 gcc_obstack_init (&expr_obstack);
246 gcc_obstack_init (&occr_obstack);
247 gcc_obstack_init (&unoccr_obstack);
248 gcc_obstack_init (&modifies_mem_obstack);
250 /* Working array used to track the last set for each register
251 in the current block. */
252 reg_avail_info = (int *) xmalloc (FIRST_PSEUDO_REGISTER * sizeof (int));
254 /* Put a dummy modifies_mem object on the modifies_mem_obstack, so we
255 can roll it back in reset_opr_set_tables. */
256 modifies_mem_obstack_bottom =
257 (struct modifies_mem *) obstack_alloc (&modifies_mem_obstack,
258 sizeof (struct modifies_mem));
261 /* Free memory allocated by alloc_mem. */
268 htab_delete (expr_table);
270 obstack_free (&expr_obstack, NULL);
271 obstack_free (&occr_obstack, NULL);
272 obstack_free (&unoccr_obstack, NULL);
273 obstack_free (&modifies_mem_obstack, NULL);
275 free (reg_avail_info);
279 /* Hash expression X.
280 DO_NOT_RECORD_P is a boolean indicating if a volatile operand is found
281 or if the expression contains something we don't want to insert in the
285 hash_expr (rtx x, int *do_not_record_p)
287 *do_not_record_p = 0;
288 return hash_rtx (x, GET_MODE (x), do_not_record_p,
289 NULL, /*have_reg_qty=*/false);
292 /* Callback for hashtab.
293 Return the hash value for expression EXP. We don't actually hash
294 here, we just return the cached hash value. */
297 hash_expr_for_htab (const void *expp)
299 struct expr *exp = (struct expr *) expp;
303 /* Callback for hashtab.
304 Return nonzero if exp1 is equivalent to exp2. */
307 expr_equiv_p (const void *exp1p, const void *exp2p)
309 struct expr *exp1 = (struct expr *) exp1p;
310 struct expr *exp2 = (struct expr *) exp2p;
311 int equiv_p = exp_equiv_p (exp1->expr, exp2->expr, 0, true);
313 gcc_assert (!equiv_p || exp1->hash == exp2->hash);
318 /* Insert expression X in INSN in the hash TABLE.
319 If it is already present, record it as the last occurrence in INSN's
323 insert_expr_in_table (rtx x, rtx insn)
327 struct expr *cur_expr, **slot;
328 struct occr *avail_occr, *last_occr = NULL;
330 hash = hash_expr (x, &do_not_record_p);
332 /* Do not insert expression in the table if it contains volatile operands,
333 or if hash_expr determines the expression is something we don't want
334 to or can't handle. */
338 /* We anticipate that redundant expressions are rare, so for convenience
339 allocate a new hash table element here already and set its fields.
340 If we don't do this, we need a hack with a static struct expr. Anyway,
341 obstack_free is really fast and one more obstack_alloc doesn't hurt if
342 we're going to see more expressions later on. */
343 cur_expr = (struct expr *) obstack_alloc (&expr_obstack,
344 sizeof (struct expr));
346 cur_expr->hash = hash;
347 cur_expr->avail_occr = NULL;
349 slot = (struct expr **) htab_find_slot_with_hash (expr_table, cur_expr,
353 /* The expression isn't found, so insert it. */
357 /* The expression is already in the table, so roll back the
358 obstack and use the existing table entry. */
359 obstack_free (&expr_obstack, cur_expr);
363 /* Search for another occurrence in the same basic block. */
364 avail_occr = cur_expr->avail_occr;
365 while (avail_occr && BLOCK_NUM (avail_occr->insn) != BLOCK_NUM (insn))
367 /* If an occurrence isn't found, save a pointer to the end of
369 last_occr = avail_occr;
370 avail_occr = avail_occr->next;
374 /* Found another instance of the expression in the same basic block.
375 Prefer this occurrence to the currently recorded one. We want
376 the last one in the block and the block is scanned from start
378 avail_occr->insn = insn;
381 /* First occurrence of this expression in this basic block. */
382 avail_occr = (struct occr *) obstack_alloc (&occr_obstack,
383 sizeof (struct occr));
385 /* First occurrence of this expression in any block? */
386 if (cur_expr->avail_occr == NULL)
387 cur_expr->avail_occr = avail_occr;
389 last_occr->next = avail_occr;
391 avail_occr->insn = insn;
392 avail_occr->next = NULL;
393 avail_occr->deleted_p = 0;
398 /* Lookup pattern PAT in the expression hash table.
399 The result is a pointer to the table entry, or NULL if not found. */
402 lookup_expr_in_table (rtx pat)
405 struct expr **slot, *tmp_expr;
406 hashval_t hash = hash_expr (pat, &do_not_record_p);
411 tmp_expr = (struct expr *) obstack_alloc (&expr_obstack,
412 sizeof (struct expr));
413 tmp_expr->expr = pat;
414 tmp_expr->hash = hash;
415 tmp_expr->avail_occr = NULL;
417 slot = (struct expr **) htab_find_slot_with_hash (expr_table, tmp_expr,
419 obstack_free (&expr_obstack, tmp_expr);
428 /* Dump all expressions and occurrences that are currently in the
429 expression hash table to FILE. */
431 /* This helper is called via htab_traverse. */
433 dump_hash_table_entry (void **slot, void *filep)
435 struct expr *expr = (struct expr *) *slot;
436 FILE *file = (FILE *) filep;
439 fprintf (file, "expr: ");
440 print_rtl (file, expr->expr);
441 fprintf (file,"\nhashcode: %u\n", expr->hash);
442 fprintf (file,"list of occurrences:\n");
443 occr = expr->avail_occr;
446 rtx insn = occr->insn;
447 print_rtl_single (file, insn);
448 fprintf (file, "\n");
451 fprintf (file, "\n");
456 dump_hash_table (FILE *file)
458 fprintf (file, "\n\nexpression hash table\n");
459 fprintf (file, "size %ld, %ld elements, %f collision/search ratio\n",
460 (long) htab_size (expr_table),
461 (long) htab_elements (expr_table),
462 htab_collisions (expr_table));
463 if (htab_elements (expr_table) > 0)
465 fprintf (file, "\n\ntable entries:\n");
466 htab_traverse (expr_table, dump_hash_table_entry, file);
468 fprintf (file, "\n");
471 /* Return true if register X is recorded as being set by an instruction
472 whose CUID is greater than the one given. */
475 reg_changed_after_insn_p (rtx x, int cuid)
477 unsigned int regno, end_regno;
480 end_regno = END_HARD_REGNO (x);
482 if (reg_avail_info[regno] > cuid)
484 while (++regno < end_regno);
488 /* Return nonzero if the operands of expression X are unchanged
489 1) from the start of INSN's basic block up to but not including INSN
490 if AFTER_INSN is false, or
491 2) from INSN to the end of INSN's basic block if AFTER_INSN is true. */
494 oprs_unchanged_p (rtx x, rtx insn, bool after_insn)
507 /* We are called after register allocation. */
508 gcc_assert (REGNO (x) < FIRST_PSEUDO_REGISTER);
510 return !reg_changed_after_insn_p (x, INSN_CUID (insn) - 1);
512 return !reg_changed_after_insn_p (x, 0);
515 if (load_killed_in_block_p (INSN_CUID (insn), x, after_insn))
518 return oprs_unchanged_p (XEXP (x, 0), insn, after_insn);
546 for (i = GET_RTX_LENGTH (code) - 1, fmt = GET_RTX_FORMAT (code); i >= 0; i--)
550 if (! oprs_unchanged_p (XEXP (x, i), insn, after_insn))
553 else if (fmt[i] == 'E')
554 for (j = 0; j < XVECLEN (x, i); j++)
555 if (! oprs_unchanged_p (XVECEXP (x, i, j), insn, after_insn))
563 /* Used for communication between find_mem_conflicts and
564 load_killed_in_block_p. Nonzero if find_mem_conflicts finds a
565 conflict between two memory references.
566 This is a bit of a hack to work around the limitations of note_stores. */
567 static int mems_conflict_p;
569 /* DEST is the output of an instruction. If it is a memory reference, and
570 possibly conflicts with the load found in DATA, then set mems_conflict_p
571 to a nonzero value. */
574 find_mem_conflicts (rtx dest, rtx setter ATTRIBUTE_UNUSED,
577 rtx mem_op = (rtx) data;
579 while (GET_CODE (dest) == SUBREG
580 || GET_CODE (dest) == ZERO_EXTRACT
581 || GET_CODE (dest) == STRICT_LOW_PART)
582 dest = XEXP (dest, 0);
584 /* If DEST is not a MEM, then it will not conflict with the load. Note
585 that function calls are assumed to clobber memory, but are handled
590 if (true_dependence (dest, GET_MODE (dest), mem_op,
596 /* Return nonzero if the expression in X (a memory reference) is killed
597 in the current basic block before (if AFTER_INSN is false) or after
598 (if AFTER_INSN is true) the insn with the CUID in UID_LIMIT.
600 This function assumes that the modifies_mem table is flushed when
601 the hash table construction or redundancy elimination phases start
602 processing a new basic block. */
605 load_killed_in_block_p (int uid_limit, rtx x, bool after_insn)
607 struct modifies_mem *list_entry = modifies_mem_list;
611 rtx setter = list_entry->insn;
613 /* Ignore entries in the list that do not apply. */
615 && INSN_CUID (setter) < uid_limit)
617 && INSN_CUID (setter) > uid_limit))
619 list_entry = list_entry->next;
623 /* If SETTER is a call everything is clobbered. Note that calls
624 to pure functions are never put on the list, so we need not
629 /* SETTER must be an insn of some kind that sets memory. Call
630 note_stores to examine each hunk of memory that is modified.
631 It will set mems_conflict_p to nonzero if there may be a
632 conflict between X and SETTER. */
634 note_stores (PATTERN (setter), find_mem_conflicts, x);
638 list_entry = list_entry->next;
644 /* Record register first/last/block set information for REGNO in INSN. */
647 record_last_reg_set_info (rtx insn, int regno)
649 reg_avail_info[regno] = INSN_CUID (insn);
653 /* Record memory modification information for INSN. We do not actually care
654 about the memory location(s) that are set, or even how they are set (consider
655 a CALL_INSN). We merely need to record which insns modify memory. */
658 record_last_mem_set_info (rtx insn)
660 struct modifies_mem *list_entry;
662 list_entry = (struct modifies_mem *) obstack_alloc (&modifies_mem_obstack,
663 sizeof (struct modifies_mem));
664 list_entry->insn = insn;
665 list_entry->next = modifies_mem_list;
666 modifies_mem_list = list_entry;
669 /* Called from compute_hash_table via note_stores to handle one
670 SET or CLOBBER in an insn. DATA is really the instruction in which
671 the SET is taking place. */
674 record_last_set_info (rtx dest, rtx setter ATTRIBUTE_UNUSED, void *data)
676 rtx last_set_insn = (rtx) data;
678 if (GET_CODE (dest) == SUBREG)
679 dest = SUBREG_REG (dest);
682 record_last_reg_set_info (last_set_insn, REGNO (dest));
683 else if (MEM_P (dest))
685 /* Ignore pushes, they don't clobber memory. They may still
686 clobber the stack pointer though. Some targets do argument
687 pushes without adding REG_INC notes. See e.g. PR25196,
688 where a pushsi2 on i386 doesn't have REG_INC notes. Note
689 such changes here too. */
690 if (! push_operand (dest, GET_MODE (dest)))
691 record_last_mem_set_info (last_set_insn);
693 record_last_reg_set_info (last_set_insn, STACK_POINTER_REGNUM);
698 /* Reset tables used to keep track of what's still available since the
699 start of the block. */
702 reset_opr_set_tables (void)
704 memset (reg_avail_info, 0, FIRST_PSEUDO_REGISTER * sizeof (int));
705 obstack_free (&modifies_mem_obstack, modifies_mem_obstack_bottom);
706 modifies_mem_list = NULL;
710 /* Record things set by INSN.
711 This data is used by oprs_unchanged_p. */
714 record_opr_changes (rtx insn)
718 /* Find all stores and record them. */
719 note_stores (PATTERN (insn), record_last_set_info, insn);
721 /* Also record autoincremented REGs for this insn as changed. */
722 for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
723 if (REG_NOTE_KIND (note) == REG_INC)
724 record_last_reg_set_info (insn, REGNO (XEXP (note, 0)));
726 /* Finally, if this is a call, record all call clobbers. */
729 unsigned int regno, end_regno;
732 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
733 if (TEST_HARD_REG_BIT (regs_invalidated_by_call, regno))
734 record_last_reg_set_info (insn, regno);
736 for (link = CALL_INSN_FUNCTION_USAGE (insn); link; link = XEXP (link, 1))
737 if (GET_CODE (XEXP (link, 0)) == CLOBBER)
739 x = XEXP (XEXP (link, 0), 0);
742 gcc_assert (HARD_REGISTER_P (x));
744 end_regno = END_HARD_REGNO (x);
746 record_last_reg_set_info (insn, regno);
747 while (++regno < end_regno);
751 if (! CONST_OR_PURE_CALL_P (insn))
752 record_last_mem_set_info (insn);
757 /* Scan the pattern of INSN and add an entry to the hash TABLE.
758 After reload we are interested in loads/stores only. */
761 hash_scan_set (rtx insn)
763 rtx pat = PATTERN (insn);
764 rtx src = SET_SRC (pat);
765 rtx dest = SET_DEST (pat);
767 /* We are only interested in loads and stores. */
768 if (! MEM_P (src) && ! MEM_P (dest))
771 /* Don't mess with jumps and nops. */
772 if (JUMP_P (insn) || set_noop_p (pat))
777 if (/* Don't CSE something if we can't do a reg/reg copy. */
778 can_copy_p (GET_MODE (dest))
779 /* Is SET_SRC something we want to gcse? */
780 && general_operand (src, GET_MODE (src))
782 /* Never consider insns touching the register stack. It may
783 create situations that reg-stack cannot handle (e.g. a stack
784 register live across an abnormal edge). */
785 && (REGNO (dest) < FIRST_STACK_REG || REGNO (dest) > LAST_STACK_REG)
787 /* An expression is not available if its operands are
788 subsequently modified, including this insn. */
789 && oprs_unchanged_p (src, insn, true))
791 insert_expr_in_table (src, insn);
794 else if (REG_P (src))
796 /* Only record sets of pseudo-regs in the hash table. */
797 if (/* Don't CSE something if we can't do a reg/reg copy. */
798 can_copy_p (GET_MODE (src))
799 /* Is SET_DEST something we want to gcse? */
800 && general_operand (dest, GET_MODE (dest))
802 /* As above for STACK_REGS. */
803 && (REGNO (src) < FIRST_STACK_REG || REGNO (src) > LAST_STACK_REG)
805 && ! (flag_float_store && FLOAT_MODE_P (GET_MODE (dest)))
806 /* Check if the memory expression is killed after insn. */
807 && ! load_killed_in_block_p (INSN_CUID (insn) + 1, dest, true)
808 && oprs_unchanged_p (XEXP (dest, 0), insn, true))
810 insert_expr_in_table (dest, insn);
816 /* Create hash table of memory expressions available at end of basic
817 blocks. Basically you should think of this hash table as the
818 representation of AVAIL_OUT. This is the set of expressions that
819 is generated in a basic block and not killed before the end of the
820 same basic block. Notice that this is really a local computation. */
823 compute_hash_table (void)
831 /* First pass over the instructions records information used to
832 determine when registers and memory are last set.
833 Since we compute a "local" AVAIL_OUT, reset the tables that
834 help us keep track of what has been modified since the start
836 reset_opr_set_tables ();
837 FOR_BB_INSNS (bb, insn)
840 record_opr_changes (insn);
843 /* The next pass actually builds the hash table. */
844 FOR_BB_INSNS (bb, insn)
845 if (INSN_P (insn) && GET_CODE (PATTERN (insn)) == SET)
846 hash_scan_set (insn);
851 /* Check if register REG is killed in any insn waiting to be inserted on
852 edge E. This function is required to check that our data flow analysis
853 is still valid prior to commit_edge_insertions. */
856 reg_killed_on_edge (rtx reg, edge e)
860 for (insn = e->insns.r; insn; insn = NEXT_INSN (insn))
861 if (INSN_P (insn) && reg_set_p (reg, insn))
867 /* Similar to above - check if register REG is used in any insn waiting
868 to be inserted on edge E.
869 Assumes no such insn can be a CALL_INSN; if so call reg_used_between_p
870 with PREV(insn),NEXT(insn) instead of calling reg_overlap_mentioned_p. */
873 reg_used_on_edge (rtx reg, edge e)
877 for (insn = e->insns.r; insn; insn = NEXT_INSN (insn))
878 if (INSN_P (insn) && reg_overlap_mentioned_p (reg, PATTERN (insn)))
884 /* Return the loaded/stored register of a load/store instruction. */
887 get_avail_load_store_reg (rtx insn)
889 if (REG_P (SET_DEST (PATTERN (insn))))
891 return SET_DEST(PATTERN(insn));
895 gcc_assert (REG_P (SET_SRC (PATTERN (insn))));
896 return SET_SRC (PATTERN (insn));
900 /* Return nonzero if the predecessors of BB are "well behaved". */
903 bb_has_well_behaved_predecessors (basic_block bb)
908 if (EDGE_COUNT (bb->preds) == 0)
911 FOR_EACH_EDGE (pred, ei, bb->preds)
913 if ((pred->flags & EDGE_ABNORMAL) && EDGE_CRITICAL_P (pred))
916 if (JUMP_TABLE_DATA_P (BB_END (pred->src)))
923 /* Search for the occurrences of expression in BB. */
926 get_bb_avail_insn (basic_block bb, struct occr *occr)
928 for (; occr != NULL; occr = occr->next)
929 if (BLOCK_FOR_INSN (occr->insn) == bb)
935 /* This handles the case where several stores feed a partially redundant
936 load. It checks if the redundancy elimination is possible and if it's
939 Redundancy elimination is possible if,
940 1) None of the operands of an insn have been modified since the start
941 of the current basic block.
942 2) In any predecessor of the current basic block, the same expression
945 See the function body for the heuristics that determine if eliminating
946 a redundancy is also worth doing, assuming it is possible. */
949 eliminate_partially_redundant_load (basic_block bb, rtx insn,
953 rtx avail_insn = NULL_RTX;
957 struct unoccr *occr, *avail_occrs = NULL;
958 struct unoccr *unoccr, *unavail_occrs = NULL, *rollback_unoccr = NULL;
960 gcov_type ok_count = 0; /* Redundant load execution count. */
961 gcov_type critical_count = 0; /* Execution count of critical edges. */
963 bool critical_edge_split = false;
965 /* The execution count of the loads to be added to make the
966 load fully redundant. */
967 gcov_type not_ok_count = 0;
970 pat = PATTERN (insn);
971 dest = SET_DEST (pat);
973 /* Check that the loaded register is not used, set, or killed from the
974 beginning of the block. */
975 if (reg_changed_after_insn_p (dest, 0)
976 || reg_used_between_p (dest, PREV_INSN (BB_HEAD (bb)), insn))
979 /* Check potential for replacing load with copy for predecessors. */
980 FOR_EACH_EDGE (pred, ei, bb->preds)
982 rtx next_pred_bb_end;
984 avail_insn = NULL_RTX;
985 avail_reg = NULL_RTX;
987 next_pred_bb_end = NEXT_INSN (BB_END (pred_bb));
988 for (a_occr = get_bb_avail_insn (pred_bb, expr->avail_occr); a_occr;
989 a_occr = get_bb_avail_insn (pred_bb, a_occr->next))
991 /* Check if the loaded register is not used. */
992 avail_insn = a_occr->insn;
993 avail_reg = get_avail_load_store_reg (avail_insn);
994 gcc_assert (avail_reg);
996 /* Make sure we can generate a move from register avail_reg to
998 extract_insn (gen_move_insn (copy_rtx (dest),
999 copy_rtx (avail_reg)));
1000 if (! constrain_operands (1)
1001 || reg_killed_on_edge (avail_reg, pred)
1002 || reg_used_on_edge (dest, pred))
1007 if (!reg_set_between_p (avail_reg, avail_insn, next_pred_bb_end))
1008 /* AVAIL_INSN remains non-null. */
1014 if (EDGE_CRITICAL_P (pred))
1015 critical_count += pred->count;
1017 if (avail_insn != NULL_RTX)
1020 ok_count += pred->count;
1021 if (! set_noop_p (PATTERN (gen_move_insn (copy_rtx (dest),
1022 copy_rtx (avail_reg)))))
1024 /* Check if there is going to be a split. */
1025 if (EDGE_CRITICAL_P (pred))
1026 critical_edge_split = true;
1028 else /* Its a dead move no need to generate. */
1030 occr = (struct unoccr *) obstack_alloc (&unoccr_obstack,
1031 sizeof (struct unoccr));
1032 occr->insn = avail_insn;
1034 occr->next = avail_occrs;
1036 if (! rollback_unoccr)
1037 rollback_unoccr = occr;
1041 /* Adding a load on a critical edge will cause a split. */
1042 if (EDGE_CRITICAL_P (pred))
1043 critical_edge_split = true;
1044 not_ok_count += pred->count;
1045 unoccr = (struct unoccr *) obstack_alloc (&unoccr_obstack,
1046 sizeof (struct unoccr));
1047 unoccr->insn = NULL_RTX;
1048 unoccr->pred = pred;
1049 unoccr->next = unavail_occrs;
1050 unavail_occrs = unoccr;
1051 if (! rollback_unoccr)
1052 rollback_unoccr = unoccr;
1056 if (/* No load can be replaced by copy. */
1058 /* Prevent exploding the code. */
1059 || (optimize_size && npred_ok > 1)
1060 /* If we don't have profile information we cannot tell if splitting
1061 a critical edge is profitable or not so don't do it. */
1062 || ((! profile_info || ! flag_branch_probabilities
1063 || targetm.cannot_modify_jumps_p ())
1064 && critical_edge_split))
1067 /* Check if it's worth applying the partial redundancy elimination. */
1068 if (ok_count < GCSE_AFTER_RELOAD_PARTIAL_FRACTION * not_ok_count)
1070 if (ok_count < GCSE_AFTER_RELOAD_CRITICAL_FRACTION * critical_count)
1073 /* Generate moves to the loaded register from where
1074 the memory is available. */
1075 for (occr = avail_occrs; occr; occr = occr->next)
1077 avail_insn = occr->insn;
1079 /* Set avail_reg to be the register having the value of the
1081 avail_reg = get_avail_load_store_reg (avail_insn);
1082 gcc_assert (avail_reg);
1084 insert_insn_on_edge (gen_move_insn (copy_rtx (dest),
1085 copy_rtx (avail_reg)),
1087 stats.moves_inserted++;
1091 "generating move from %d to %d on edge from %d to %d\n",
1098 /* Regenerate loads where the memory is unavailable. */
1099 for (unoccr = unavail_occrs; unoccr; unoccr = unoccr->next)
1101 pred = unoccr->pred;
1102 insert_insn_on_edge (copy_insn (PATTERN (insn)), pred);
1103 stats.copies_inserted++;
1108 "generating on edge from %d to %d a copy of load: ",
1111 print_rtl (dump_file, PATTERN (insn));
1112 fprintf (dump_file, "\n");
1116 /* Delete the insn if it is not available in this block and mark it
1117 for deletion if it is available. If insn is available it may help
1118 discover additional redundancies, so mark it for later deletion. */
1119 for (a_occr = get_bb_avail_insn (bb, expr->avail_occr);
1120 a_occr && (a_occr->insn != insn);
1121 a_occr = get_bb_avail_insn (bb, a_occr->next));
1125 stats.insns_deleted++;
1129 fprintf (dump_file, "deleting insn:\n");
1130 print_rtl_single (dump_file, insn);
1131 fprintf (dump_file, "\n");
1136 a_occr->deleted_p = 1;
1139 if (rollback_unoccr)
1140 obstack_free (&unoccr_obstack, rollback_unoccr);
1143 /* Performing the redundancy elimination as described before. */
1146 eliminate_partially_redundant_loads (void)
1151 /* Note we start at block 1. */
1153 if (ENTRY_BLOCK_PTR->next_bb == EXIT_BLOCK_PTR)
1157 ENTRY_BLOCK_PTR->next_bb->next_bb,
1161 /* Don't try anything on basic blocks with strange predecessors. */
1162 if (! bb_has_well_behaved_predecessors (bb))
1165 /* Do not try anything on cold basic blocks. */
1166 if (probably_cold_bb_p (bb))
1169 /* Reset the table of things changed since the start of the current
1171 reset_opr_set_tables ();
1173 /* Look at all insns in the current basic block and see if there are
1174 any loads in it that we can record. */
1175 FOR_BB_INSNS (bb, insn)
1177 /* Is it a load - of the form (set (reg) (mem))? */
1178 if (NONJUMP_INSN_P (insn)
1179 && GET_CODE (PATTERN (insn)) == SET
1180 && REG_P (SET_DEST (PATTERN (insn)))
1181 && MEM_P (SET_SRC (PATTERN (insn))))
1183 rtx pat = PATTERN (insn);
1184 rtx src = SET_SRC (pat);
1187 if (!MEM_VOLATILE_P (src)
1188 && GET_MODE (src) != BLKmode
1189 && general_operand (src, GET_MODE (src))
1190 /* Are the operands unchanged since the start of the
1192 && oprs_unchanged_p (src, insn, false)
1193 && !(flag_non_call_exceptions && may_trap_p (src))
1194 && !side_effects_p (src)
1195 /* Is the expression recorded? */
1196 && (expr = lookup_expr_in_table (src)) != NULL)
1198 /* We now have a load (insn) and an available memory at
1199 its BB start (expr). Try to remove the loads if it is
1201 eliminate_partially_redundant_load (bb, insn, expr);
1205 /* Keep track of everything modified by this insn, so that we
1206 know what has been modified since the start of the current
1209 record_opr_changes (insn);
1213 commit_edge_insertions ();
1216 /* Go over the expression hash table and delete insns that were
1217 marked for later deletion. */
1219 /* This helper is called via htab_traverse. */
1221 delete_redundant_insns_1 (void **slot, void *data ATTRIBUTE_UNUSED)
1223 struct expr *expr = (struct expr *) *slot;
1226 for (occr = expr->avail_occr; occr != NULL; occr = occr->next)
1228 if (occr->deleted_p)
1230 delete_insn (occr->insn);
1231 stats.insns_deleted++;
1235 fprintf (dump_file, "deleting insn:\n");
1236 print_rtl_single (dump_file, occr->insn);
1237 fprintf (dump_file, "\n");
1246 delete_redundant_insns (void)
1248 htab_traverse (expr_table, delete_redundant_insns_1, NULL);
1250 fprintf (dump_file, "\n");
1253 /* Main entry point of the GCSE after reload - clean some redundant loads
1257 gcse_after_reload_main (rtx f ATTRIBUTE_UNUSED)
1260 memset (&stats, 0, sizeof (stats));
1262 /* Allocate ememory for this pass.
1263 Also computes and initializes the insns' CUIDs. */
1266 /* We need alias analysis. */
1267 init_alias_analysis ();
1269 compute_hash_table ();
1272 dump_hash_table (dump_file);
1274 if (htab_elements (expr_table) > 0)
1276 eliminate_partially_redundant_loads ();
1277 delete_redundant_insns ();
1281 fprintf (dump_file, "GCSE AFTER RELOAD stats:\n");
1282 fprintf (dump_file, "copies inserted: %d\n", stats.copies_inserted);
1283 fprintf (dump_file, "moves inserted: %d\n", stats.moves_inserted);
1284 fprintf (dump_file, "insns deleted: %d\n", stats.insns_deleted);
1285 fprintf (dump_file, "\n\n");
1289 /* We are finished with alias. */
1290 end_alias_analysis ();
1297 gate_handle_gcse2 (void)
1299 return (optimize > 0 && flag_gcse_after_reload);
1304 rest_of_handle_gcse2 (void)
1306 gcse_after_reload_main (get_insns ());
1307 rebuild_jump_labels (get_insns ());
1308 delete_trivially_dead_insns (get_insns (), max_reg_num ());
1312 struct tree_opt_pass pass_gcse2 =
1315 gate_handle_gcse2, /* gate */
1316 rest_of_handle_gcse2, /* execute */
1319 0, /* static_pass_number */
1320 TV_GCSE_AFTER_RELOAD, /* tv_id */
1321 0, /* properties_required */
1322 0, /* properties_provided */
1323 0, /* properties_destroyed */
1324 0, /* todo_flags_start */
1326 TODO_verify_flow | TODO_ggc_collect, /* todo_flags_finish */