Daily bump.
[official-gcc.git] / gcc / postreload-gcse.c
blobaeffc14435eda175aac26a2b225abcdc0da66fed
1 /* Post reload partially redundant load elimination
2 Copyright (C) 2004-2013 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
9 version.
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
14 for more details.
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/>. */
20 #include "config.h"
21 #include "system.h"
22 #include "coretypes.h"
23 #include "tm.h"
24 #include "diagnostic-core.h"
26 #include "hash-table.h"
27 #include "rtl.h"
28 #include "tree.h"
29 #include "tm_p.h"
30 #include "regs.h"
31 #include "hard-reg-set.h"
32 #include "flags.h"
33 #include "insn-config.h"
34 #include "recog.h"
35 #include "basic-block.h"
36 #include "function.h"
37 #include "expr.h"
38 #include "except.h"
39 #include "intl.h"
40 #include "obstack.h"
41 #include "hashtab.h"
42 #include "params.h"
43 #include "target.h"
44 #include "tree-pass.h"
45 #include "dbgcnt.h"
47 /* The following code implements gcse after reload, the purpose of this
48 pass is to cleanup redundant loads generated by reload and other
49 optimizations that come after gcse. It searches for simple inter-block
50 redundancies and tries to eliminate them by adding moves and loads
51 in cold places.
53 Perform partially redundant load elimination, try to eliminate redundant
54 loads created by the reload pass. We try to look for full or partial
55 redundant loads fed by one or more loads/stores in predecessor BBs,
56 and try adding loads to make them fully redundant. We also check if
57 it's worth adding loads to be able to delete the redundant load.
59 Algorithm:
60 1. Build available expressions hash table:
61 For each load/store instruction, if the loaded/stored memory didn't
62 change until the end of the basic block add this memory expression to
63 the hash table.
64 2. Perform Redundancy elimination:
65 For each load instruction do the following:
66 perform partial redundancy elimination, check if it's worth adding
67 loads to make the load fully redundant. If so add loads and
68 register copies and delete the load.
69 3. Delete instructions made redundant in step 2.
71 Future enhancement:
72 If the loaded register is used/defined between load and some store,
73 look for some other free register between load and all its stores,
74 and replace the load with a copy from this register to the loaded
75 register.
79 /* Keep statistics of this pass. */
80 static struct
82 int moves_inserted;
83 int copies_inserted;
84 int insns_deleted;
85 } stats;
87 /* We need to keep a hash table of expressions. The table entries are of
88 type 'struct expr', and for each expression there is a single linked
89 list of occurrences. */
91 /* Expression elements in the hash table. */
92 struct expr
94 /* The expression (SET_SRC for expressions, PATTERN for assignments). */
95 rtx expr;
97 /* The same hash for this entry. */
98 hashval_t hash;
100 /* List of available occurrence in basic blocks in the function. */
101 struct occr *avail_occr;
104 /* Hashtable helpers. */
106 struct expr_hasher : typed_noop_remove <expr>
108 typedef expr value_type;
109 typedef expr compare_type;
110 static inline hashval_t hash (const value_type *);
111 static inline bool equal (const value_type *, const compare_type *);
115 /* Hash expression X.
116 DO_NOT_RECORD_P is a boolean indicating if a volatile operand is found
117 or if the expression contains something we don't want to insert in the
118 table. */
120 static hashval_t
121 hash_expr (rtx x, int *do_not_record_p)
123 *do_not_record_p = 0;
124 return hash_rtx (x, GET_MODE (x), do_not_record_p,
125 NULL, /*have_reg_qty=*/false);
128 /* Callback for hashtab.
129 Return the hash value for expression EXP. We don't actually hash
130 here, we just return the cached hash value. */
132 inline hashval_t
133 expr_hasher::hash (const value_type *exp)
135 return exp->hash;
138 /* Callback for hashtab.
139 Return nonzero if exp1 is equivalent to exp2. */
141 inline bool
142 expr_hasher::equal (const value_type *exp1, const compare_type *exp2)
144 int equiv_p = exp_equiv_p (exp1->expr, exp2->expr, 0, true);
146 gcc_assert (!equiv_p || exp1->hash == exp2->hash);
147 return equiv_p;
150 /* The table itself. */
151 static hash_table <expr_hasher> expr_table;
154 static struct obstack expr_obstack;
156 /* Occurrence of an expression.
157 There is at most one occurrence per basic block. If a pattern appears
158 more than once, the last appearance is used. */
160 struct occr
162 /* Next occurrence of this expression. */
163 struct occr *next;
164 /* The insn that computes the expression. */
165 rtx insn;
166 /* Nonzero if this [anticipatable] occurrence has been deleted. */
167 char deleted_p;
170 static struct obstack occr_obstack;
172 /* The following structure holds the information about the occurrences of
173 the redundant instructions. */
174 struct unoccr
176 struct unoccr *next;
177 edge pred;
178 rtx insn;
181 static struct obstack unoccr_obstack;
183 /* Array where each element is the CUID if the insn that last set the hard
184 register with the number of the element, since the start of the current
185 basic block.
187 This array is used during the building of the hash table (step 1) to
188 determine if a reg is killed before the end of a basic block.
190 It is also used when eliminating partial redundancies (step 2) to see
191 if a reg was modified since the start of a basic block. */
192 static int *reg_avail_info;
194 /* A list of insns that may modify memory within the current basic block. */
195 struct modifies_mem
197 rtx insn;
198 struct modifies_mem *next;
200 static struct modifies_mem *modifies_mem_list;
202 /* The modifies_mem structs also go on an obstack, only this obstack is
203 freed each time after completing the analysis or transformations on
204 a basic block. So we allocate a dummy modifies_mem_obstack_bottom
205 object on the obstack to keep track of the bottom of the obstack. */
206 static struct obstack modifies_mem_obstack;
207 static struct modifies_mem *modifies_mem_obstack_bottom;
209 /* Mapping of insn UIDs to CUIDs.
210 CUIDs are like UIDs except they increase monotonically in each basic
211 block, have no gaps, and only apply to real insns. */
212 static int *uid_cuid;
213 #define INSN_CUID(INSN) (uid_cuid[INSN_UID (INSN)])
216 /* Helpers for memory allocation/freeing. */
217 static void alloc_mem (void);
218 static void free_mem (void);
220 /* Support for hash table construction and transformations. */
221 static bool oprs_unchanged_p (rtx, rtx, bool);
222 static void record_last_reg_set_info (rtx, rtx);
223 static void record_last_reg_set_info_regno (rtx, int);
224 static void record_last_mem_set_info (rtx);
225 static void record_last_set_info (rtx, const_rtx, void *);
226 static void record_opr_changes (rtx);
228 static void find_mem_conflicts (rtx, const_rtx, void *);
229 static int load_killed_in_block_p (int, rtx, bool);
230 static void reset_opr_set_tables (void);
232 /* Hash table support. */
233 static hashval_t hash_expr (rtx, int *);
234 static void insert_expr_in_table (rtx, rtx);
235 static struct expr *lookup_expr_in_table (rtx);
236 static void dump_hash_table (FILE *);
238 /* Helpers for eliminate_partially_redundant_load. */
239 static bool reg_killed_on_edge (rtx, edge);
240 static bool reg_used_on_edge (rtx, edge);
242 static rtx get_avail_load_store_reg (rtx);
244 static bool bb_has_well_behaved_predecessors (basic_block);
245 static struct occr* get_bb_avail_insn (basic_block, struct occr *);
246 static void hash_scan_set (rtx);
247 static void compute_hash_table (void);
249 /* The work horses of this pass. */
250 static void eliminate_partially_redundant_load (basic_block,
251 rtx,
252 struct expr *);
253 static void eliminate_partially_redundant_loads (void);
256 /* Allocate memory for the CUID mapping array and register/memory
257 tracking tables. */
259 static void
260 alloc_mem (void)
262 int i;
263 basic_block bb;
264 rtx insn;
266 /* Find the largest UID and create a mapping from UIDs to CUIDs. */
267 uid_cuid = XCNEWVEC (int, get_max_uid () + 1);
268 i = 1;
269 FOR_EACH_BB (bb)
270 FOR_BB_INSNS (bb, insn)
272 if (INSN_P (insn))
273 uid_cuid[INSN_UID (insn)] = i++;
274 else
275 uid_cuid[INSN_UID (insn)] = i;
278 /* Allocate the available expressions hash table. We don't want to
279 make the hash table too small, but unnecessarily making it too large
280 also doesn't help. The i/4 is a gcse.c relic, and seems like a
281 reasonable choice. */
282 expr_table.create (MAX (i / 4, 13));
284 /* We allocate everything on obstacks because we often can roll back
285 the whole obstack to some point. Freeing obstacks is very fast. */
286 gcc_obstack_init (&expr_obstack);
287 gcc_obstack_init (&occr_obstack);
288 gcc_obstack_init (&unoccr_obstack);
289 gcc_obstack_init (&modifies_mem_obstack);
291 /* Working array used to track the last set for each register
292 in the current block. */
293 reg_avail_info = (int *) xmalloc (FIRST_PSEUDO_REGISTER * sizeof (int));
295 /* Put a dummy modifies_mem object on the modifies_mem_obstack, so we
296 can roll it back in reset_opr_set_tables. */
297 modifies_mem_obstack_bottom =
298 (struct modifies_mem *) obstack_alloc (&modifies_mem_obstack,
299 sizeof (struct modifies_mem));
302 /* Free memory allocated by alloc_mem. */
304 static void
305 free_mem (void)
307 free (uid_cuid);
309 expr_table.dispose ();
311 obstack_free (&expr_obstack, NULL);
312 obstack_free (&occr_obstack, NULL);
313 obstack_free (&unoccr_obstack, NULL);
314 obstack_free (&modifies_mem_obstack, NULL);
316 free (reg_avail_info);
320 /* Insert expression X in INSN in the hash TABLE.
321 If it is already present, record it as the last occurrence in INSN's
322 basic block. */
324 static void
325 insert_expr_in_table (rtx x, rtx insn)
327 int do_not_record_p;
328 hashval_t hash;
329 struct expr *cur_expr, **slot;
330 struct occr *avail_occr, *last_occr = NULL;
332 hash = hash_expr (x, &do_not_record_p);
334 /* Do not insert expression in the table if it contains volatile operands,
335 or if hash_expr determines the expression is something we don't want
336 to or can't handle. */
337 if (do_not_record_p)
338 return;
340 /* We anticipate that redundant expressions are rare, so for convenience
341 allocate a new hash table element here already and set its fields.
342 If we don't do this, we need a hack with a static struct expr. Anyway,
343 obstack_free is really fast and one more obstack_alloc doesn't hurt if
344 we're going to see more expressions later on. */
345 cur_expr = (struct expr *) obstack_alloc (&expr_obstack,
346 sizeof (struct expr));
347 cur_expr->expr = x;
348 cur_expr->hash = hash;
349 cur_expr->avail_occr = NULL;
351 slot = expr_table.find_slot_with_hash (cur_expr, hash, INSERT);
353 if (! (*slot))
354 /* The expression isn't found, so insert it. */
355 *slot = cur_expr;
356 else
358 /* The expression is already in the table, so roll back the
359 obstack and use the existing table entry. */
360 obstack_free (&expr_obstack, cur_expr);
361 cur_expr = *slot;
364 /* Search for another occurrence in the same basic block. */
365 avail_occr = cur_expr->avail_occr;
366 while (avail_occr
367 && BLOCK_FOR_INSN (avail_occr->insn) != BLOCK_FOR_INSN (insn))
369 /* If an occurrence isn't found, save a pointer to the end of
370 the list. */
371 last_occr = avail_occr;
372 avail_occr = avail_occr->next;
375 if (avail_occr)
376 /* Found another instance of the expression in the same basic block.
377 Prefer this occurrence to the currently recorded one. We want
378 the last one in the block and the block is scanned from start
379 to end. */
380 avail_occr->insn = insn;
381 else
383 /* First occurrence of this expression in this basic block. */
384 avail_occr = (struct occr *) obstack_alloc (&occr_obstack,
385 sizeof (struct occr));
387 /* First occurrence of this expression in any block? */
388 if (cur_expr->avail_occr == NULL)
389 cur_expr->avail_occr = avail_occr;
390 else
391 last_occr->next = avail_occr;
393 avail_occr->insn = insn;
394 avail_occr->next = NULL;
395 avail_occr->deleted_p = 0;
400 /* Lookup pattern PAT in the expression hash table.
401 The result is a pointer to the table entry, or NULL if not found. */
403 static struct expr *
404 lookup_expr_in_table (rtx pat)
406 int do_not_record_p;
407 struct expr **slot, *tmp_expr;
408 hashval_t hash = hash_expr (pat, &do_not_record_p);
410 if (do_not_record_p)
411 return NULL;
413 tmp_expr = (struct expr *) obstack_alloc (&expr_obstack,
414 sizeof (struct expr));
415 tmp_expr->expr = pat;
416 tmp_expr->hash = hash;
417 tmp_expr->avail_occr = NULL;
419 slot = expr_table.find_slot_with_hash (tmp_expr, hash, INSERT);
420 obstack_free (&expr_obstack, tmp_expr);
422 if (!slot)
423 return NULL;
424 else
425 return (*slot);
429 /* Dump all expressions and occurrences that are currently in the
430 expression hash table to FILE. */
432 /* This helper is called via htab_traverse. */
434 dump_expr_hash_table_entry (expr **slot, FILE *file)
436 struct expr *exprs = *slot;
437 struct occr *occr;
439 fprintf (file, "expr: ");
440 print_rtl (file, exprs->expr);
441 fprintf (file,"\nhashcode: %u\n", exprs->hash);
442 fprintf (file,"list of occurrences:\n");
443 occr = exprs->avail_occr;
444 while (occr)
446 rtx insn = occr->insn;
447 print_rtl_single (file, insn);
448 fprintf (file, "\n");
449 occr = occr->next;
451 fprintf (file, "\n");
452 return 1;
455 static void
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) expr_table.size (),
461 (long) expr_table.elements (),
462 expr_table.collisions ());
463 if (expr_table.elements () > 0)
465 fprintf (file, "\n\ntable entries:\n");
466 expr_table.traverse <FILE *, dump_expr_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. */
474 static bool
475 reg_changed_after_insn_p (rtx x, int cuid)
477 unsigned int regno, end_regno;
479 regno = REGNO (x);
480 end_regno = END_HARD_REGNO (x);
482 if (reg_avail_info[regno] > cuid)
483 return true;
484 while (++regno < end_regno);
485 return false;
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. */
493 static bool
494 oprs_unchanged_p (rtx x, rtx insn, bool after_insn)
496 int i, j;
497 enum rtx_code code;
498 const char *fmt;
500 if (x == 0)
501 return 1;
503 code = GET_CODE (x);
504 switch (code)
506 case REG:
507 /* We are called after register allocation. */
508 gcc_assert (REGNO (x) < FIRST_PSEUDO_REGISTER);
509 if (after_insn)
510 return !reg_changed_after_insn_p (x, INSN_CUID (insn) - 1);
511 else
512 return !reg_changed_after_insn_p (x, 0);
514 case MEM:
515 if (load_killed_in_block_p (INSN_CUID (insn), x, after_insn))
516 return 0;
517 else
518 return oprs_unchanged_p (XEXP (x, 0), insn, after_insn);
520 case PC:
521 case CC0: /*FIXME*/
522 case CONST:
523 CASE_CONST_ANY:
524 case SYMBOL_REF:
525 case LABEL_REF:
526 case ADDR_VEC:
527 case ADDR_DIFF_VEC:
528 return 1;
530 case PRE_DEC:
531 case PRE_INC:
532 case POST_DEC:
533 case POST_INC:
534 case PRE_MODIFY:
535 case POST_MODIFY:
536 if (after_insn)
537 return 0;
538 break;
540 default:
541 break;
544 for (i = GET_RTX_LENGTH (code) - 1, fmt = GET_RTX_FORMAT (code); i >= 0; i--)
546 if (fmt[i] == 'e')
548 if (! oprs_unchanged_p (XEXP (x, i), insn, after_insn))
549 return 0;
551 else if (fmt[i] == 'E')
552 for (j = 0; j < XVECLEN (x, i); j++)
553 if (! oprs_unchanged_p (XVECEXP (x, i, j), insn, after_insn))
554 return 0;
557 return 1;
561 /* Used for communication between find_mem_conflicts and
562 load_killed_in_block_p. Nonzero if find_mem_conflicts finds a
563 conflict between two memory references.
564 This is a bit of a hack to work around the limitations of note_stores. */
565 static int mems_conflict_p;
567 /* DEST is the output of an instruction. If it is a memory reference, and
568 possibly conflicts with the load found in DATA, then set mems_conflict_p
569 to a nonzero value. */
571 static void
572 find_mem_conflicts (rtx dest, const_rtx setter ATTRIBUTE_UNUSED,
573 void *data)
575 rtx mem_op = (rtx) data;
577 while (GET_CODE (dest) == SUBREG
578 || GET_CODE (dest) == ZERO_EXTRACT
579 || GET_CODE (dest) == STRICT_LOW_PART)
580 dest = XEXP (dest, 0);
582 /* If DEST is not a MEM, then it will not conflict with the load. Note
583 that function calls are assumed to clobber memory, but are handled
584 elsewhere. */
585 if (! MEM_P (dest))
586 return;
588 if (true_dependence (dest, GET_MODE (dest), mem_op))
589 mems_conflict_p = 1;
593 /* Return nonzero if the expression in X (a memory reference) is killed
594 in the current basic block before (if AFTER_INSN is false) or after
595 (if AFTER_INSN is true) the insn with the CUID in UID_LIMIT.
597 This function assumes that the modifies_mem table is flushed when
598 the hash table construction or redundancy elimination phases start
599 processing a new basic block. */
601 static int
602 load_killed_in_block_p (int uid_limit, rtx x, bool after_insn)
604 struct modifies_mem *list_entry = modifies_mem_list;
606 while (list_entry)
608 rtx setter = list_entry->insn;
610 /* Ignore entries in the list that do not apply. */
611 if ((after_insn
612 && INSN_CUID (setter) < uid_limit)
613 || (! after_insn
614 && INSN_CUID (setter) > uid_limit))
616 list_entry = list_entry->next;
617 continue;
620 /* If SETTER is a call everything is clobbered. Note that calls
621 to pure functions are never put on the list, so we need not
622 worry about them. */
623 if (CALL_P (setter))
624 return 1;
626 /* SETTER must be an insn of some kind that sets memory. Call
627 note_stores to examine each hunk of memory that is modified.
628 It will set mems_conflict_p to nonzero if there may be a
629 conflict between X and SETTER. */
630 mems_conflict_p = 0;
631 note_stores (PATTERN (setter), find_mem_conflicts, x);
632 if (mems_conflict_p)
633 return 1;
635 list_entry = list_entry->next;
637 return 0;
641 /* Record register first/last/block set information for REGNO in INSN. */
643 static inline void
644 record_last_reg_set_info (rtx insn, rtx reg)
646 unsigned int regno, end_regno;
648 regno = REGNO (reg);
649 end_regno = END_HARD_REGNO (reg);
651 reg_avail_info[regno] = INSN_CUID (insn);
652 while (++regno < end_regno);
655 static inline void
656 record_last_reg_set_info_regno (rtx insn, int regno)
658 reg_avail_info[regno] = INSN_CUID (insn);
662 /* Record memory modification information for INSN. We do not actually care
663 about the memory location(s) that are set, or even how they are set (consider
664 a CALL_INSN). We merely need to record which insns modify memory. */
666 static void
667 record_last_mem_set_info (rtx insn)
669 struct modifies_mem *list_entry;
671 list_entry = (struct modifies_mem *) obstack_alloc (&modifies_mem_obstack,
672 sizeof (struct modifies_mem));
673 list_entry->insn = insn;
674 list_entry->next = modifies_mem_list;
675 modifies_mem_list = list_entry;
678 /* Called from compute_hash_table via note_stores to handle one
679 SET or CLOBBER in an insn. DATA is really the instruction in which
680 the SET is taking place. */
682 static void
683 record_last_set_info (rtx dest, const_rtx setter ATTRIBUTE_UNUSED, void *data)
685 rtx last_set_insn = (rtx) data;
687 if (GET_CODE (dest) == SUBREG)
688 dest = SUBREG_REG (dest);
690 if (REG_P (dest))
691 record_last_reg_set_info (last_set_insn, dest);
692 else if (MEM_P (dest))
694 /* Ignore pushes, they don't clobber memory. They may still
695 clobber the stack pointer though. Some targets do argument
696 pushes without adding REG_INC notes. See e.g. PR25196,
697 where a pushsi2 on i386 doesn't have REG_INC notes. Note
698 such changes here too. */
699 if (! push_operand (dest, GET_MODE (dest)))
700 record_last_mem_set_info (last_set_insn);
701 else
702 record_last_reg_set_info_regno (last_set_insn, STACK_POINTER_REGNUM);
707 /* Reset tables used to keep track of what's still available since the
708 start of the block. */
710 static void
711 reset_opr_set_tables (void)
713 memset (reg_avail_info, 0, FIRST_PSEUDO_REGISTER * sizeof (int));
714 obstack_free (&modifies_mem_obstack, modifies_mem_obstack_bottom);
715 modifies_mem_list = NULL;
719 /* Record things set by INSN.
720 This data is used by oprs_unchanged_p. */
722 static void
723 record_opr_changes (rtx insn)
725 rtx note;
727 /* Find all stores and record them. */
728 note_stores (PATTERN (insn), record_last_set_info, insn);
730 /* Also record autoincremented REGs for this insn as changed. */
731 for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
732 if (REG_NOTE_KIND (note) == REG_INC)
733 record_last_reg_set_info (insn, XEXP (note, 0));
735 /* Finally, if this is a call, record all call clobbers. */
736 if (CALL_P (insn))
738 unsigned int regno;
739 rtx link, x;
740 hard_reg_set_iterator hrsi;
741 EXECUTE_IF_SET_IN_HARD_REG_SET (regs_invalidated_by_call, 0, regno, hrsi)
742 record_last_reg_set_info_regno (insn, regno);
744 for (link = CALL_INSN_FUNCTION_USAGE (insn); link; link = XEXP (link, 1))
745 if (GET_CODE (XEXP (link, 0)) == CLOBBER)
747 x = XEXP (XEXP (link, 0), 0);
748 if (REG_P (x))
750 gcc_assert (HARD_REGISTER_P (x));
751 record_last_reg_set_info (insn, x);
755 if (! RTL_CONST_OR_PURE_CALL_P (insn))
756 record_last_mem_set_info (insn);
761 /* Scan the pattern of INSN and add an entry to the hash TABLE.
762 After reload we are interested in loads/stores only. */
764 static void
765 hash_scan_set (rtx insn)
767 rtx pat = PATTERN (insn);
768 rtx src = SET_SRC (pat);
769 rtx dest = SET_DEST (pat);
771 /* We are only interested in loads and stores. */
772 if (! MEM_P (src) && ! MEM_P (dest))
773 return;
775 /* Don't mess with jumps and nops. */
776 if (JUMP_P (insn) || set_noop_p (pat))
777 return;
779 if (REG_P (dest))
781 if (/* Don't CSE something if we can't do a reg/reg copy. */
782 can_copy_p (GET_MODE (dest))
783 /* Is SET_SRC something we want to gcse? */
784 && general_operand (src, GET_MODE (src))
785 #ifdef STACK_REGS
786 /* Never consider insns touching the register stack. It may
787 create situations that reg-stack cannot handle (e.g. a stack
788 register live across an abnormal edge). */
789 && (REGNO (dest) < FIRST_STACK_REG || REGNO (dest) > LAST_STACK_REG)
790 #endif
791 /* An expression is not available if its operands are
792 subsequently modified, including this insn. */
793 && oprs_unchanged_p (src, insn, true))
795 insert_expr_in_table (src, insn);
798 else if (REG_P (src))
800 /* Only record sets of pseudo-regs in the hash table. */
801 if (/* Don't CSE something if we can't do a reg/reg copy. */
802 can_copy_p (GET_MODE (src))
803 /* Is SET_DEST something we want to gcse? */
804 && general_operand (dest, GET_MODE (dest))
805 #ifdef STACK_REGS
806 /* As above for STACK_REGS. */
807 && (REGNO (src) < FIRST_STACK_REG || REGNO (src) > LAST_STACK_REG)
808 #endif
809 && ! (flag_float_store && FLOAT_MODE_P (GET_MODE (dest)))
810 /* Check if the memory expression is killed after insn. */
811 && ! load_killed_in_block_p (INSN_CUID (insn) + 1, dest, true)
812 && oprs_unchanged_p (XEXP (dest, 0), insn, true))
814 insert_expr_in_table (dest, insn);
820 /* Create hash table of memory expressions available at end of basic
821 blocks. Basically you should think of this hash table as the
822 representation of AVAIL_OUT. This is the set of expressions that
823 is generated in a basic block and not killed before the end of the
824 same basic block. Notice that this is really a local computation. */
826 static void
827 compute_hash_table (void)
829 basic_block bb;
831 FOR_EACH_BB (bb)
833 rtx insn;
835 /* First pass over the instructions records information used to
836 determine when registers and memory are last set.
837 Since we compute a "local" AVAIL_OUT, reset the tables that
838 help us keep track of what has been modified since the start
839 of the block. */
840 reset_opr_set_tables ();
841 FOR_BB_INSNS (bb, insn)
843 if (INSN_P (insn))
844 record_opr_changes (insn);
847 /* The next pass actually builds the hash table. */
848 FOR_BB_INSNS (bb, insn)
849 if (INSN_P (insn) && GET_CODE (PATTERN (insn)) == SET)
850 hash_scan_set (insn);
855 /* Check if register REG is killed in any insn waiting to be inserted on
856 edge E. This function is required to check that our data flow analysis
857 is still valid prior to commit_edge_insertions. */
859 static bool
860 reg_killed_on_edge (rtx reg, edge e)
862 rtx insn;
864 for (insn = e->insns.r; insn; insn = NEXT_INSN (insn))
865 if (INSN_P (insn) && reg_set_p (reg, insn))
866 return true;
868 return false;
871 /* Similar to above - check if register REG is used in any insn waiting
872 to be inserted on edge E.
873 Assumes no such insn can be a CALL_INSN; if so call reg_used_between_p
874 with PREV(insn),NEXT(insn) instead of calling reg_overlap_mentioned_p. */
876 static bool
877 reg_used_on_edge (rtx reg, edge e)
879 rtx insn;
881 for (insn = e->insns.r; insn; insn = NEXT_INSN (insn))
882 if (INSN_P (insn) && reg_overlap_mentioned_p (reg, PATTERN (insn)))
883 return true;
885 return false;
888 /* Return the loaded/stored register of a load/store instruction. */
890 static rtx
891 get_avail_load_store_reg (rtx insn)
893 if (REG_P (SET_DEST (PATTERN (insn))))
894 /* A load. */
895 return SET_DEST(PATTERN(insn));
896 else
898 /* A store. */
899 gcc_assert (REG_P (SET_SRC (PATTERN (insn))));
900 return SET_SRC (PATTERN (insn));
904 /* Return nonzero if the predecessors of BB are "well behaved". */
906 static bool
907 bb_has_well_behaved_predecessors (basic_block bb)
909 edge pred;
910 edge_iterator ei;
912 if (EDGE_COUNT (bb->preds) == 0)
913 return false;
915 FOR_EACH_EDGE (pred, ei, bb->preds)
917 if ((pred->flags & EDGE_ABNORMAL) && EDGE_CRITICAL_P (pred))
918 return false;
920 if ((pred->flags & EDGE_ABNORMAL_CALL) && cfun->has_nonlocal_label)
921 return false;
923 if (tablejump_p (BB_END (pred->src), NULL, NULL))
924 return false;
926 return true;
930 /* Search for the occurrences of expression in BB. */
932 static struct occr*
933 get_bb_avail_insn (basic_block bb, struct occr *occr)
935 for (; occr != NULL; occr = occr->next)
936 if (BLOCK_FOR_INSN (occr->insn) == bb)
937 return occr;
938 return NULL;
942 /* This handles the case where several stores feed a partially redundant
943 load. It checks if the redundancy elimination is possible and if it's
944 worth it.
946 Redundancy elimination is possible if,
947 1) None of the operands of an insn have been modified since the start
948 of the current basic block.
949 2) In any predecessor of the current basic block, the same expression
950 is generated.
952 See the function body for the heuristics that determine if eliminating
953 a redundancy is also worth doing, assuming it is possible. */
955 static void
956 eliminate_partially_redundant_load (basic_block bb, rtx insn,
957 struct expr *expr)
959 edge pred;
960 rtx avail_insn = NULL_RTX;
961 rtx avail_reg;
962 rtx dest, pat;
963 struct occr *a_occr;
964 struct unoccr *occr, *avail_occrs = NULL;
965 struct unoccr *unoccr, *unavail_occrs = NULL, *rollback_unoccr = NULL;
966 int npred_ok = 0;
967 gcov_type ok_count = 0; /* Redundant load execution count. */
968 gcov_type critical_count = 0; /* Execution count of critical edges. */
969 edge_iterator ei;
970 bool critical_edge_split = false;
972 /* The execution count of the loads to be added to make the
973 load fully redundant. */
974 gcov_type not_ok_count = 0;
975 basic_block pred_bb;
977 pat = PATTERN (insn);
978 dest = SET_DEST (pat);
980 /* Check that the loaded register is not used, set, or killed from the
981 beginning of the block. */
982 if (reg_changed_after_insn_p (dest, 0)
983 || reg_used_between_p (dest, PREV_INSN (BB_HEAD (bb)), insn))
984 return;
986 /* Check potential for replacing load with copy for predecessors. */
987 FOR_EACH_EDGE (pred, ei, bb->preds)
989 rtx next_pred_bb_end;
991 avail_insn = NULL_RTX;
992 avail_reg = NULL_RTX;
993 pred_bb = pred->src;
994 next_pred_bb_end = NEXT_INSN (BB_END (pred_bb));
995 for (a_occr = get_bb_avail_insn (pred_bb, expr->avail_occr); a_occr;
996 a_occr = get_bb_avail_insn (pred_bb, a_occr->next))
998 /* Check if the loaded register is not used. */
999 avail_insn = a_occr->insn;
1000 avail_reg = get_avail_load_store_reg (avail_insn);
1001 gcc_assert (avail_reg);
1003 /* Make sure we can generate a move from register avail_reg to
1004 dest. */
1005 extract_insn (gen_move_insn (copy_rtx (dest),
1006 copy_rtx (avail_reg)));
1007 if (! constrain_operands (1)
1008 || reg_killed_on_edge (avail_reg, pred)
1009 || reg_used_on_edge (dest, pred))
1011 avail_insn = NULL;
1012 continue;
1014 if (!reg_set_between_p (avail_reg, avail_insn, next_pred_bb_end))
1015 /* AVAIL_INSN remains non-null. */
1016 break;
1017 else
1018 avail_insn = NULL;
1021 if (EDGE_CRITICAL_P (pred))
1022 critical_count += pred->count;
1024 if (avail_insn != NULL_RTX)
1026 npred_ok++;
1027 ok_count += pred->count;
1028 if (! set_noop_p (PATTERN (gen_move_insn (copy_rtx (dest),
1029 copy_rtx (avail_reg)))))
1031 /* Check if there is going to be a split. */
1032 if (EDGE_CRITICAL_P (pred))
1033 critical_edge_split = true;
1035 else /* Its a dead move no need to generate. */
1036 continue;
1037 occr = (struct unoccr *) obstack_alloc (&unoccr_obstack,
1038 sizeof (struct unoccr));
1039 occr->insn = avail_insn;
1040 occr->pred = pred;
1041 occr->next = avail_occrs;
1042 avail_occrs = occr;
1043 if (! rollback_unoccr)
1044 rollback_unoccr = occr;
1046 else
1048 /* Adding a load on a critical edge will cause a split. */
1049 if (EDGE_CRITICAL_P (pred))
1050 critical_edge_split = true;
1051 not_ok_count += pred->count;
1052 unoccr = (struct unoccr *) obstack_alloc (&unoccr_obstack,
1053 sizeof (struct unoccr));
1054 unoccr->insn = NULL_RTX;
1055 unoccr->pred = pred;
1056 unoccr->next = unavail_occrs;
1057 unavail_occrs = unoccr;
1058 if (! rollback_unoccr)
1059 rollback_unoccr = unoccr;
1063 if (/* No load can be replaced by copy. */
1064 npred_ok == 0
1065 /* Prevent exploding the code. */
1066 || (optimize_bb_for_size_p (bb) && npred_ok > 1)
1067 /* If we don't have profile information we cannot tell if splitting
1068 a critical edge is profitable or not so don't do it. */
1069 || ((! profile_info || ! flag_branch_probabilities
1070 || targetm.cannot_modify_jumps_p ())
1071 && critical_edge_split))
1072 goto cleanup;
1074 /* Check if it's worth applying the partial redundancy elimination. */
1075 if (ok_count < GCSE_AFTER_RELOAD_PARTIAL_FRACTION * not_ok_count)
1076 goto cleanup;
1077 if (ok_count < GCSE_AFTER_RELOAD_CRITICAL_FRACTION * critical_count)
1078 goto cleanup;
1080 /* Generate moves to the loaded register from where
1081 the memory is available. */
1082 for (occr = avail_occrs; occr; occr = occr->next)
1084 avail_insn = occr->insn;
1085 pred = occr->pred;
1086 /* Set avail_reg to be the register having the value of the
1087 memory. */
1088 avail_reg = get_avail_load_store_reg (avail_insn);
1089 gcc_assert (avail_reg);
1091 insert_insn_on_edge (gen_move_insn (copy_rtx (dest),
1092 copy_rtx (avail_reg)),
1093 pred);
1094 stats.moves_inserted++;
1096 if (dump_file)
1097 fprintf (dump_file,
1098 "generating move from %d to %d on edge from %d to %d\n",
1099 REGNO (avail_reg),
1100 REGNO (dest),
1101 pred->src->index,
1102 pred->dest->index);
1105 /* Regenerate loads where the memory is unavailable. */
1106 for (unoccr = unavail_occrs; unoccr; unoccr = unoccr->next)
1108 pred = unoccr->pred;
1109 insert_insn_on_edge (copy_insn (PATTERN (insn)), pred);
1110 stats.copies_inserted++;
1112 if (dump_file)
1114 fprintf (dump_file,
1115 "generating on edge from %d to %d a copy of load: ",
1116 pred->src->index,
1117 pred->dest->index);
1118 print_rtl (dump_file, PATTERN (insn));
1119 fprintf (dump_file, "\n");
1123 /* Delete the insn if it is not available in this block and mark it
1124 for deletion if it is available. If insn is available it may help
1125 discover additional redundancies, so mark it for later deletion. */
1126 for (a_occr = get_bb_avail_insn (bb, expr->avail_occr);
1127 a_occr && (a_occr->insn != insn);
1128 a_occr = get_bb_avail_insn (bb, a_occr->next))
1131 if (!a_occr)
1133 stats.insns_deleted++;
1135 if (dump_file)
1137 fprintf (dump_file, "deleting insn:\n");
1138 print_rtl_single (dump_file, insn);
1139 fprintf (dump_file, "\n");
1141 delete_insn (insn);
1143 else
1144 a_occr->deleted_p = 1;
1146 cleanup:
1147 if (rollback_unoccr)
1148 obstack_free (&unoccr_obstack, rollback_unoccr);
1151 /* Performing the redundancy elimination as described before. */
1153 static void
1154 eliminate_partially_redundant_loads (void)
1156 rtx insn;
1157 basic_block bb;
1159 /* Note we start at block 1. */
1161 if (ENTRY_BLOCK_PTR->next_bb == EXIT_BLOCK_PTR)
1162 return;
1164 FOR_BB_BETWEEN (bb,
1165 ENTRY_BLOCK_PTR->next_bb->next_bb,
1166 EXIT_BLOCK_PTR,
1167 next_bb)
1169 /* Don't try anything on basic blocks with strange predecessors. */
1170 if (! bb_has_well_behaved_predecessors (bb))
1171 continue;
1173 /* Do not try anything on cold basic blocks. */
1174 if (optimize_bb_for_size_p (bb))
1175 continue;
1177 /* Reset the table of things changed since the start of the current
1178 basic block. */
1179 reset_opr_set_tables ();
1181 /* Look at all insns in the current basic block and see if there are
1182 any loads in it that we can record. */
1183 FOR_BB_INSNS (bb, insn)
1185 /* Is it a load - of the form (set (reg) (mem))? */
1186 if (NONJUMP_INSN_P (insn)
1187 && GET_CODE (PATTERN (insn)) == SET
1188 && REG_P (SET_DEST (PATTERN (insn)))
1189 && MEM_P (SET_SRC (PATTERN (insn))))
1191 rtx pat = PATTERN (insn);
1192 rtx src = SET_SRC (pat);
1193 struct expr *expr;
1195 if (!MEM_VOLATILE_P (src)
1196 && GET_MODE (src) != BLKmode
1197 && general_operand (src, GET_MODE (src))
1198 /* Are the operands unchanged since the start of the
1199 block? */
1200 && oprs_unchanged_p (src, insn, false)
1201 && !(cfun->can_throw_non_call_exceptions && may_trap_p (src))
1202 && !side_effects_p (src)
1203 /* Is the expression recorded? */
1204 && (expr = lookup_expr_in_table (src)) != NULL)
1206 /* We now have a load (insn) and an available memory at
1207 its BB start (expr). Try to remove the loads if it is
1208 redundant. */
1209 eliminate_partially_redundant_load (bb, insn, expr);
1213 /* Keep track of everything modified by this insn, so that we
1214 know what has been modified since the start of the current
1215 basic block. */
1216 if (INSN_P (insn))
1217 record_opr_changes (insn);
1221 commit_edge_insertions ();
1224 /* Go over the expression hash table and delete insns that were
1225 marked for later deletion. */
1227 /* This helper is called via htab_traverse. */
1229 delete_redundant_insns_1 (expr **slot, void *data ATTRIBUTE_UNUSED)
1231 struct expr *exprs = *slot;
1232 struct occr *occr;
1234 for (occr = exprs->avail_occr; occr != NULL; occr = occr->next)
1236 if (occr->deleted_p && dbg_cnt (gcse2_delete))
1238 delete_insn (occr->insn);
1239 stats.insns_deleted++;
1241 if (dump_file)
1243 fprintf (dump_file, "deleting insn:\n");
1244 print_rtl_single (dump_file, occr->insn);
1245 fprintf (dump_file, "\n");
1250 return 1;
1253 static void
1254 delete_redundant_insns (void)
1256 expr_table.traverse <void *, delete_redundant_insns_1> (NULL);
1257 if (dump_file)
1258 fprintf (dump_file, "\n");
1261 /* Main entry point of the GCSE after reload - clean some redundant loads
1262 due to spilling. */
1264 static void
1265 gcse_after_reload_main (rtx f ATTRIBUTE_UNUSED)
1268 memset (&stats, 0, sizeof (stats));
1270 /* Allocate memory for this pass.
1271 Also computes and initializes the insns' CUIDs. */
1272 alloc_mem ();
1274 /* We need alias analysis. */
1275 init_alias_analysis ();
1277 compute_hash_table ();
1279 if (dump_file)
1280 dump_hash_table (dump_file);
1282 if (expr_table.elements () > 0)
1284 eliminate_partially_redundant_loads ();
1285 delete_redundant_insns ();
1287 if (dump_file)
1289 fprintf (dump_file, "GCSE AFTER RELOAD stats:\n");
1290 fprintf (dump_file, "copies inserted: %d\n", stats.copies_inserted);
1291 fprintf (dump_file, "moves inserted: %d\n", stats.moves_inserted);
1292 fprintf (dump_file, "insns deleted: %d\n", stats.insns_deleted);
1293 fprintf (dump_file, "\n\n");
1296 statistics_counter_event (cfun, "copies inserted",
1297 stats.copies_inserted);
1298 statistics_counter_event (cfun, "moves inserted",
1299 stats.moves_inserted);
1300 statistics_counter_event (cfun, "insns deleted",
1301 stats.insns_deleted);
1304 /* We are finished with alias. */
1305 end_alias_analysis ();
1307 free_mem ();
1311 static bool
1312 gate_handle_gcse2 (void)
1314 return (optimize > 0 && flag_gcse_after_reload
1315 && optimize_function_for_speed_p (cfun));
1319 static unsigned int
1320 rest_of_handle_gcse2 (void)
1322 gcse_after_reload_main (get_insns ());
1323 rebuild_jump_labels (get_insns ());
1324 return 0;
1327 struct rtl_opt_pass pass_gcse2 =
1330 RTL_PASS,
1331 "gcse2", /* name */
1332 OPTGROUP_NONE, /* optinfo_flags */
1333 gate_handle_gcse2, /* gate */
1334 rest_of_handle_gcse2, /* execute */
1335 NULL, /* sub */
1336 NULL, /* next */
1337 0, /* static_pass_number */
1338 TV_GCSE_AFTER_RELOAD, /* tv_id */
1339 0, /* properties_required */
1340 0, /* properties_provided */
1341 0, /* properties_destroyed */
1342 0, /* todo_flags_start */
1343 TODO_verify_rtl_sharing
1344 | TODO_verify_flow /* todo_flags_finish */