* pt.c (lookup_template_class_1): Splice out abi_tag attribute if
[official-gcc.git] / gcc / postreload-gcse.c
blobb81c402cc8a5086bacc6e3141168bd5780f70703
1 /* Post reload partially redundant load elimination
2 Copyright (C) 2004-2014 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 *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 *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 *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_insn *, bool);
222 static void record_last_reg_set_info (rtx_insn *, rtx);
223 static void record_last_reg_set_info_regno (rtx_insn *, int);
224 static void record_last_mem_set_info (rtx_insn *);
225 static void record_last_set_info (rtx, const_rtx, void *);
226 static void record_opr_changes (rtx_insn *);
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_insn *);
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_insn *);
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_insn *);
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_insn *,
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 *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_FN (bb, cfun)
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 = new hash_table<expr_hasher> (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 delete expr_table;
310 expr_table = NULL;
312 obstack_free (&expr_obstack, NULL);
313 obstack_free (&occr_obstack, NULL);
314 obstack_free (&unoccr_obstack, NULL);
315 obstack_free (&modifies_mem_obstack, NULL);
317 free (reg_avail_info);
321 /* Insert expression X in INSN in the hash TABLE.
322 If it is already present, record it as the last occurrence in INSN's
323 basic block. */
325 static void
326 insert_expr_in_table (rtx x, rtx_insn *insn)
328 int do_not_record_p;
329 hashval_t hash;
330 struct expr *cur_expr, **slot;
331 struct occr *avail_occr, *last_occr = NULL;
333 hash = hash_expr (x, &do_not_record_p);
335 /* Do not insert expression in the table if it contains volatile operands,
336 or if hash_expr determines the expression is something we don't want
337 to or can't handle. */
338 if (do_not_record_p)
339 return;
341 /* We anticipate that redundant expressions are rare, so for convenience
342 allocate a new hash table element here already and set its fields.
343 If we don't do this, we need a hack with a static struct expr. Anyway,
344 obstack_free is really fast and one more obstack_alloc doesn't hurt if
345 we're going to see more expressions later on. */
346 cur_expr = (struct expr *) obstack_alloc (&expr_obstack,
347 sizeof (struct expr));
348 cur_expr->expr = x;
349 cur_expr->hash = hash;
350 cur_expr->avail_occr = NULL;
352 slot = expr_table->find_slot_with_hash (cur_expr, hash, INSERT);
354 if (! (*slot))
355 /* The expression isn't found, so insert it. */
356 *slot = cur_expr;
357 else
359 /* The expression is already in the table, so roll back the
360 obstack and use the existing table entry. */
361 obstack_free (&expr_obstack, cur_expr);
362 cur_expr = *slot;
365 /* Search for another occurrence in the same basic block. */
366 avail_occr = cur_expr->avail_occr;
367 while (avail_occr
368 && BLOCK_FOR_INSN (avail_occr->insn) != BLOCK_FOR_INSN (insn))
370 /* If an occurrence isn't found, save a pointer to the end of
371 the list. */
372 last_occr = avail_occr;
373 avail_occr = avail_occr->next;
376 if (avail_occr)
377 /* Found another instance of the expression in the same basic block.
378 Prefer this occurrence to the currently recorded one. We want
379 the last one in the block and the block is scanned from start
380 to end. */
381 avail_occr->insn = insn;
382 else
384 /* First occurrence of this expression in this basic block. */
385 avail_occr = (struct occr *) obstack_alloc (&occr_obstack,
386 sizeof (struct occr));
388 /* First occurrence of this expression in any block? */
389 if (cur_expr->avail_occr == NULL)
390 cur_expr->avail_occr = avail_occr;
391 else
392 last_occr->next = avail_occr;
394 avail_occr->insn = insn;
395 avail_occr->next = NULL;
396 avail_occr->deleted_p = 0;
401 /* Lookup pattern PAT in the expression hash table.
402 The result is a pointer to the table entry, or NULL if not found. */
404 static struct expr *
405 lookup_expr_in_table (rtx pat)
407 int do_not_record_p;
408 struct expr **slot, *tmp_expr;
409 hashval_t hash = hash_expr (pat, &do_not_record_p);
411 if (do_not_record_p)
412 return NULL;
414 tmp_expr = (struct expr *) obstack_alloc (&expr_obstack,
415 sizeof (struct expr));
416 tmp_expr->expr = pat;
417 tmp_expr->hash = hash;
418 tmp_expr->avail_occr = NULL;
420 slot = expr_table->find_slot_with_hash (tmp_expr, hash, INSERT);
421 obstack_free (&expr_obstack, tmp_expr);
423 if (!slot)
424 return NULL;
425 else
426 return (*slot);
430 /* Dump all expressions and occurrences that are currently in the
431 expression hash table to FILE. */
433 /* This helper is called via htab_traverse. */
435 dump_expr_hash_table_entry (expr **slot, FILE *file)
437 struct expr *exprs = *slot;
438 struct occr *occr;
440 fprintf (file, "expr: ");
441 print_rtl (file, exprs->expr);
442 fprintf (file,"\nhashcode: %u\n", exprs->hash);
443 fprintf (file,"list of occurrences:\n");
444 occr = exprs->avail_occr;
445 while (occr)
447 rtx_insn *insn = occr->insn;
448 print_rtl_single (file, insn);
449 fprintf (file, "\n");
450 occr = occr->next;
452 fprintf (file, "\n");
453 return 1;
456 static void
457 dump_hash_table (FILE *file)
459 fprintf (file, "\n\nexpression hash table\n");
460 fprintf (file, "size %ld, %ld elements, %f collision/search ratio\n",
461 (long) expr_table->size (),
462 (long) expr_table->elements (),
463 expr_table->collisions ());
464 if (expr_table->elements () > 0)
466 fprintf (file, "\n\ntable entries:\n");
467 expr_table->traverse <FILE *, dump_expr_hash_table_entry> (file);
469 fprintf (file, "\n");
472 /* Return true if register X is recorded as being set by an instruction
473 whose CUID is greater than the one given. */
475 static bool
476 reg_changed_after_insn_p (rtx x, int cuid)
478 unsigned int regno, end_regno;
480 regno = REGNO (x);
481 end_regno = END_HARD_REGNO (x);
483 if (reg_avail_info[regno] > cuid)
484 return true;
485 while (++regno < end_regno);
486 return false;
489 /* Return nonzero if the operands of expression X are unchanged
490 1) from the start of INSN's basic block up to but not including INSN
491 if AFTER_INSN is false, or
492 2) from INSN to the end of INSN's basic block if AFTER_INSN is true. */
494 static bool
495 oprs_unchanged_p (rtx x, rtx_insn *insn, bool after_insn)
497 int i, j;
498 enum rtx_code code;
499 const char *fmt;
501 if (x == 0)
502 return 1;
504 code = GET_CODE (x);
505 switch (code)
507 case REG:
508 /* We are called after register allocation. */
509 gcc_assert (REGNO (x) < FIRST_PSEUDO_REGISTER);
510 if (after_insn)
511 return !reg_changed_after_insn_p (x, INSN_CUID (insn) - 1);
512 else
513 return !reg_changed_after_insn_p (x, 0);
515 case MEM:
516 if (load_killed_in_block_p (INSN_CUID (insn), x, after_insn))
517 return 0;
518 else
519 return oprs_unchanged_p (XEXP (x, 0), insn, after_insn);
521 case PC:
522 case CC0: /*FIXME*/
523 case CONST:
524 CASE_CONST_ANY:
525 case SYMBOL_REF:
526 case LABEL_REF:
527 case ADDR_VEC:
528 case ADDR_DIFF_VEC:
529 return 1;
531 case PRE_DEC:
532 case PRE_INC:
533 case POST_DEC:
534 case POST_INC:
535 case PRE_MODIFY:
536 case POST_MODIFY:
537 if (after_insn)
538 return 0;
539 break;
541 default:
542 break;
545 for (i = GET_RTX_LENGTH (code) - 1, fmt = GET_RTX_FORMAT (code); i >= 0; i--)
547 if (fmt[i] == 'e')
549 if (! oprs_unchanged_p (XEXP (x, i), insn, after_insn))
550 return 0;
552 else if (fmt[i] == 'E')
553 for (j = 0; j < XVECLEN (x, i); j++)
554 if (! oprs_unchanged_p (XVECEXP (x, i, j), insn, after_insn))
555 return 0;
558 return 1;
562 /* Used for communication between find_mem_conflicts and
563 load_killed_in_block_p. Nonzero if find_mem_conflicts finds a
564 conflict between two memory references.
565 This is a bit of a hack to work around the limitations of note_stores. */
566 static int mems_conflict_p;
568 /* DEST is the output of an instruction. If it is a memory reference, and
569 possibly conflicts with the load found in DATA, then set mems_conflict_p
570 to a nonzero value. */
572 static void
573 find_mem_conflicts (rtx dest, const_rtx setter ATTRIBUTE_UNUSED,
574 void *data)
576 rtx mem_op = (rtx) data;
578 while (GET_CODE (dest) == SUBREG
579 || GET_CODE (dest) == ZERO_EXTRACT
580 || GET_CODE (dest) == STRICT_LOW_PART)
581 dest = XEXP (dest, 0);
583 /* If DEST is not a MEM, then it will not conflict with the load. Note
584 that function calls are assumed to clobber memory, but are handled
585 elsewhere. */
586 if (! MEM_P (dest))
587 return;
589 if (true_dependence (dest, GET_MODE (dest), mem_op))
590 mems_conflict_p = 1;
594 /* Return nonzero if the expression in X (a memory reference) is killed
595 in the current basic block before (if AFTER_INSN is false) or after
596 (if AFTER_INSN is true) the insn with the CUID in UID_LIMIT.
598 This function assumes that the modifies_mem table is flushed when
599 the hash table construction or redundancy elimination phases start
600 processing a new basic block. */
602 static int
603 load_killed_in_block_p (int uid_limit, rtx x, bool after_insn)
605 struct modifies_mem *list_entry = modifies_mem_list;
607 while (list_entry)
609 rtx_insn *setter = list_entry->insn;
611 /* Ignore entries in the list that do not apply. */
612 if ((after_insn
613 && INSN_CUID (setter) < uid_limit)
614 || (! after_insn
615 && INSN_CUID (setter) > uid_limit))
617 list_entry = list_entry->next;
618 continue;
621 /* If SETTER is a call everything is clobbered. Note that calls
622 to pure functions are never put on the list, so we need not
623 worry about them. */
624 if (CALL_P (setter))
625 return 1;
627 /* SETTER must be an insn of some kind that sets memory. Call
628 note_stores to examine each hunk of memory that is modified.
629 It will set mems_conflict_p to nonzero if there may be a
630 conflict between X and SETTER. */
631 mems_conflict_p = 0;
632 note_stores (PATTERN (setter), find_mem_conflicts, x);
633 if (mems_conflict_p)
634 return 1;
636 list_entry = list_entry->next;
638 return 0;
642 /* Record register first/last/block set information for REGNO in INSN. */
644 static inline void
645 record_last_reg_set_info (rtx_insn *insn, rtx reg)
647 unsigned int regno, end_regno;
649 regno = REGNO (reg);
650 end_regno = END_HARD_REGNO (reg);
652 reg_avail_info[regno] = INSN_CUID (insn);
653 while (++regno < end_regno);
656 static inline void
657 record_last_reg_set_info_regno (rtx_insn *insn, int regno)
659 reg_avail_info[regno] = INSN_CUID (insn);
663 /* Record memory modification information for INSN. We do not actually care
664 about the memory location(s) that are set, or even how they are set (consider
665 a CALL_INSN). We merely need to record which insns modify memory. */
667 static void
668 record_last_mem_set_info (rtx_insn *insn)
670 struct modifies_mem *list_entry;
672 list_entry = (struct modifies_mem *) obstack_alloc (&modifies_mem_obstack,
673 sizeof (struct modifies_mem));
674 list_entry->insn = insn;
675 list_entry->next = modifies_mem_list;
676 modifies_mem_list = list_entry;
679 /* Called from compute_hash_table via note_stores to handle one
680 SET or CLOBBER in an insn. DATA is really the instruction in which
681 the SET is taking place. */
683 static void
684 record_last_set_info (rtx dest, const_rtx setter ATTRIBUTE_UNUSED, void *data)
686 rtx_insn *last_set_insn = (rtx_insn *) data;
688 if (GET_CODE (dest) == SUBREG)
689 dest = SUBREG_REG (dest);
691 if (REG_P (dest))
692 record_last_reg_set_info (last_set_insn, dest);
693 else if (MEM_P (dest))
695 /* Ignore pushes, they don't clobber memory. They may still
696 clobber the stack pointer though. Some targets do argument
697 pushes without adding REG_INC notes. See e.g. PR25196,
698 where a pushsi2 on i386 doesn't have REG_INC notes. Note
699 such changes here too. */
700 if (! push_operand (dest, GET_MODE (dest)))
701 record_last_mem_set_info (last_set_insn);
702 else
703 record_last_reg_set_info_regno (last_set_insn, STACK_POINTER_REGNUM);
708 /* Reset tables used to keep track of what's still available since the
709 start of the block. */
711 static void
712 reset_opr_set_tables (void)
714 memset (reg_avail_info, 0, FIRST_PSEUDO_REGISTER * sizeof (int));
715 obstack_free (&modifies_mem_obstack, modifies_mem_obstack_bottom);
716 modifies_mem_list = NULL;
720 /* Record things set by INSN.
721 This data is used by oprs_unchanged_p. */
723 static void
724 record_opr_changes (rtx_insn *insn)
726 rtx note;
728 /* Find all stores and record them. */
729 note_stores (PATTERN (insn), record_last_set_info, insn);
731 /* Also record autoincremented REGs for this insn as changed. */
732 for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
733 if (REG_NOTE_KIND (note) == REG_INC)
734 record_last_reg_set_info (insn, XEXP (note, 0));
736 /* Finally, if this is a call, record all call clobbers. */
737 if (CALL_P (insn))
739 unsigned int regno;
740 rtx link, x;
741 hard_reg_set_iterator hrsi;
742 EXECUTE_IF_SET_IN_HARD_REG_SET (regs_invalidated_by_call, 0, regno, hrsi)
743 record_last_reg_set_info_regno (insn, regno);
745 for (link = CALL_INSN_FUNCTION_USAGE (insn); link; link = XEXP (link, 1))
746 if (GET_CODE (XEXP (link, 0)) == CLOBBER)
748 x = XEXP (XEXP (link, 0), 0);
749 if (REG_P (x))
751 gcc_assert (HARD_REGISTER_P (x));
752 record_last_reg_set_info (insn, x);
756 if (! RTL_CONST_OR_PURE_CALL_P (insn))
757 record_last_mem_set_info (insn);
762 /* Scan the pattern of INSN and add an entry to the hash TABLE.
763 After reload we are interested in loads/stores only. */
765 static void
766 hash_scan_set (rtx_insn *insn)
768 rtx pat = PATTERN (insn);
769 rtx src = SET_SRC (pat);
770 rtx dest = SET_DEST (pat);
772 /* We are only interested in loads and stores. */
773 if (! MEM_P (src) && ! MEM_P (dest))
774 return;
776 /* Don't mess with jumps and nops. */
777 if (JUMP_P (insn) || set_noop_p (pat))
778 return;
780 if (REG_P (dest))
782 if (/* Don't CSE something if we can't do a reg/reg copy. */
783 can_copy_p (GET_MODE (dest))
784 /* Is SET_SRC something we want to gcse? */
785 && general_operand (src, GET_MODE (src))
786 #ifdef STACK_REGS
787 /* Never consider insns touching the register stack. It may
788 create situations that reg-stack cannot handle (e.g. a stack
789 register live across an abnormal edge). */
790 && (REGNO (dest) < FIRST_STACK_REG || REGNO (dest) > LAST_STACK_REG)
791 #endif
792 /* An expression is not available if its operands are
793 subsequently modified, including this insn. */
794 && oprs_unchanged_p (src, insn, true))
796 insert_expr_in_table (src, insn);
799 else if (REG_P (src))
801 /* Only record sets of pseudo-regs in the hash table. */
802 if (/* Don't CSE something if we can't do a reg/reg copy. */
803 can_copy_p (GET_MODE (src))
804 /* Is SET_DEST something we want to gcse? */
805 && general_operand (dest, GET_MODE (dest))
806 #ifdef STACK_REGS
807 /* As above for STACK_REGS. */
808 && (REGNO (src) < FIRST_STACK_REG || REGNO (src) > LAST_STACK_REG)
809 #endif
810 && ! (flag_float_store && FLOAT_MODE_P (GET_MODE (dest)))
811 /* Check if the memory expression is killed after insn. */
812 && ! load_killed_in_block_p (INSN_CUID (insn) + 1, dest, true)
813 && oprs_unchanged_p (XEXP (dest, 0), insn, true))
815 insert_expr_in_table (dest, insn);
821 /* Create hash table of memory expressions available at end of basic
822 blocks. Basically you should think of this hash table as the
823 representation of AVAIL_OUT. This is the set of expressions that
824 is generated in a basic block and not killed before the end of the
825 same basic block. Notice that this is really a local computation. */
827 static void
828 compute_hash_table (void)
830 basic_block bb;
832 FOR_EACH_BB_FN (bb, cfun)
834 rtx_insn *insn;
836 /* First pass over the instructions records information used to
837 determine when registers and memory are last set.
838 Since we compute a "local" AVAIL_OUT, reset the tables that
839 help us keep track of what has been modified since the start
840 of the block. */
841 reset_opr_set_tables ();
842 FOR_BB_INSNS (bb, insn)
844 if (INSN_P (insn))
845 record_opr_changes (insn);
848 /* The next pass actually builds the hash table. */
849 FOR_BB_INSNS (bb, insn)
850 if (INSN_P (insn) && GET_CODE (PATTERN (insn)) == SET)
851 hash_scan_set (insn);
856 /* Check if register REG is killed in any insn waiting to be inserted on
857 edge E. This function is required to check that our data flow analysis
858 is still valid prior to commit_edge_insertions. */
860 static bool
861 reg_killed_on_edge (rtx reg, edge e)
863 rtx_insn *insn;
865 for (insn = e->insns.r; insn; insn = NEXT_INSN (insn))
866 if (INSN_P (insn) && reg_set_p (reg, insn))
867 return true;
869 return false;
872 /* Similar to above - check if register REG is used in any insn waiting
873 to be inserted on edge E.
874 Assumes no such insn can be a CALL_INSN; if so call reg_used_between_p
875 with PREV(insn),NEXT(insn) instead of calling reg_overlap_mentioned_p. */
877 static bool
878 reg_used_on_edge (rtx reg, edge e)
880 rtx_insn *insn;
882 for (insn = e->insns.r; insn; insn = NEXT_INSN (insn))
883 if (INSN_P (insn) && reg_overlap_mentioned_p (reg, PATTERN (insn)))
884 return true;
886 return false;
889 /* Return the loaded/stored register of a load/store instruction. */
891 static rtx
892 get_avail_load_store_reg (rtx_insn *insn)
894 if (REG_P (SET_DEST (PATTERN (insn))))
895 /* A load. */
896 return SET_DEST (PATTERN (insn));
897 else
899 /* A store. */
900 gcc_assert (REG_P (SET_SRC (PATTERN (insn))));
901 return SET_SRC (PATTERN (insn));
905 /* Return nonzero if the predecessors of BB are "well behaved". */
907 static bool
908 bb_has_well_behaved_predecessors (basic_block bb)
910 edge pred;
911 edge_iterator ei;
913 if (EDGE_COUNT (bb->preds) == 0)
914 return false;
916 FOR_EACH_EDGE (pred, ei, bb->preds)
918 if ((pred->flags & EDGE_ABNORMAL) && EDGE_CRITICAL_P (pred))
919 return false;
921 if ((pred->flags & EDGE_ABNORMAL_CALL) && cfun->has_nonlocal_label)
922 return false;
924 if (tablejump_p (BB_END (pred->src), NULL, NULL))
925 return false;
927 return true;
931 /* Search for the occurrences of expression in BB. */
933 static struct occr*
934 get_bb_avail_insn (basic_block bb, struct occr *occr)
936 for (; occr != NULL; occr = occr->next)
937 if (BLOCK_FOR_INSN (occr->insn) == bb)
938 return occr;
939 return NULL;
943 /* This handles the case where several stores feed a partially redundant
944 load. It checks if the redundancy elimination is possible and if it's
945 worth it.
947 Redundancy elimination is possible if,
948 1) None of the operands of an insn have been modified since the start
949 of the current basic block.
950 2) In any predecessor of the current basic block, the same expression
951 is generated.
953 See the function body for the heuristics that determine if eliminating
954 a redundancy is also worth doing, assuming it is possible. */
956 static void
957 eliminate_partially_redundant_load (basic_block bb, rtx_insn *insn,
958 struct expr *expr)
960 edge pred;
961 rtx_insn *avail_insn = NULL;
962 rtx avail_reg;
963 rtx dest, pat;
964 struct occr *a_occr;
965 struct unoccr *occr, *avail_occrs = NULL;
966 struct unoccr *unoccr, *unavail_occrs = NULL, *rollback_unoccr = NULL;
967 int npred_ok = 0;
968 gcov_type ok_count = 0; /* Redundant load execution count. */
969 gcov_type critical_count = 0; /* Execution count of critical edges. */
970 edge_iterator ei;
971 bool critical_edge_split = false;
973 /* The execution count of the loads to be added to make the
974 load fully redundant. */
975 gcov_type not_ok_count = 0;
976 basic_block pred_bb;
978 pat = PATTERN (insn);
979 dest = SET_DEST (pat);
981 /* Check that the loaded register is not used, set, or killed from the
982 beginning of the block. */
983 if (reg_changed_after_insn_p (dest, 0)
984 || reg_used_between_p (dest, PREV_INSN (BB_HEAD (bb)), insn))
985 return;
987 /* Check potential for replacing load with copy for predecessors. */
988 FOR_EACH_EDGE (pred, ei, bb->preds)
990 rtx_insn *next_pred_bb_end;
992 avail_insn = NULL;
993 avail_reg = NULL_RTX;
994 pred_bb = pred->src;
995 next_pred_bb_end = NEXT_INSN (BB_END (pred_bb));
996 for (a_occr = get_bb_avail_insn (pred_bb, expr->avail_occr); a_occr;
997 a_occr = get_bb_avail_insn (pred_bb, a_occr->next))
999 /* Check if the loaded register is not used. */
1000 avail_insn = a_occr->insn;
1001 avail_reg = get_avail_load_store_reg (avail_insn);
1002 gcc_assert (avail_reg);
1004 /* Make sure we can generate a move from register avail_reg to
1005 dest. */
1006 extract_insn (as_a <rtx_insn *> (
1007 gen_move_insn (copy_rtx (dest),
1008 copy_rtx (avail_reg))));
1009 if (! constrain_operands (1)
1010 || reg_killed_on_edge (avail_reg, pred)
1011 || reg_used_on_edge (dest, pred))
1013 avail_insn = NULL;
1014 continue;
1016 if (!reg_set_between_p (avail_reg, avail_insn, next_pred_bb_end))
1017 /* AVAIL_INSN remains non-null. */
1018 break;
1019 else
1020 avail_insn = NULL;
1023 if (EDGE_CRITICAL_P (pred))
1024 critical_count += pred->count;
1026 if (avail_insn != NULL_RTX)
1028 npred_ok++;
1029 ok_count += pred->count;
1030 if (! set_noop_p (PATTERN (gen_move_insn (copy_rtx (dest),
1031 copy_rtx (avail_reg)))))
1033 /* Check if there is going to be a split. */
1034 if (EDGE_CRITICAL_P (pred))
1035 critical_edge_split = true;
1037 else /* Its a dead move no need to generate. */
1038 continue;
1039 occr = (struct unoccr *) obstack_alloc (&unoccr_obstack,
1040 sizeof (struct unoccr));
1041 occr->insn = avail_insn;
1042 occr->pred = pred;
1043 occr->next = avail_occrs;
1044 avail_occrs = occr;
1045 if (! rollback_unoccr)
1046 rollback_unoccr = occr;
1048 else
1050 /* Adding a load on a critical edge will cause a split. */
1051 if (EDGE_CRITICAL_P (pred))
1052 critical_edge_split = true;
1053 not_ok_count += pred->count;
1054 unoccr = (struct unoccr *) obstack_alloc (&unoccr_obstack,
1055 sizeof (struct unoccr));
1056 unoccr->insn = NULL;
1057 unoccr->pred = pred;
1058 unoccr->next = unavail_occrs;
1059 unavail_occrs = unoccr;
1060 if (! rollback_unoccr)
1061 rollback_unoccr = unoccr;
1065 if (/* No load can be replaced by copy. */
1066 npred_ok == 0
1067 /* Prevent exploding the code. */
1068 || (optimize_bb_for_size_p (bb) && npred_ok > 1)
1069 /* If we don't have profile information we cannot tell if splitting
1070 a critical edge is profitable or not so don't do it. */
1071 || ((! profile_info || ! flag_branch_probabilities
1072 || targetm.cannot_modify_jumps_p ())
1073 && critical_edge_split))
1074 goto cleanup;
1076 /* Check if it's worth applying the partial redundancy elimination. */
1077 if (ok_count < GCSE_AFTER_RELOAD_PARTIAL_FRACTION * not_ok_count)
1078 goto cleanup;
1079 if (ok_count < GCSE_AFTER_RELOAD_CRITICAL_FRACTION * critical_count)
1080 goto cleanup;
1082 /* Generate moves to the loaded register from where
1083 the memory is available. */
1084 for (occr = avail_occrs; occr; occr = occr->next)
1086 avail_insn = occr->insn;
1087 pred = occr->pred;
1088 /* Set avail_reg to be the register having the value of the
1089 memory. */
1090 avail_reg = get_avail_load_store_reg (avail_insn);
1091 gcc_assert (avail_reg);
1093 insert_insn_on_edge (gen_move_insn (copy_rtx (dest),
1094 copy_rtx (avail_reg)),
1095 pred);
1096 stats.moves_inserted++;
1098 if (dump_file)
1099 fprintf (dump_file,
1100 "generating move from %d to %d on edge from %d to %d\n",
1101 REGNO (avail_reg),
1102 REGNO (dest),
1103 pred->src->index,
1104 pred->dest->index);
1107 /* Regenerate loads where the memory is unavailable. */
1108 for (unoccr = unavail_occrs; unoccr; unoccr = unoccr->next)
1110 pred = unoccr->pred;
1111 insert_insn_on_edge (copy_insn (PATTERN (insn)), pred);
1112 stats.copies_inserted++;
1114 if (dump_file)
1116 fprintf (dump_file,
1117 "generating on edge from %d to %d a copy of load: ",
1118 pred->src->index,
1119 pred->dest->index);
1120 print_rtl (dump_file, PATTERN (insn));
1121 fprintf (dump_file, "\n");
1125 /* Delete the insn if it is not available in this block and mark it
1126 for deletion if it is available. If insn is available it may help
1127 discover additional redundancies, so mark it for later deletion. */
1128 for (a_occr = get_bb_avail_insn (bb, expr->avail_occr);
1129 a_occr && (a_occr->insn != insn);
1130 a_occr = get_bb_avail_insn (bb, a_occr->next))
1133 if (!a_occr)
1135 stats.insns_deleted++;
1137 if (dump_file)
1139 fprintf (dump_file, "deleting insn:\n");
1140 print_rtl_single (dump_file, insn);
1141 fprintf (dump_file, "\n");
1143 delete_insn (insn);
1145 else
1146 a_occr->deleted_p = 1;
1148 cleanup:
1149 if (rollback_unoccr)
1150 obstack_free (&unoccr_obstack, rollback_unoccr);
1153 /* Performing the redundancy elimination as described before. */
1155 static void
1156 eliminate_partially_redundant_loads (void)
1158 rtx_insn *insn;
1159 basic_block bb;
1161 /* Note we start at block 1. */
1163 if (ENTRY_BLOCK_PTR_FOR_FN (cfun)->next_bb == EXIT_BLOCK_PTR_FOR_FN (cfun))
1164 return;
1166 FOR_BB_BETWEEN (bb,
1167 ENTRY_BLOCK_PTR_FOR_FN (cfun)->next_bb->next_bb,
1168 EXIT_BLOCK_PTR_FOR_FN (cfun),
1169 next_bb)
1171 /* Don't try anything on basic blocks with strange predecessors. */
1172 if (! bb_has_well_behaved_predecessors (bb))
1173 continue;
1175 /* Do not try anything on cold basic blocks. */
1176 if (optimize_bb_for_size_p (bb))
1177 continue;
1179 /* Reset the table of things changed since the start of the current
1180 basic block. */
1181 reset_opr_set_tables ();
1183 /* Look at all insns in the current basic block and see if there are
1184 any loads in it that we can record. */
1185 FOR_BB_INSNS (bb, insn)
1187 /* Is it a load - of the form (set (reg) (mem))? */
1188 if (NONJUMP_INSN_P (insn)
1189 && GET_CODE (PATTERN (insn)) == SET
1190 && REG_P (SET_DEST (PATTERN (insn)))
1191 && MEM_P (SET_SRC (PATTERN (insn))))
1193 rtx pat = PATTERN (insn);
1194 rtx src = SET_SRC (pat);
1195 struct expr *expr;
1197 if (!MEM_VOLATILE_P (src)
1198 && GET_MODE (src) != BLKmode
1199 && general_operand (src, GET_MODE (src))
1200 /* Are the operands unchanged since the start of the
1201 block? */
1202 && oprs_unchanged_p (src, insn, false)
1203 && !(cfun->can_throw_non_call_exceptions && may_trap_p (src))
1204 && !side_effects_p (src)
1205 /* Is the expression recorded? */
1206 && (expr = lookup_expr_in_table (src)) != NULL)
1208 /* We now have a load (insn) and an available memory at
1209 its BB start (expr). Try to remove the loads if it is
1210 redundant. */
1211 eliminate_partially_redundant_load (bb, insn, expr);
1215 /* Keep track of everything modified by this insn, so that we
1216 know what has been modified since the start of the current
1217 basic block. */
1218 if (INSN_P (insn))
1219 record_opr_changes (insn);
1223 commit_edge_insertions ();
1226 /* Go over the expression hash table and delete insns that were
1227 marked for later deletion. */
1229 /* This helper is called via htab_traverse. */
1231 delete_redundant_insns_1 (expr **slot, void *data ATTRIBUTE_UNUSED)
1233 struct expr *exprs = *slot;
1234 struct occr *occr;
1236 for (occr = exprs->avail_occr; occr != NULL; occr = occr->next)
1238 if (occr->deleted_p && dbg_cnt (gcse2_delete))
1240 delete_insn (occr->insn);
1241 stats.insns_deleted++;
1243 if (dump_file)
1245 fprintf (dump_file, "deleting insn:\n");
1246 print_rtl_single (dump_file, occr->insn);
1247 fprintf (dump_file, "\n");
1252 return 1;
1255 static void
1256 delete_redundant_insns (void)
1258 expr_table->traverse <void *, delete_redundant_insns_1> (NULL);
1259 if (dump_file)
1260 fprintf (dump_file, "\n");
1263 /* Main entry point of the GCSE after reload - clean some redundant loads
1264 due to spilling. */
1266 static void
1267 gcse_after_reload_main (rtx f ATTRIBUTE_UNUSED)
1270 memset (&stats, 0, sizeof (stats));
1272 /* Allocate memory for this pass.
1273 Also computes and initializes the insns' CUIDs. */
1274 alloc_mem ();
1276 /* We need alias analysis. */
1277 init_alias_analysis ();
1279 compute_hash_table ();
1281 if (dump_file)
1282 dump_hash_table (dump_file);
1284 if (expr_table->elements () > 0)
1286 eliminate_partially_redundant_loads ();
1287 delete_redundant_insns ();
1289 if (dump_file)
1291 fprintf (dump_file, "GCSE AFTER RELOAD stats:\n");
1292 fprintf (dump_file, "copies inserted: %d\n", stats.copies_inserted);
1293 fprintf (dump_file, "moves inserted: %d\n", stats.moves_inserted);
1294 fprintf (dump_file, "insns deleted: %d\n", stats.insns_deleted);
1295 fprintf (dump_file, "\n\n");
1298 statistics_counter_event (cfun, "copies inserted",
1299 stats.copies_inserted);
1300 statistics_counter_event (cfun, "moves inserted",
1301 stats.moves_inserted);
1302 statistics_counter_event (cfun, "insns deleted",
1303 stats.insns_deleted);
1306 /* We are finished with alias. */
1307 end_alias_analysis ();
1309 free_mem ();
1314 static unsigned int
1315 rest_of_handle_gcse2 (void)
1317 gcse_after_reload_main (get_insns ());
1318 rebuild_jump_labels (get_insns ());
1319 return 0;
1322 namespace {
1324 const pass_data pass_data_gcse2 =
1326 RTL_PASS, /* type */
1327 "gcse2", /* name */
1328 OPTGROUP_NONE, /* optinfo_flags */
1329 TV_GCSE_AFTER_RELOAD, /* tv_id */
1330 0, /* properties_required */
1331 0, /* properties_provided */
1332 0, /* properties_destroyed */
1333 0, /* todo_flags_start */
1334 0, /* todo_flags_finish */
1337 class pass_gcse2 : public rtl_opt_pass
1339 public:
1340 pass_gcse2 (gcc::context *ctxt)
1341 : rtl_opt_pass (pass_data_gcse2, ctxt)
1344 /* opt_pass methods: */
1345 virtual bool gate (function *fun)
1347 return (optimize > 0 && flag_gcse_after_reload
1348 && optimize_function_for_speed_p (fun));
1351 virtual unsigned int execute (function *) { return rest_of_handle_gcse2 (); }
1353 }; // class pass_gcse2
1355 } // anon namespace
1357 rtl_opt_pass *
1358 make_pass_gcse2 (gcc::context *ctxt)
1360 return new pass_gcse2 (ctxt);