re PR bootstrap/54281 (Fails to bootstrap with --disable-nls)
[official-gcc.git] / gcc / postreload-gcse.c
blobb9e9f2525cafb4d06ae33949b2cb6d9436a81a2b
1 /* Post reload partially redundant load elimination
2 Copyright (C) 2004, 2005, 2006, 2007, 2008, 2010, 2011
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 3, or (at your option) any later
10 version.
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
15 for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
21 #include "config.h"
22 #include "system.h"
23 #include "coretypes.h"
24 #include "tm.h"
25 #include "diagnostic-core.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 /* The table itself. */
92 static htab_t expr_table;
94 /* Expression elements in the hash table. */
95 struct expr
97 /* The expression (SET_SRC for expressions, PATTERN for assignments). */
98 rtx expr;
100 /* The same hash for this entry. */
101 hashval_t hash;
103 /* List of available occurrence in basic blocks in the function. */
104 struct occr *avail_occr;
107 static struct obstack expr_obstack;
109 /* Occurrence of an expression.
110 There is at most one occurrence per basic block. If a pattern appears
111 more than once, the last appearance is used. */
113 struct occr
115 /* Next occurrence of this expression. */
116 struct occr *next;
117 /* The insn that computes the expression. */
118 rtx insn;
119 /* Nonzero if this [anticipatable] occurrence has been deleted. */
120 char deleted_p;
123 static struct obstack occr_obstack;
125 /* The following structure holds the information about the occurrences of
126 the redundant instructions. */
127 struct unoccr
129 struct unoccr *next;
130 edge pred;
131 rtx insn;
134 static struct obstack unoccr_obstack;
136 /* Array where each element is the CUID if the insn that last set the hard
137 register with the number of the element, since the start of the current
138 basic block.
140 This array is used during the building of the hash table (step 1) to
141 determine if a reg is killed before the end of a basic block.
143 It is also used when eliminating partial redundancies (step 2) to see
144 if a reg was modified since the start of a basic block. */
145 static int *reg_avail_info;
147 /* A list of insns that may modify memory within the current basic block. */
148 struct modifies_mem
150 rtx insn;
151 struct modifies_mem *next;
153 static struct modifies_mem *modifies_mem_list;
155 /* The modifies_mem structs also go on an obstack, only this obstack is
156 freed each time after completing the analysis or transformations on
157 a basic block. So we allocate a dummy modifies_mem_obstack_bottom
158 object on the obstack to keep track of the bottom of the obstack. */
159 static struct obstack modifies_mem_obstack;
160 static struct modifies_mem *modifies_mem_obstack_bottom;
162 /* Mapping of insn UIDs to CUIDs.
163 CUIDs are like UIDs except they increase monotonically in each basic
164 block, have no gaps, and only apply to real insns. */
165 static int *uid_cuid;
166 #define INSN_CUID(INSN) (uid_cuid[INSN_UID (INSN)])
169 /* Helpers for memory allocation/freeing. */
170 static void alloc_mem (void);
171 static void free_mem (void);
173 /* Support for hash table construction and transformations. */
174 static bool oprs_unchanged_p (rtx, rtx, bool);
175 static void record_last_reg_set_info (rtx, rtx);
176 static void record_last_reg_set_info_regno (rtx, int);
177 static void record_last_mem_set_info (rtx);
178 static void record_last_set_info (rtx, const_rtx, void *);
179 static void record_opr_changes (rtx);
181 static void find_mem_conflicts (rtx, const_rtx, void *);
182 static int load_killed_in_block_p (int, rtx, bool);
183 static void reset_opr_set_tables (void);
185 /* Hash table support. */
186 static hashval_t hash_expr (rtx, int *);
187 static hashval_t hash_expr_for_htab (const void *);
188 static int expr_equiv_p (const void *, const void *);
189 static void insert_expr_in_table (rtx, rtx);
190 static struct expr *lookup_expr_in_table (rtx);
191 static int dump_hash_table_entry (void **, void *);
192 static void dump_hash_table (FILE *);
194 /* Helpers for eliminate_partially_redundant_load. */
195 static bool reg_killed_on_edge (rtx, edge);
196 static bool reg_used_on_edge (rtx, edge);
198 static rtx get_avail_load_store_reg (rtx);
200 static bool bb_has_well_behaved_predecessors (basic_block);
201 static struct occr* get_bb_avail_insn (basic_block, struct occr *);
202 static void hash_scan_set (rtx);
203 static void compute_hash_table (void);
205 /* The work horses of this pass. */
206 static void eliminate_partially_redundant_load (basic_block,
207 rtx,
208 struct expr *);
209 static void eliminate_partially_redundant_loads (void);
212 /* Allocate memory for the CUID mapping array and register/memory
213 tracking tables. */
215 static void
216 alloc_mem (void)
218 int i;
219 basic_block bb;
220 rtx insn;
222 /* Find the largest UID and create a mapping from UIDs to CUIDs. */
223 uid_cuid = XCNEWVEC (int, get_max_uid () + 1);
224 i = 1;
225 FOR_EACH_BB (bb)
226 FOR_BB_INSNS (bb, insn)
228 if (INSN_P (insn))
229 uid_cuid[INSN_UID (insn)] = i++;
230 else
231 uid_cuid[INSN_UID (insn)] = i;
234 /* Allocate the available expressions hash table. We don't want to
235 make the hash table too small, but unnecessarily making it too large
236 also doesn't help. The i/4 is a gcse.c relic, and seems like a
237 reasonable choice. */
238 expr_table = htab_create (MAX (i / 4, 13),
239 hash_expr_for_htab, expr_equiv_p, NULL);
241 /* We allocate everything on obstacks because we often can roll back
242 the whole obstack to some point. Freeing obstacks is very fast. */
243 gcc_obstack_init (&expr_obstack);
244 gcc_obstack_init (&occr_obstack);
245 gcc_obstack_init (&unoccr_obstack);
246 gcc_obstack_init (&modifies_mem_obstack);
248 /* Working array used to track the last set for each register
249 in the current block. */
250 reg_avail_info = (int *) xmalloc (FIRST_PSEUDO_REGISTER * sizeof (int));
252 /* Put a dummy modifies_mem object on the modifies_mem_obstack, so we
253 can roll it back in reset_opr_set_tables. */
254 modifies_mem_obstack_bottom =
255 (struct modifies_mem *) obstack_alloc (&modifies_mem_obstack,
256 sizeof (struct modifies_mem));
259 /* Free memory allocated by alloc_mem. */
261 static void
262 free_mem (void)
264 free (uid_cuid);
266 htab_delete (expr_table);
268 obstack_free (&expr_obstack, NULL);
269 obstack_free (&occr_obstack, NULL);
270 obstack_free (&unoccr_obstack, NULL);
271 obstack_free (&modifies_mem_obstack, NULL);
273 free (reg_avail_info);
277 /* Hash expression X.
278 DO_NOT_RECORD_P is a boolean indicating if a volatile operand is found
279 or if the expression contains something we don't want to insert in the
280 table. */
282 static hashval_t
283 hash_expr (rtx x, int *do_not_record_p)
285 *do_not_record_p = 0;
286 return hash_rtx (x, GET_MODE (x), do_not_record_p,
287 NULL, /*have_reg_qty=*/false);
290 /* Callback for hashtab.
291 Return the hash value for expression EXP. We don't actually hash
292 here, we just return the cached hash value. */
294 static hashval_t
295 hash_expr_for_htab (const void *expp)
297 const struct expr *const exp = (const struct expr *) expp;
298 return exp->hash;
301 /* Callback for hashtab.
302 Return nonzero if exp1 is equivalent to exp2. */
304 static int
305 expr_equiv_p (const void *exp1p, const void *exp2p)
307 const struct expr *const exp1 = (const struct expr *) exp1p;
308 const struct expr *const exp2 = (const struct expr *) exp2p;
309 int equiv_p = exp_equiv_p (exp1->expr, exp2->expr, 0, true);
311 gcc_assert (!equiv_p || exp1->hash == exp2->hash);
312 return equiv_p;
316 /* Insert expression X in INSN in the hash TABLE.
317 If it is already present, record it as the last occurrence in INSN's
318 basic block. */
320 static void
321 insert_expr_in_table (rtx x, rtx insn)
323 int do_not_record_p;
324 hashval_t hash;
325 struct expr *cur_expr, **slot;
326 struct occr *avail_occr, *last_occr = NULL;
328 hash = hash_expr (x, &do_not_record_p);
330 /* Do not insert expression in the table if it contains volatile operands,
331 or if hash_expr determines the expression is something we don't want
332 to or can't handle. */
333 if (do_not_record_p)
334 return;
336 /* We anticipate that redundant expressions are rare, so for convenience
337 allocate a new hash table element here already and set its fields.
338 If we don't do this, we need a hack with a static struct expr. Anyway,
339 obstack_free is really fast and one more obstack_alloc doesn't hurt if
340 we're going to see more expressions later on. */
341 cur_expr = (struct expr *) obstack_alloc (&expr_obstack,
342 sizeof (struct expr));
343 cur_expr->expr = x;
344 cur_expr->hash = hash;
345 cur_expr->avail_occr = NULL;
347 slot = (struct expr **) htab_find_slot_with_hash (expr_table, cur_expr,
348 hash, INSERT);
350 if (! (*slot))
351 /* The expression isn't found, so insert it. */
352 *slot = cur_expr;
353 else
355 /* The expression is already in the table, so roll back the
356 obstack and use the existing table entry. */
357 obstack_free (&expr_obstack, cur_expr);
358 cur_expr = *slot;
361 /* Search for another occurrence in the same basic block. */
362 avail_occr = cur_expr->avail_occr;
363 while (avail_occr
364 && BLOCK_FOR_INSN (avail_occr->insn) != BLOCK_FOR_INSN (insn))
366 /* If an occurrence isn't found, save a pointer to the end of
367 the list. */
368 last_occr = avail_occr;
369 avail_occr = avail_occr->next;
372 if (avail_occr)
373 /* Found another instance of the expression in the same basic block.
374 Prefer this occurrence to the currently recorded one. We want
375 the last one in the block and the block is scanned from start
376 to end. */
377 avail_occr->insn = insn;
378 else
380 /* First occurrence of this expression in this basic block. */
381 avail_occr = (struct occr *) obstack_alloc (&occr_obstack,
382 sizeof (struct occr));
384 /* First occurrence of this expression in any block? */
385 if (cur_expr->avail_occr == NULL)
386 cur_expr->avail_occr = avail_occr;
387 else
388 last_occr->next = avail_occr;
390 avail_occr->insn = insn;
391 avail_occr->next = NULL;
392 avail_occr->deleted_p = 0;
397 /* Lookup pattern PAT in the expression hash table.
398 The result is a pointer to the table entry, or NULL if not found. */
400 static struct expr *
401 lookup_expr_in_table (rtx pat)
403 int do_not_record_p;
404 struct expr **slot, *tmp_expr;
405 hashval_t hash = hash_expr (pat, &do_not_record_p);
407 if (do_not_record_p)
408 return NULL;
410 tmp_expr = (struct expr *) obstack_alloc (&expr_obstack,
411 sizeof (struct expr));
412 tmp_expr->expr = pat;
413 tmp_expr->hash = hash;
414 tmp_expr->avail_occr = NULL;
416 slot = (struct expr **) htab_find_slot_with_hash (expr_table, tmp_expr,
417 hash, INSERT);
418 obstack_free (&expr_obstack, tmp_expr);
420 if (!slot)
421 return NULL;
422 else
423 return (*slot);
427 /* Dump all expressions and occurrences that are currently in the
428 expression hash table to FILE. */
430 /* This helper is called via htab_traverse. */
431 static int
432 dump_hash_table_entry (void **slot, void *filep)
434 struct expr *expr = (struct expr *) *slot;
435 FILE *file = (FILE *) filep;
436 struct occr *occr;
438 fprintf (file, "expr: ");
439 print_rtl (file, expr->expr);
440 fprintf (file,"\nhashcode: %u\n", expr->hash);
441 fprintf (file,"list of occurrences:\n");
442 occr = expr->avail_occr;
443 while (occr)
445 rtx insn = occr->insn;
446 print_rtl_single (file, insn);
447 fprintf (file, "\n");
448 occr = occr->next;
450 fprintf (file, "\n");
451 return 1;
454 static void
455 dump_hash_table (FILE *file)
457 fprintf (file, "\n\nexpression hash table\n");
458 fprintf (file, "size %ld, %ld elements, %f collision/search ratio\n",
459 (long) htab_size (expr_table),
460 (long) htab_elements (expr_table),
461 htab_collisions (expr_table));
462 if (htab_elements (expr_table) > 0)
464 fprintf (file, "\n\ntable entries:\n");
465 htab_traverse (expr_table, dump_hash_table_entry, file);
467 fprintf (file, "\n");
470 /* Return true if register X is recorded as being set by an instruction
471 whose CUID is greater than the one given. */
473 static bool
474 reg_changed_after_insn_p (rtx x, int cuid)
476 unsigned int regno, end_regno;
478 regno = REGNO (x);
479 end_regno = END_HARD_REGNO (x);
481 if (reg_avail_info[regno] > cuid)
482 return true;
483 while (++regno < end_regno);
484 return false;
487 /* Return nonzero if the operands of expression X are unchanged
488 1) from the start of INSN's basic block up to but not including INSN
489 if AFTER_INSN is false, or
490 2) from INSN to the end of INSN's basic block if AFTER_INSN is true. */
492 static bool
493 oprs_unchanged_p (rtx x, rtx insn, bool after_insn)
495 int i, j;
496 enum rtx_code code;
497 const char *fmt;
499 if (x == 0)
500 return 1;
502 code = GET_CODE (x);
503 switch (code)
505 case REG:
506 /* We are called after register allocation. */
507 gcc_assert (REGNO (x) < FIRST_PSEUDO_REGISTER);
508 if (after_insn)
509 return !reg_changed_after_insn_p (x, INSN_CUID (insn) - 1);
510 else
511 return !reg_changed_after_insn_p (x, 0);
513 case MEM:
514 if (load_killed_in_block_p (INSN_CUID (insn), x, after_insn))
515 return 0;
516 else
517 return oprs_unchanged_p (XEXP (x, 0), insn, after_insn);
519 case PC:
520 case CC0: /*FIXME*/
521 case CONST:
522 case CONST_INT:
523 case CONST_DOUBLE:
524 case CONST_FIXED:
525 case CONST_VECTOR:
526 case SYMBOL_REF:
527 case LABEL_REF:
528 case ADDR_VEC:
529 case ADDR_DIFF_VEC:
530 return 1;
532 case PRE_DEC:
533 case PRE_INC:
534 case POST_DEC:
535 case POST_INC:
536 case PRE_MODIFY:
537 case POST_MODIFY:
538 if (after_insn)
539 return 0;
540 break;
542 default:
543 break;
546 for (i = GET_RTX_LENGTH (code) - 1, fmt = GET_RTX_FORMAT (code); i >= 0; i--)
548 if (fmt[i] == 'e')
550 if (! oprs_unchanged_p (XEXP (x, i), insn, after_insn))
551 return 0;
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))
556 return 0;
559 return 1;
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. */
573 static void
574 find_mem_conflicts (rtx dest, const_rtx setter ATTRIBUTE_UNUSED,
575 void *data)
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
586 elsewhere. */
587 if (! MEM_P (dest))
588 return;
590 if (true_dependence (dest, GET_MODE (dest), mem_op))
591 mems_conflict_p = 1;
595 /* Return nonzero if the expression in X (a memory reference) is killed
596 in the current basic block before (if AFTER_INSN is false) or after
597 (if AFTER_INSN is true) the insn with the CUID in UID_LIMIT.
599 This function assumes that the modifies_mem table is flushed when
600 the hash table construction or redundancy elimination phases start
601 processing a new basic block. */
603 static int
604 load_killed_in_block_p (int uid_limit, rtx x, bool after_insn)
606 struct modifies_mem *list_entry = modifies_mem_list;
608 while (list_entry)
610 rtx setter = list_entry->insn;
612 /* Ignore entries in the list that do not apply. */
613 if ((after_insn
614 && INSN_CUID (setter) < uid_limit)
615 || (! after_insn
616 && INSN_CUID (setter) > uid_limit))
618 list_entry = list_entry->next;
619 continue;
622 /* If SETTER is a call everything is clobbered. Note that calls
623 to pure functions are never put on the list, so we need not
624 worry about them. */
625 if (CALL_P (setter))
626 return 1;
628 /* SETTER must be an insn of some kind that sets memory. Call
629 note_stores to examine each hunk of memory that is modified.
630 It will set mems_conflict_p to nonzero if there may be a
631 conflict between X and SETTER. */
632 mems_conflict_p = 0;
633 note_stores (PATTERN (setter), find_mem_conflicts, x);
634 if (mems_conflict_p)
635 return 1;
637 list_entry = list_entry->next;
639 return 0;
643 /* Record register first/last/block set information for REGNO in INSN. */
645 static inline void
646 record_last_reg_set_info (rtx insn, rtx reg)
648 unsigned int regno, end_regno;
650 regno = REGNO (reg);
651 end_regno = END_HARD_REGNO (reg);
653 reg_avail_info[regno] = INSN_CUID (insn);
654 while (++regno < end_regno);
657 static inline void
658 record_last_reg_set_info_regno (rtx insn, int regno)
660 reg_avail_info[regno] = INSN_CUID (insn);
664 /* Record memory modification information for INSN. We do not actually care
665 about the memory location(s) that are set, or even how they are set (consider
666 a CALL_INSN). We merely need to record which insns modify memory. */
668 static void
669 record_last_mem_set_info (rtx insn)
671 struct modifies_mem *list_entry;
673 list_entry = (struct modifies_mem *) obstack_alloc (&modifies_mem_obstack,
674 sizeof (struct modifies_mem));
675 list_entry->insn = insn;
676 list_entry->next = modifies_mem_list;
677 modifies_mem_list = list_entry;
680 /* Called from compute_hash_table via note_stores to handle one
681 SET or CLOBBER in an insn. DATA is really the instruction in which
682 the SET is taking place. */
684 static void
685 record_last_set_info (rtx dest, const_rtx setter ATTRIBUTE_UNUSED, void *data)
687 rtx last_set_insn = (rtx) data;
689 if (GET_CODE (dest) == SUBREG)
690 dest = SUBREG_REG (dest);
692 if (REG_P (dest))
693 record_last_reg_set_info (last_set_insn, dest);
694 else if (MEM_P (dest))
696 /* Ignore pushes, they don't clobber memory. They may still
697 clobber the stack pointer though. Some targets do argument
698 pushes without adding REG_INC notes. See e.g. PR25196,
699 where a pushsi2 on i386 doesn't have REG_INC notes. Note
700 such changes here too. */
701 if (! push_operand (dest, GET_MODE (dest)))
702 record_last_mem_set_info (last_set_insn);
703 else
704 record_last_reg_set_info_regno (last_set_insn, STACK_POINTER_REGNUM);
709 /* Reset tables used to keep track of what's still available since the
710 start of the block. */
712 static void
713 reset_opr_set_tables (void)
715 memset (reg_avail_info, 0, FIRST_PSEUDO_REGISTER * sizeof (int));
716 obstack_free (&modifies_mem_obstack, modifies_mem_obstack_bottom);
717 modifies_mem_list = NULL;
721 /* Record things set by INSN.
722 This data is used by oprs_unchanged_p. */
724 static void
725 record_opr_changes (rtx insn)
727 rtx note;
729 /* Find all stores and record them. */
730 note_stores (PATTERN (insn), record_last_set_info, insn);
732 /* Also record autoincremented REGs for this insn as changed. */
733 for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
734 if (REG_NOTE_KIND (note) == REG_INC)
735 record_last_reg_set_info (insn, XEXP (note, 0));
737 /* Finally, if this is a call, record all call clobbers. */
738 if (CALL_P (insn))
740 unsigned int regno;
741 rtx link, x;
743 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
744 if (TEST_HARD_REG_BIT (regs_invalidated_by_call, regno))
745 record_last_reg_set_info_regno (insn, regno);
747 for (link = CALL_INSN_FUNCTION_USAGE (insn); link; link = XEXP (link, 1))
748 if (GET_CODE (XEXP (link, 0)) == CLOBBER)
750 x = XEXP (XEXP (link, 0), 0);
751 if (REG_P (x))
753 gcc_assert (HARD_REGISTER_P (x));
754 record_last_reg_set_info (insn, x);
758 if (! RTL_CONST_OR_PURE_CALL_P (insn))
759 record_last_mem_set_info (insn);
764 /* Scan the pattern of INSN and add an entry to the hash TABLE.
765 After reload we are interested in loads/stores only. */
767 static void
768 hash_scan_set (rtx insn)
770 rtx pat = PATTERN (insn);
771 rtx src = SET_SRC (pat);
772 rtx dest = SET_DEST (pat);
774 /* We are only interested in loads and stores. */
775 if (! MEM_P (src) && ! MEM_P (dest))
776 return;
778 /* Don't mess with jumps and nops. */
779 if (JUMP_P (insn) || set_noop_p (pat))
780 return;
782 if (REG_P (dest))
784 if (/* Don't CSE something if we can't do a reg/reg copy. */
785 can_copy_p (GET_MODE (dest))
786 /* Is SET_SRC something we want to gcse? */
787 && general_operand (src, GET_MODE (src))
788 #ifdef STACK_REGS
789 /* Never consider insns touching the register stack. It may
790 create situations that reg-stack cannot handle (e.g. a stack
791 register live across an abnormal edge). */
792 && (REGNO (dest) < FIRST_STACK_REG || REGNO (dest) > LAST_STACK_REG)
793 #endif
794 /* An expression is not available if its operands are
795 subsequently modified, including this insn. */
796 && oprs_unchanged_p (src, insn, true))
798 insert_expr_in_table (src, insn);
801 else if (REG_P (src))
803 /* Only record sets of pseudo-regs in the hash table. */
804 if (/* Don't CSE something if we can't do a reg/reg copy. */
805 can_copy_p (GET_MODE (src))
806 /* Is SET_DEST something we want to gcse? */
807 && general_operand (dest, GET_MODE (dest))
808 #ifdef STACK_REGS
809 /* As above for STACK_REGS. */
810 && (REGNO (src) < FIRST_STACK_REG || REGNO (src) > LAST_STACK_REG)
811 #endif
812 && ! (flag_float_store && FLOAT_MODE_P (GET_MODE (dest)))
813 /* Check if the memory expression is killed after insn. */
814 && ! load_killed_in_block_p (INSN_CUID (insn) + 1, dest, true)
815 && oprs_unchanged_p (XEXP (dest, 0), insn, true))
817 insert_expr_in_table (dest, insn);
823 /* Create hash table of memory expressions available at end of basic
824 blocks. Basically you should think of this hash table as the
825 representation of AVAIL_OUT. This is the set of expressions that
826 is generated in a basic block and not killed before the end of the
827 same basic block. Notice that this is really a local computation. */
829 static void
830 compute_hash_table (void)
832 basic_block bb;
834 FOR_EACH_BB (bb)
836 rtx insn;
838 /* First pass over the instructions records information used to
839 determine when registers and memory are last set.
840 Since we compute a "local" AVAIL_OUT, reset the tables that
841 help us keep track of what has been modified since the start
842 of the block. */
843 reset_opr_set_tables ();
844 FOR_BB_INSNS (bb, insn)
846 if (INSN_P (insn))
847 record_opr_changes (insn);
850 /* The next pass actually builds the hash table. */
851 FOR_BB_INSNS (bb, insn)
852 if (INSN_P (insn) && GET_CODE (PATTERN (insn)) == SET)
853 hash_scan_set (insn);
858 /* Check if register REG is killed in any insn waiting to be inserted on
859 edge E. This function is required to check that our data flow analysis
860 is still valid prior to commit_edge_insertions. */
862 static bool
863 reg_killed_on_edge (rtx reg, edge e)
865 rtx insn;
867 for (insn = e->insns.r; insn; insn = NEXT_INSN (insn))
868 if (INSN_P (insn) && reg_set_p (reg, insn))
869 return true;
871 return false;
874 /* Similar to above - check if register REG is used in any insn waiting
875 to be inserted on edge E.
876 Assumes no such insn can be a CALL_INSN; if so call reg_used_between_p
877 with PREV(insn),NEXT(insn) instead of calling reg_overlap_mentioned_p. */
879 static bool
880 reg_used_on_edge (rtx reg, edge e)
882 rtx insn;
884 for (insn = e->insns.r; insn; insn = NEXT_INSN (insn))
885 if (INSN_P (insn) && reg_overlap_mentioned_p (reg, PATTERN (insn)))
886 return true;
888 return false;
891 /* Return the loaded/stored register of a load/store instruction. */
893 static rtx
894 get_avail_load_store_reg (rtx insn)
896 if (REG_P (SET_DEST (PATTERN (insn))))
897 /* A load. */
898 return SET_DEST(PATTERN(insn));
899 else
901 /* A store. */
902 gcc_assert (REG_P (SET_SRC (PATTERN (insn))));
903 return SET_SRC (PATTERN (insn));
907 /* Return nonzero if the predecessors of BB are "well behaved". */
909 static bool
910 bb_has_well_behaved_predecessors (basic_block bb)
912 edge pred;
913 edge_iterator ei;
915 if (EDGE_COUNT (bb->preds) == 0)
916 return false;
918 FOR_EACH_EDGE (pred, ei, bb->preds)
920 if ((pred->flags & EDGE_ABNORMAL) && EDGE_CRITICAL_P (pred))
921 return false;
923 if ((pred->flags & EDGE_ABNORMAL_CALL) && cfun->has_nonlocal_label)
924 return false;
926 if (JUMP_TABLE_DATA_P (BB_END (pred->src)))
927 return false;
929 return true;
933 /* Search for the occurrences of expression in BB. */
935 static struct occr*
936 get_bb_avail_insn (basic_block bb, struct occr *occr)
938 for (; occr != NULL; occr = occr->next)
939 if (BLOCK_FOR_INSN (occr->insn) == bb)
940 return occr;
941 return NULL;
945 /* This handles the case where several stores feed a partially redundant
946 load. It checks if the redundancy elimination is possible and if it's
947 worth it.
949 Redundancy elimination is possible if,
950 1) None of the operands of an insn have been modified since the start
951 of the current basic block.
952 2) In any predecessor of the current basic block, the same expression
953 is generated.
955 See the function body for the heuristics that determine if eliminating
956 a redundancy is also worth doing, assuming it is possible. */
958 static void
959 eliminate_partially_redundant_load (basic_block bb, rtx insn,
960 struct expr *expr)
962 edge pred;
963 rtx avail_insn = NULL_RTX;
964 rtx avail_reg;
965 rtx dest, pat;
966 struct occr *a_occr;
967 struct unoccr *occr, *avail_occrs = NULL;
968 struct unoccr *unoccr, *unavail_occrs = NULL, *rollback_unoccr = NULL;
969 int npred_ok = 0;
970 gcov_type ok_count = 0; /* Redundant load execution count. */
971 gcov_type critical_count = 0; /* Execution count of critical edges. */
972 edge_iterator ei;
973 bool critical_edge_split = false;
975 /* The execution count of the loads to be added to make the
976 load fully redundant. */
977 gcov_type not_ok_count = 0;
978 basic_block pred_bb;
980 pat = PATTERN (insn);
981 dest = SET_DEST (pat);
983 /* Check that the loaded register is not used, set, or killed from the
984 beginning of the block. */
985 if (reg_changed_after_insn_p (dest, 0)
986 || reg_used_between_p (dest, PREV_INSN (BB_HEAD (bb)), insn))
987 return;
989 /* Check potential for replacing load with copy for predecessors. */
990 FOR_EACH_EDGE (pred, ei, bb->preds)
992 rtx next_pred_bb_end;
994 avail_insn = NULL_RTX;
995 avail_reg = NULL_RTX;
996 pred_bb = pred->src;
997 next_pred_bb_end = NEXT_INSN (BB_END (pred_bb));
998 for (a_occr = get_bb_avail_insn (pred_bb, expr->avail_occr); a_occr;
999 a_occr = get_bb_avail_insn (pred_bb, a_occr->next))
1001 /* Check if the loaded register is not used. */
1002 avail_insn = a_occr->insn;
1003 avail_reg = get_avail_load_store_reg (avail_insn);
1004 gcc_assert (avail_reg);
1006 /* Make sure we can generate a move from register avail_reg to
1007 dest. */
1008 extract_insn (gen_move_insn (copy_rtx (dest),
1009 copy_rtx (avail_reg)));
1010 if (! constrain_operands (1)
1011 || reg_killed_on_edge (avail_reg, pred)
1012 || reg_used_on_edge (dest, pred))
1014 avail_insn = NULL;
1015 continue;
1017 if (!reg_set_between_p (avail_reg, avail_insn, next_pred_bb_end))
1018 /* AVAIL_INSN remains non-null. */
1019 break;
1020 else
1021 avail_insn = NULL;
1024 if (EDGE_CRITICAL_P (pred))
1025 critical_count += pred->count;
1027 if (avail_insn != NULL_RTX)
1029 npred_ok++;
1030 ok_count += pred->count;
1031 if (! set_noop_p (PATTERN (gen_move_insn (copy_rtx (dest),
1032 copy_rtx (avail_reg)))))
1034 /* Check if there is going to be a split. */
1035 if (EDGE_CRITICAL_P (pred))
1036 critical_edge_split = true;
1038 else /* Its a dead move no need to generate. */
1039 continue;
1040 occr = (struct unoccr *) obstack_alloc (&unoccr_obstack,
1041 sizeof (struct unoccr));
1042 occr->insn = avail_insn;
1043 occr->pred = pred;
1044 occr->next = avail_occrs;
1045 avail_occrs = occr;
1046 if (! rollback_unoccr)
1047 rollback_unoccr = occr;
1049 else
1051 /* Adding a load on a critical edge will cause a split. */
1052 if (EDGE_CRITICAL_P (pred))
1053 critical_edge_split = true;
1054 not_ok_count += pred->count;
1055 unoccr = (struct unoccr *) obstack_alloc (&unoccr_obstack,
1056 sizeof (struct unoccr));
1057 unoccr->insn = NULL_RTX;
1058 unoccr->pred = pred;
1059 unoccr->next = unavail_occrs;
1060 unavail_occrs = unoccr;
1061 if (! rollback_unoccr)
1062 rollback_unoccr = unoccr;
1066 if (/* No load can be replaced by copy. */
1067 npred_ok == 0
1068 /* Prevent exploding the code. */
1069 || (optimize_bb_for_size_p (bb) && npred_ok > 1)
1070 /* If we don't have profile information we cannot tell if splitting
1071 a critical edge is profitable or not so don't do it. */
1072 || ((! profile_info || ! flag_branch_probabilities
1073 || targetm.cannot_modify_jumps_p ())
1074 && critical_edge_split))
1075 goto cleanup;
1077 /* Check if it's worth applying the partial redundancy elimination. */
1078 if (ok_count < GCSE_AFTER_RELOAD_PARTIAL_FRACTION * not_ok_count)
1079 goto cleanup;
1080 if (ok_count < GCSE_AFTER_RELOAD_CRITICAL_FRACTION * critical_count)
1081 goto cleanup;
1083 /* Generate moves to the loaded register from where
1084 the memory is available. */
1085 for (occr = avail_occrs; occr; occr = occr->next)
1087 avail_insn = occr->insn;
1088 pred = occr->pred;
1089 /* Set avail_reg to be the register having the value of the
1090 memory. */
1091 avail_reg = get_avail_load_store_reg (avail_insn);
1092 gcc_assert (avail_reg);
1094 insert_insn_on_edge (gen_move_insn (copy_rtx (dest),
1095 copy_rtx (avail_reg)),
1096 pred);
1097 stats.moves_inserted++;
1099 if (dump_file)
1100 fprintf (dump_file,
1101 "generating move from %d to %d on edge from %d to %d\n",
1102 REGNO (avail_reg),
1103 REGNO (dest),
1104 pred->src->index,
1105 pred->dest->index);
1108 /* Regenerate loads where the memory is unavailable. */
1109 for (unoccr = unavail_occrs; unoccr; unoccr = unoccr->next)
1111 pred = unoccr->pred;
1112 insert_insn_on_edge (copy_insn (PATTERN (insn)), pred);
1113 stats.copies_inserted++;
1115 if (dump_file)
1117 fprintf (dump_file,
1118 "generating on edge from %d to %d a copy of load: ",
1119 pred->src->index,
1120 pred->dest->index);
1121 print_rtl (dump_file, PATTERN (insn));
1122 fprintf (dump_file, "\n");
1126 /* Delete the insn if it is not available in this block and mark it
1127 for deletion if it is available. If insn is available it may help
1128 discover additional redundancies, so mark it for later deletion. */
1129 for (a_occr = get_bb_avail_insn (bb, expr->avail_occr);
1130 a_occr && (a_occr->insn != insn);
1131 a_occr = get_bb_avail_insn (bb, a_occr->next))
1134 if (!a_occr)
1136 stats.insns_deleted++;
1138 if (dump_file)
1140 fprintf (dump_file, "deleting insn:\n");
1141 print_rtl_single (dump_file, insn);
1142 fprintf (dump_file, "\n");
1144 delete_insn (insn);
1146 else
1147 a_occr->deleted_p = 1;
1149 cleanup:
1150 if (rollback_unoccr)
1151 obstack_free (&unoccr_obstack, rollback_unoccr);
1154 /* Performing the redundancy elimination as described before. */
1156 static void
1157 eliminate_partially_redundant_loads (void)
1159 rtx insn;
1160 basic_block bb;
1162 /* Note we start at block 1. */
1164 if (ENTRY_BLOCK_PTR->next_bb == EXIT_BLOCK_PTR)
1165 return;
1167 FOR_BB_BETWEEN (bb,
1168 ENTRY_BLOCK_PTR->next_bb->next_bb,
1169 EXIT_BLOCK_PTR,
1170 next_bb)
1172 /* Don't try anything on basic blocks with strange predecessors. */
1173 if (! bb_has_well_behaved_predecessors (bb))
1174 continue;
1176 /* Do not try anything on cold basic blocks. */
1177 if (optimize_bb_for_size_p (bb))
1178 continue;
1180 /* Reset the table of things changed since the start of the current
1181 basic block. */
1182 reset_opr_set_tables ();
1184 /* Look at all insns in the current basic block and see if there are
1185 any loads in it that we can record. */
1186 FOR_BB_INSNS (bb, insn)
1188 /* Is it a load - of the form (set (reg) (mem))? */
1189 if (NONJUMP_INSN_P (insn)
1190 && GET_CODE (PATTERN (insn)) == SET
1191 && REG_P (SET_DEST (PATTERN (insn)))
1192 && MEM_P (SET_SRC (PATTERN (insn))))
1194 rtx pat = PATTERN (insn);
1195 rtx src = SET_SRC (pat);
1196 struct expr *expr;
1198 if (!MEM_VOLATILE_P (src)
1199 && GET_MODE (src) != BLKmode
1200 && general_operand (src, GET_MODE (src))
1201 /* Are the operands unchanged since the start of the
1202 block? */
1203 && oprs_unchanged_p (src, insn, false)
1204 && !(cfun->can_throw_non_call_exceptions && may_trap_p (src))
1205 && !side_effects_p (src)
1206 /* Is the expression recorded? */
1207 && (expr = lookup_expr_in_table (src)) != NULL)
1209 /* We now have a load (insn) and an available memory at
1210 its BB start (expr). Try to remove the loads if it is
1211 redundant. */
1212 eliminate_partially_redundant_load (bb, insn, expr);
1216 /* Keep track of everything modified by this insn, so that we
1217 know what has been modified since the start of the current
1218 basic block. */
1219 if (INSN_P (insn))
1220 record_opr_changes (insn);
1224 commit_edge_insertions ();
1227 /* Go over the expression hash table and delete insns that were
1228 marked for later deletion. */
1230 /* This helper is called via htab_traverse. */
1231 static int
1232 delete_redundant_insns_1 (void **slot, void *data ATTRIBUTE_UNUSED)
1234 struct expr *expr = (struct expr *) *slot;
1235 struct occr *occr;
1237 for (occr = expr->avail_occr; occr != NULL; occr = occr->next)
1239 if (occr->deleted_p && dbg_cnt (gcse2_delete))
1241 delete_insn (occr->insn);
1242 stats.insns_deleted++;
1244 if (dump_file)
1246 fprintf (dump_file, "deleting insn:\n");
1247 print_rtl_single (dump_file, occr->insn);
1248 fprintf (dump_file, "\n");
1253 return 1;
1256 static void
1257 delete_redundant_insns (void)
1259 htab_traverse (expr_table, delete_redundant_insns_1, NULL);
1260 if (dump_file)
1261 fprintf (dump_file, "\n");
1264 /* Main entry point of the GCSE after reload - clean some redundant loads
1265 due to spilling. */
1267 static void
1268 gcse_after_reload_main (rtx f ATTRIBUTE_UNUSED)
1271 memset (&stats, 0, sizeof (stats));
1273 /* Allocate memory for this pass.
1274 Also computes and initializes the insns' CUIDs. */
1275 alloc_mem ();
1277 /* We need alias analysis. */
1278 init_alias_analysis ();
1280 compute_hash_table ();
1282 if (dump_file)
1283 dump_hash_table (dump_file);
1285 if (htab_elements (expr_table) > 0)
1287 eliminate_partially_redundant_loads ();
1288 delete_redundant_insns ();
1290 if (dump_file)
1292 fprintf (dump_file, "GCSE AFTER RELOAD stats:\n");
1293 fprintf (dump_file, "copies inserted: %d\n", stats.copies_inserted);
1294 fprintf (dump_file, "moves inserted: %d\n", stats.moves_inserted);
1295 fprintf (dump_file, "insns deleted: %d\n", stats.insns_deleted);
1296 fprintf (dump_file, "\n\n");
1299 statistics_counter_event (cfun, "copies inserted",
1300 stats.copies_inserted);
1301 statistics_counter_event (cfun, "moves inserted",
1302 stats.moves_inserted);
1303 statistics_counter_event (cfun, "insns deleted",
1304 stats.insns_deleted);
1307 /* We are finished with alias. */
1308 end_alias_analysis ();
1310 free_mem ();
1314 static bool
1315 gate_handle_gcse2 (void)
1317 return (optimize > 0 && flag_gcse_after_reload
1318 && optimize_function_for_speed_p (cfun));
1322 static unsigned int
1323 rest_of_handle_gcse2 (void)
1325 gcse_after_reload_main (get_insns ());
1326 rebuild_jump_labels (get_insns ());
1327 return 0;
1330 struct rtl_opt_pass pass_gcse2 =
1333 RTL_PASS,
1334 "gcse2", /* name */
1335 gate_handle_gcse2, /* gate */
1336 rest_of_handle_gcse2, /* execute */
1337 NULL, /* sub */
1338 NULL, /* next */
1339 0, /* static_pass_number */
1340 TV_GCSE_AFTER_RELOAD, /* tv_id */
1341 0, /* properties_required */
1342 0, /* properties_provided */
1343 0, /* properties_destroyed */
1344 0, /* todo_flags_start */
1345 TODO_verify_rtl_sharing
1346 | TODO_verify_flow | TODO_ggc_collect /* todo_flags_finish */