1 /* Common subexpression elimination library for GNU compiler.
2 Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
4 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
30 #include "hard-reg-set.h"
32 #include "insn-config.h"
36 #include "diagnostic-core.h"
40 #include "tree-pass.h"
43 #include "alloc-pool.h"
47 /* A list of cselib_val structures. */
49 struct elt_list
*next
;
53 static bool cselib_record_memory
;
54 static bool cselib_preserve_constants
;
55 static int entry_and_rtx_equal_p (const void *, const void *);
56 static hashval_t
get_value_hash (const void *);
57 static struct elt_list
*new_elt_list (struct elt_list
*, cselib_val
*);
58 static struct elt_loc_list
*new_elt_loc_list (struct elt_loc_list
*, rtx
);
59 static void unchain_one_value (cselib_val
*);
60 static void unchain_one_elt_list (struct elt_list
**);
61 static void unchain_one_elt_loc_list (struct elt_loc_list
**);
62 static int discard_useless_locs (void **, void *);
63 static int discard_useless_values (void **, void *);
64 static void remove_useless_values (void);
65 static int rtx_equal_for_cselib_1 (rtx
, rtx
, enum machine_mode
);
66 static unsigned int cselib_hash_rtx (rtx
, int, enum machine_mode
);
67 static cselib_val
*new_cselib_val (unsigned int, enum machine_mode
, rtx
);
68 static void add_mem_for_addr (cselib_val
*, cselib_val
*, rtx
);
69 static cselib_val
*cselib_lookup_mem (rtx
, int);
70 static void cselib_invalidate_regno (unsigned int, enum machine_mode
);
71 static void cselib_invalidate_mem (rtx
);
72 static void cselib_record_set (rtx
, cselib_val
*, cselib_val
*);
73 static void cselib_record_sets (rtx
);
75 struct expand_value_data
78 cselib_expand_callback callback
;
83 static rtx
cselib_expand_value_rtx_1 (rtx
, struct expand_value_data
*, int);
85 /* There are three ways in which cselib can look up an rtx:
86 - for a REG, the reg_values table (which is indexed by regno) is used
87 - for a MEM, we recursively look up its address and then follow the
88 addr_list of that value
89 - for everything else, we compute a hash value and go through the hash
90 table. Since different rtx's can still have the same hash value,
91 this involves walking the table entries for a given value and comparing
92 the locations of the entries with the rtx we are looking up. */
94 /* A table that enables us to look up elts by their value. */
95 static htab_t cselib_hash_table
;
97 /* This is a global so we don't have to pass this through every function.
98 It is used in new_elt_loc_list to set SETTING_INSN. */
99 static rtx cselib_current_insn
;
101 /* The unique id that the next create value will take. */
102 static unsigned int next_uid
;
104 /* The number of registers we had when the varrays were last resized. */
105 static unsigned int cselib_nregs
;
107 /* Count values without known locations, or with only locations that
108 wouldn't have been known except for debug insns. Whenever this
109 grows too big, we remove these useless values from the table.
111 Counting values with only debug values is a bit tricky. We don't
112 want to increment n_useless_values when we create a value for a
113 debug insn, for this would get n_useless_values out of sync, but we
114 want increment it if all locs in the list that were ever referenced
115 in nondebug insns are removed from the list.
117 In the general case, once we do that, we'd have to stop accepting
118 nondebug expressions in the loc list, to avoid having two values
119 equivalent that, without debug insns, would have been made into
120 separate values. However, because debug insns never introduce
121 equivalences themselves (no assignments), the only means for
122 growing loc lists is through nondebug assignments. If the locs
123 also happen to be referenced in debug insns, it will work just fine.
125 A consequence of this is that there's at most one debug-only loc in
126 each loc list. If we keep it in the first entry, testing whether
127 we have a debug-only loc list takes O(1).
129 Furthermore, since any additional entry in a loc list containing a
130 debug loc would have to come from an assignment (nondebug) that
131 references both the initial debug loc and the newly-equivalent loc,
132 the initial debug loc would be promoted to a nondebug loc, and the
133 loc list would not contain debug locs any more.
135 So the only case we have to be careful with in order to keep
136 n_useless_values in sync between debug and nondebug compilations is
137 to avoid incrementing n_useless_values when removing the single loc
138 from a value that turns out to not appear outside debug values. We
139 increment n_useless_debug_values instead, and leave such values
140 alone until, for other reasons, we garbage-collect useless
142 static int n_useless_values
;
143 static int n_useless_debug_values
;
145 /* Count values whose locs have been taken exclusively from debug
146 insns for the entire life of the value. */
147 static int n_debug_values
;
149 /* Number of useless values before we remove them from the hash table. */
150 #define MAX_USELESS_VALUES 32
152 /* This table maps from register number to values. It does not
153 contain pointers to cselib_val structures, but rather elt_lists.
154 The purpose is to be able to refer to the same register in
155 different modes. The first element of the list defines the mode in
156 which the register was set; if the mode is unknown or the value is
157 no longer valid in that mode, ELT will be NULL for the first
159 static struct elt_list
**reg_values
;
160 static unsigned int reg_values_size
;
161 #define REG_VALUES(i) reg_values[i]
163 /* The largest number of hard regs used by any entry added to the
164 REG_VALUES table. Cleared on each cselib_clear_table() invocation. */
165 static unsigned int max_value_regs
;
167 /* Here the set of indices I with REG_VALUES(I) != 0 is saved. This is used
168 in cselib_clear_table() for fast emptying. */
169 static unsigned int *used_regs
;
170 static unsigned int n_used_regs
;
172 /* We pass this to cselib_invalidate_mem to invalidate all of
173 memory for a non-const call instruction. */
174 static GTY(()) rtx callmem
;
176 /* Set by discard_useless_locs if it deleted the last location of any
178 static int values_became_useless
;
180 /* Used as stop element of the containing_mem list so we can check
181 presence in the list by checking the next pointer. */
182 static cselib_val dummy_val
;
184 /* If non-NULL, value of the eliminated arg_pointer_rtx or frame_pointer_rtx
185 that is constant through the whole function and should never be
187 static cselib_val
*cfa_base_preserved_val
;
188 static unsigned int cfa_base_preserved_regno
;
190 /* Used to list all values that contain memory reference.
191 May or may not contain the useless values - the list is compacted
192 each time memory is invalidated. */
193 static cselib_val
*first_containing_mem
= &dummy_val
;
194 static alloc_pool elt_loc_list_pool
, elt_list_pool
, cselib_val_pool
, value_pool
;
196 /* If nonnull, cselib will call this function before freeing useless
197 VALUEs. A VALUE is deemed useless if its "locs" field is null. */
198 void (*cselib_discard_hook
) (cselib_val
*);
200 /* If nonnull, cselib will call this function before recording sets or
201 even clobbering outputs of INSN. All the recorded sets will be
202 represented in the array sets[n_sets]. new_val_min can be used to
203 tell whether values present in sets are introduced by this
205 void (*cselib_record_sets_hook
) (rtx insn
, struct cselib_set
*sets
,
208 #define PRESERVED_VALUE_P(RTX) \
209 (RTL_FLAG_CHECK1("PRESERVED_VALUE_P", (RTX), VALUE)->unchanging)
213 /* Allocate a struct elt_list and fill in its two elements with the
216 static inline struct elt_list
*
217 new_elt_list (struct elt_list
*next
, cselib_val
*elt
)
220 el
= (struct elt_list
*) pool_alloc (elt_list_pool
);
226 /* Allocate a struct elt_loc_list and fill in its two elements with the
229 static inline struct elt_loc_list
*
230 new_elt_loc_list (struct elt_loc_list
*next
, rtx loc
)
232 struct elt_loc_list
*el
;
233 el
= (struct elt_loc_list
*) pool_alloc (elt_loc_list_pool
);
236 el
->setting_insn
= cselib_current_insn
;
237 gcc_assert (!next
|| !next
->setting_insn
238 || !DEBUG_INSN_P (next
->setting_insn
));
240 /* If we're creating the first loc in a debug insn context, we've
241 just created a debug value. Count it. */
242 if (!next
&& cselib_current_insn
&& DEBUG_INSN_P (cselib_current_insn
))
248 /* Promote loc L to a nondebug cselib_current_insn if L is marked as
249 originating from a debug insn, maintaining the debug values
253 promote_debug_loc (struct elt_loc_list
*l
)
255 if (l
->setting_insn
&& DEBUG_INSN_P (l
->setting_insn
)
256 && (!cselib_current_insn
|| !DEBUG_INSN_P (cselib_current_insn
)))
259 l
->setting_insn
= cselib_current_insn
;
260 gcc_assert (!l
->next
|| cselib_preserve_constants
);
264 /* The elt_list at *PL is no longer needed. Unchain it and free its
268 unchain_one_elt_list (struct elt_list
**pl
)
270 struct elt_list
*l
= *pl
;
273 pool_free (elt_list_pool
, l
);
276 /* Likewise for elt_loc_lists. */
279 unchain_one_elt_loc_list (struct elt_loc_list
**pl
)
281 struct elt_loc_list
*l
= *pl
;
284 pool_free (elt_loc_list_pool
, l
);
287 /* Likewise for cselib_vals. This also frees the addr_list associated with
291 unchain_one_value (cselib_val
*v
)
294 unchain_one_elt_list (&v
->addr_list
);
296 pool_free (cselib_val_pool
, v
);
299 /* Remove all entries from the hash table. Also used during
303 cselib_clear_table (void)
305 cselib_reset_table (1);
308 /* Remove from hash table all VALUEs except constants
309 and function invariants. */
312 preserve_only_constants (void **x
, void *info ATTRIBUTE_UNUSED
)
314 cselib_val
*v
= (cselib_val
*)*x
;
317 && v
->locs
->next
== NULL
)
319 if (CONSTANT_P (v
->locs
->loc
)
320 && (GET_CODE (v
->locs
->loc
) != CONST
321 || !references_value_p (v
->locs
->loc
, 0)))
323 if (cfa_base_preserved_val
)
325 if (v
== cfa_base_preserved_val
)
327 if (GET_CODE (v
->locs
->loc
) == PLUS
328 && CONST_INT_P (XEXP (v
->locs
->loc
, 1))
329 && XEXP (v
->locs
->loc
, 0) == cfa_base_preserved_val
->val_rtx
)
333 /* Keep around VALUEs that forward function invariant ENTRY_VALUEs
334 to corresponding parameter VALUEs. */
336 && v
->locs
->next
!= NULL
337 && v
->locs
->next
->next
== NULL
338 && GET_CODE (v
->locs
->next
->loc
) == ENTRY_VALUE
339 && GET_CODE (v
->locs
->loc
) == VALUE
)
342 htab_clear_slot (cselib_hash_table
, x
);
346 /* Remove all entries from the hash table, arranging for the next
347 value to be numbered NUM. */
350 cselib_reset_table (unsigned int num
)
356 if (cfa_base_preserved_val
)
358 unsigned int regno
= cfa_base_preserved_regno
;
359 unsigned int new_used_regs
= 0;
360 for (i
= 0; i
< n_used_regs
; i
++)
361 if (used_regs
[i
] == regno
)
367 REG_VALUES (used_regs
[i
]) = 0;
368 gcc_assert (new_used_regs
== 1);
369 n_used_regs
= new_used_regs
;
370 used_regs
[0] = regno
;
372 = hard_regno_nregs
[regno
][GET_MODE (cfa_base_preserved_val
->locs
->loc
)];
376 for (i
= 0; i
< n_used_regs
; i
++)
377 REG_VALUES (used_regs
[i
]) = 0;
381 if (cselib_preserve_constants
)
382 htab_traverse (cselib_hash_table
, preserve_only_constants
, NULL
);
384 htab_empty (cselib_hash_table
);
386 n_useless_values
= 0;
387 n_useless_debug_values
= 0;
392 first_containing_mem
= &dummy_val
;
395 /* Return the number of the next value that will be generated. */
398 cselib_get_next_uid (void)
403 /* See the documentation of cselib_find_slot below. */
404 static enum machine_mode find_slot_memmode
;
406 /* Search for X, whose hashcode is HASH, in CSELIB_HASH_TABLE,
407 INSERTing if requested. When X is part of the address of a MEM,
408 MEMMODE should specify the mode of the MEM. While searching the
409 table, MEMMODE is held in FIND_SLOT_MEMMODE, so that autoinc RTXs
410 in X can be resolved. */
413 cselib_find_slot (rtx x
, hashval_t hash
, enum insert_option insert
,
414 enum machine_mode memmode
)
417 find_slot_memmode
= memmode
;
418 slot
= htab_find_slot_with_hash (cselib_hash_table
, x
, hash
, insert
);
419 find_slot_memmode
= VOIDmode
;
423 /* The equality test for our hash table. The first argument ENTRY is a table
424 element (i.e. a cselib_val), while the second arg X is an rtx. We know
425 that all callers of htab_find_slot_with_hash will wrap CONST_INTs into a
426 CONST of an appropriate mode. */
429 entry_and_rtx_equal_p (const void *entry
, const void *x_arg
)
431 struct elt_loc_list
*l
;
432 const cselib_val
*const v
= (const cselib_val
*) entry
;
433 rtx x
= CONST_CAST_RTX ((const_rtx
)x_arg
);
434 enum machine_mode mode
= GET_MODE (x
);
436 gcc_assert (!CONST_INT_P (x
) && GET_CODE (x
) != CONST_FIXED
437 && (mode
!= VOIDmode
|| GET_CODE (x
) != CONST_DOUBLE
));
439 if (mode
!= GET_MODE (v
->val_rtx
))
442 /* Unwrap X if necessary. */
443 if (GET_CODE (x
) == CONST
444 && (CONST_INT_P (XEXP (x
, 0))
445 || GET_CODE (XEXP (x
, 0)) == CONST_FIXED
446 || GET_CODE (XEXP (x
, 0)) == CONST_DOUBLE
))
449 /* We don't guarantee that distinct rtx's have different hash values,
450 so we need to do a comparison. */
451 for (l
= v
->locs
; l
; l
= l
->next
)
452 if (rtx_equal_for_cselib_1 (l
->loc
, x
, find_slot_memmode
))
454 promote_debug_loc (l
);
461 /* The hash function for our hash table. The value is always computed with
462 cselib_hash_rtx when adding an element; this function just extracts the
463 hash value from a cselib_val structure. */
466 get_value_hash (const void *entry
)
468 const cselib_val
*const v
= (const cselib_val
*) entry
;
472 /* Return true if X contains a VALUE rtx. If ONLY_USELESS is set, we
473 only return true for values which point to a cselib_val whose value
474 element has been set to zero, which implies the cselib_val will be
478 references_value_p (const_rtx x
, int only_useless
)
480 const enum rtx_code code
= GET_CODE (x
);
481 const char *fmt
= GET_RTX_FORMAT (code
);
484 if (GET_CODE (x
) == VALUE
485 && (! only_useless
|| CSELIB_VAL_PTR (x
)->locs
== 0))
488 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
490 if (fmt
[i
] == 'e' && references_value_p (XEXP (x
, i
), only_useless
))
492 else if (fmt
[i
] == 'E')
493 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
494 if (references_value_p (XVECEXP (x
, i
, j
), only_useless
))
501 /* For all locations found in X, delete locations that reference useless
502 values (i.e. values without any location). Called through
506 discard_useless_locs (void **x
, void *info ATTRIBUTE_UNUSED
)
508 cselib_val
*v
= (cselib_val
*)*x
;
509 struct elt_loc_list
**p
= &v
->locs
;
510 bool had_locs
= v
->locs
!= NULL
;
511 rtx setting_insn
= v
->locs
? v
->locs
->setting_insn
: NULL
;
515 if (references_value_p ((*p
)->loc
, 1))
516 unchain_one_elt_loc_list (p
);
521 if (had_locs
&& v
->locs
== 0 && !PRESERVED_VALUE_P (v
->val_rtx
))
523 if (setting_insn
&& DEBUG_INSN_P (setting_insn
))
524 n_useless_debug_values
++;
527 values_became_useless
= 1;
532 /* If X is a value with no locations, remove it from the hashtable. */
535 discard_useless_values (void **x
, void *info ATTRIBUTE_UNUSED
)
537 cselib_val
*v
= (cselib_val
*)*x
;
539 if (v
->locs
== 0 && !PRESERVED_VALUE_P (v
->val_rtx
))
541 if (cselib_discard_hook
)
542 cselib_discard_hook (v
);
544 CSELIB_VAL_PTR (v
->val_rtx
) = NULL
;
545 htab_clear_slot (cselib_hash_table
, x
);
546 unchain_one_value (v
);
553 /* Clean out useless values (i.e. those which no longer have locations
554 associated with them) from the hash table. */
557 remove_useless_values (void)
561 /* First pass: eliminate locations that reference the value. That in
562 turn can make more values useless. */
565 values_became_useless
= 0;
566 htab_traverse (cselib_hash_table
, discard_useless_locs
, 0);
568 while (values_became_useless
);
570 /* Second pass: actually remove the values. */
572 p
= &first_containing_mem
;
573 for (v
= *p
; v
!= &dummy_val
; v
= v
->next_containing_mem
)
577 p
= &(*p
)->next_containing_mem
;
581 n_useless_values
+= n_useless_debug_values
;
582 n_debug_values
-= n_useless_debug_values
;
583 n_useless_debug_values
= 0;
585 htab_traverse (cselib_hash_table
, discard_useless_values
, 0);
587 gcc_assert (!n_useless_values
);
590 /* Arrange for a value to not be removed from the hash table even if
591 it becomes useless. */
594 cselib_preserve_value (cselib_val
*v
)
596 PRESERVED_VALUE_P (v
->val_rtx
) = 1;
599 /* Test whether a value is preserved. */
602 cselib_preserved_value_p (cselib_val
*v
)
604 return PRESERVED_VALUE_P (v
->val_rtx
);
607 /* Arrange for a REG value to be assumed constant through the whole function,
608 never invalidated and preserved across cselib_reset_table calls. */
611 cselib_preserve_cfa_base_value (cselib_val
*v
, unsigned int regno
)
613 if (cselib_preserve_constants
615 && REG_P (v
->locs
->loc
))
617 cfa_base_preserved_val
= v
;
618 cfa_base_preserved_regno
= regno
;
622 /* Clean all non-constant expressions in the hash table, but retain
626 cselib_preserve_only_values (void)
630 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
631 cselib_invalidate_regno (i
, reg_raw_mode
[i
]);
633 cselib_invalidate_mem (callmem
);
635 remove_useless_values ();
637 gcc_assert (first_containing_mem
== &dummy_val
);
640 /* Return the mode in which a register was last set. If X is not a
641 register, return its mode. If the mode in which the register was
642 set is not known, or the value was already clobbered, return
646 cselib_reg_set_mode (const_rtx x
)
651 if (REG_VALUES (REGNO (x
)) == NULL
652 || REG_VALUES (REGNO (x
))->elt
== NULL
)
655 return GET_MODE (REG_VALUES (REGNO (x
))->elt
->val_rtx
);
658 /* Return nonzero if we can prove that X and Y contain the same value, taking
659 our gathered information into account. */
662 rtx_equal_for_cselib_p (rtx x
, rtx y
)
664 return rtx_equal_for_cselib_1 (x
, y
, VOIDmode
);
667 /* If x is a PLUS or an autoinc operation, expand the operation,
668 storing the offset, if any, in *OFF. */
671 autoinc_split (rtx x
, rtx
*off
, enum machine_mode memmode
)
673 switch (GET_CODE (x
))
680 if (memmode
== VOIDmode
)
683 *off
= GEN_INT (-GET_MODE_SIZE (memmode
));
688 if (memmode
== VOIDmode
)
691 *off
= GEN_INT (GET_MODE_SIZE (memmode
));
707 /* Return nonzero if we can prove that X and Y contain the same value,
708 taking our gathered information into account. MEMMODE holds the
709 mode of the enclosing MEM, if any, as required to deal with autoinc
710 addressing modes. If X and Y are not (known to be) part of
711 addresses, MEMMODE should be VOIDmode. */
714 rtx_equal_for_cselib_1 (rtx x
, rtx y
, enum machine_mode memmode
)
720 if (REG_P (x
) || MEM_P (x
))
722 cselib_val
*e
= cselib_lookup (x
, GET_MODE (x
), 0, memmode
);
728 if (REG_P (y
) || MEM_P (y
))
730 cselib_val
*e
= cselib_lookup (y
, GET_MODE (y
), 0, memmode
);
739 if (GET_CODE (x
) == VALUE
&& GET_CODE (y
) == VALUE
)
740 return CSELIB_VAL_PTR (x
) == CSELIB_VAL_PTR (y
);
742 if (GET_CODE (x
) == VALUE
)
744 cselib_val
*e
= CSELIB_VAL_PTR (x
);
745 struct elt_loc_list
*l
;
747 for (l
= e
->locs
; l
; l
= l
->next
)
751 /* Avoid infinite recursion. */
752 if (REG_P (t
) || MEM_P (t
))
754 else if (rtx_equal_for_cselib_1 (t
, y
, memmode
))
761 if (GET_CODE (y
) == VALUE
)
763 cselib_val
*e
= CSELIB_VAL_PTR (y
);
764 struct elt_loc_list
*l
;
766 for (l
= e
->locs
; l
; l
= l
->next
)
770 if (REG_P (t
) || MEM_P (t
))
772 else if (rtx_equal_for_cselib_1 (x
, t
, memmode
))
779 if (GET_MODE (x
) != GET_MODE (y
))
782 if (GET_CODE (x
) != GET_CODE (y
))
784 rtx xorig
= x
, yorig
= y
;
785 rtx xoff
= NULL
, yoff
= NULL
;
787 x
= autoinc_split (x
, &xoff
, memmode
);
788 y
= autoinc_split (y
, &yoff
, memmode
);
793 if (xoff
&& !rtx_equal_for_cselib_1 (xoff
, yoff
, memmode
))
796 /* Don't recurse if nothing changed. */
797 if (x
!= xorig
|| y
!= yorig
)
798 return rtx_equal_for_cselib_1 (x
, y
, memmode
);
803 /* These won't be handled correctly by the code below. */
804 switch (GET_CODE (x
))
811 case DEBUG_IMPLICIT_PTR
:
812 return DEBUG_IMPLICIT_PTR_DECL (x
)
813 == DEBUG_IMPLICIT_PTR_DECL (y
);
815 case DEBUG_PARAMETER_REF
:
816 return DEBUG_PARAMETER_REF_DECL (x
)
817 == DEBUG_PARAMETER_REF_DECL (y
);
820 /* ENTRY_VALUEs are function invariant, it is thus undesirable to
821 use rtx_equal_for_cselib_1 to compare the operands. */
822 return rtx_equal_p (ENTRY_VALUE_EXP (x
), ENTRY_VALUE_EXP (y
));
825 return XEXP (x
, 0) == XEXP (y
, 0);
828 /* We have to compare any autoinc operations in the addresses
829 using this MEM's mode. */
830 return rtx_equal_for_cselib_1 (XEXP (x
, 0), XEXP (y
, 0), GET_MODE (x
));
837 fmt
= GET_RTX_FORMAT (code
);
839 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
846 if (XWINT (x
, i
) != XWINT (y
, i
))
852 if (XINT (x
, i
) != XINT (y
, i
))
858 /* Two vectors must have the same length. */
859 if (XVECLEN (x
, i
) != XVECLEN (y
, i
))
862 /* And the corresponding elements must match. */
863 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
864 if (! rtx_equal_for_cselib_1 (XVECEXP (x
, i
, j
),
865 XVECEXP (y
, i
, j
), memmode
))
871 && targetm
.commutative_p (x
, UNKNOWN
)
872 && rtx_equal_for_cselib_1 (XEXP (x
, 1), XEXP (y
, 0), memmode
)
873 && rtx_equal_for_cselib_1 (XEXP (x
, 0), XEXP (y
, 1), memmode
))
875 if (! rtx_equal_for_cselib_1 (XEXP (x
, i
), XEXP (y
, i
), memmode
))
881 if (strcmp (XSTR (x
, i
), XSTR (y
, i
)))
886 /* These are just backpointers, so they don't matter. */
893 /* It is believed that rtx's at this level will never
894 contain anything but integers and other rtx's,
895 except for within LABEL_REFs and SYMBOL_REFs. */
903 /* We need to pass down the mode of constants through the hash table
904 functions. For that purpose, wrap them in a CONST of the appropriate
907 wrap_constant (enum machine_mode mode
, rtx x
)
909 if (!CONST_INT_P (x
) && GET_CODE (x
) != CONST_FIXED
910 && (GET_CODE (x
) != CONST_DOUBLE
|| GET_MODE (x
) != VOIDmode
))
912 gcc_assert (mode
!= VOIDmode
);
913 return gen_rtx_CONST (mode
, x
);
916 /* Hash an rtx. Return 0 if we couldn't hash the rtx.
917 For registers and memory locations, we look up their cselib_val structure
918 and return its VALUE element.
919 Possible reasons for return 0 are: the object is volatile, or we couldn't
920 find a register or memory location in the table and CREATE is zero. If
921 CREATE is nonzero, table elts are created for regs and mem.
922 N.B. this hash function returns the same hash value for RTXes that
923 differ only in the order of operands, thus it is suitable for comparisons
924 that take commutativity into account.
925 If we wanted to also support associative rules, we'd have to use a different
926 strategy to avoid returning spurious 0, e.g. return ~(~0U >> 1) .
927 MEMMODE indicates the mode of an enclosing MEM, and it's only
928 used to compute autoinc values.
929 We used to have a MODE argument for hashing for CONST_INTs, but that
930 didn't make sense, since it caused spurious hash differences between
931 (set (reg:SI 1) (const_int))
932 (plus:SI (reg:SI 2) (reg:SI 1))
934 (plus:SI (reg:SI 2) (const_int))
935 If the mode is important in any context, it must be checked specifically
936 in a comparison anyway, since relying on hash differences is unsafe. */
939 cselib_hash_rtx (rtx x
, int create
, enum machine_mode memmode
)
945 unsigned int hash
= 0;
948 hash
+= (unsigned) code
+ (unsigned) GET_MODE (x
);
954 e
= cselib_lookup (x
, GET_MODE (x
), create
, memmode
);
961 hash
+= ((unsigned) DEBUG_EXPR
<< 7)
962 + DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (x
));
963 return hash
? hash
: (unsigned int) DEBUG_EXPR
;
965 case DEBUG_IMPLICIT_PTR
:
966 hash
+= ((unsigned) DEBUG_IMPLICIT_PTR
<< 7)
967 + DECL_UID (DEBUG_IMPLICIT_PTR_DECL (x
));
968 return hash
? hash
: (unsigned int) DEBUG_IMPLICIT_PTR
;
970 case DEBUG_PARAMETER_REF
:
971 hash
+= ((unsigned) DEBUG_PARAMETER_REF
<< 7)
972 + DECL_UID (DEBUG_PARAMETER_REF_DECL (x
));
973 return hash
? hash
: (unsigned int) DEBUG_PARAMETER_REF
;
976 /* ENTRY_VALUEs are function invariant, thus try to avoid
977 recursing on argument if ENTRY_VALUE is one of the
978 forms emitted by expand_debug_expr, otherwise
979 ENTRY_VALUE hash would depend on the current value
980 in some register or memory. */
981 if (REG_P (ENTRY_VALUE_EXP (x
)))
982 hash
+= (unsigned int) REG
983 + (unsigned int) GET_MODE (ENTRY_VALUE_EXP (x
))
984 + (unsigned int) REGNO (ENTRY_VALUE_EXP (x
));
985 else if (MEM_P (ENTRY_VALUE_EXP (x
))
986 && REG_P (XEXP (ENTRY_VALUE_EXP (x
), 0)))
987 hash
+= (unsigned int) MEM
988 + (unsigned int) GET_MODE (XEXP (ENTRY_VALUE_EXP (x
), 0))
989 + (unsigned int) REGNO (XEXP (ENTRY_VALUE_EXP (x
), 0));
991 hash
+= cselib_hash_rtx (ENTRY_VALUE_EXP (x
), create
, memmode
);
992 return hash
? hash
: (unsigned int) ENTRY_VALUE
;
995 hash
+= ((unsigned) CONST_INT
<< 7) + INTVAL (x
);
996 return hash
? hash
: (unsigned int) CONST_INT
;
999 /* This is like the general case, except that it only counts
1000 the integers representing the constant. */
1001 hash
+= (unsigned) code
+ (unsigned) GET_MODE (x
);
1002 if (GET_MODE (x
) != VOIDmode
)
1003 hash
+= real_hash (CONST_DOUBLE_REAL_VALUE (x
));
1005 hash
+= ((unsigned) CONST_DOUBLE_LOW (x
)
1006 + (unsigned) CONST_DOUBLE_HIGH (x
));
1007 return hash
? hash
: (unsigned int) CONST_DOUBLE
;
1010 hash
+= (unsigned int) code
+ (unsigned int) GET_MODE (x
);
1011 hash
+= fixed_hash (CONST_FIXED_VALUE (x
));
1012 return hash
? hash
: (unsigned int) CONST_FIXED
;
1019 units
= CONST_VECTOR_NUNITS (x
);
1021 for (i
= 0; i
< units
; ++i
)
1023 elt
= CONST_VECTOR_ELT (x
, i
);
1024 hash
+= cselib_hash_rtx (elt
, 0, memmode
);
1030 /* Assume there is only one rtx object for any given label. */
1032 /* We don't hash on the address of the CODE_LABEL to avoid bootstrap
1033 differences and differences between each stage's debugging dumps. */
1034 hash
+= (((unsigned int) LABEL_REF
<< 7)
1035 + CODE_LABEL_NUMBER (XEXP (x
, 0)));
1036 return hash
? hash
: (unsigned int) LABEL_REF
;
1040 /* Don't hash on the symbol's address to avoid bootstrap differences.
1041 Different hash values may cause expressions to be recorded in
1042 different orders and thus different registers to be used in the
1043 final assembler. This also avoids differences in the dump files
1044 between various stages. */
1046 const unsigned char *p
= (const unsigned char *) XSTR (x
, 0);
1049 h
+= (h
<< 7) + *p
++; /* ??? revisit */
1051 hash
+= ((unsigned int) SYMBOL_REF
<< 7) + h
;
1052 return hash
? hash
: (unsigned int) SYMBOL_REF
;
1057 /* We can't compute these without knowing the MEM mode. */
1058 gcc_assert (memmode
!= VOIDmode
);
1059 i
= GET_MODE_SIZE (memmode
);
1060 if (code
== PRE_DEC
)
1062 /* Adjust the hash so that (mem:MEMMODE (pre_* (reg))) hashes
1063 like (mem:MEMMODE (plus (reg) (const_int I))). */
1064 hash
+= (unsigned) PLUS
- (unsigned)code
1065 + cselib_hash_rtx (XEXP (x
, 0), create
, memmode
)
1066 + cselib_hash_rtx (GEN_INT (i
), create
, memmode
);
1067 return hash
? hash
: 1 + (unsigned) PLUS
;
1070 gcc_assert (memmode
!= VOIDmode
);
1071 return cselib_hash_rtx (XEXP (x
, 1), create
, memmode
);
1076 gcc_assert (memmode
!= VOIDmode
);
1077 return cselib_hash_rtx (XEXP (x
, 0), create
, memmode
);
1082 case UNSPEC_VOLATILE
:
1086 if (MEM_VOLATILE_P (x
))
1095 i
= GET_RTX_LENGTH (code
) - 1;
1096 fmt
= GET_RTX_FORMAT (code
);
1103 rtx tem
= XEXP (x
, i
);
1104 unsigned int tem_hash
= cselib_hash_rtx (tem
, create
, memmode
);
1113 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1115 unsigned int tem_hash
1116 = cselib_hash_rtx (XVECEXP (x
, i
, j
), create
, memmode
);
1127 const unsigned char *p
= (const unsigned char *) XSTR (x
, i
);
1136 hash
+= XINT (x
, i
);
1149 return hash
? hash
: 1 + (unsigned int) GET_CODE (x
);
1152 /* Create a new value structure for VALUE and initialize it. The mode of the
1155 static inline cselib_val
*
1156 new_cselib_val (unsigned int hash
, enum machine_mode mode
, rtx x
)
1158 cselib_val
*e
= (cselib_val
*) pool_alloc (cselib_val_pool
);
1161 gcc_assert (next_uid
);
1164 e
->uid
= next_uid
++;
1165 /* We use an alloc pool to allocate this RTL construct because it
1166 accounts for about 8% of the overall memory usage. We know
1167 precisely when we can have VALUE RTXen (when cselib is active)
1168 so we don't need to put them in garbage collected memory.
1169 ??? Why should a VALUE be an RTX in the first place? */
1170 e
->val_rtx
= (rtx
) pool_alloc (value_pool
);
1171 memset (e
->val_rtx
, 0, RTX_HDR_SIZE
);
1172 PUT_CODE (e
->val_rtx
, VALUE
);
1173 PUT_MODE (e
->val_rtx
, mode
);
1174 CSELIB_VAL_PTR (e
->val_rtx
) = e
;
1177 e
->next_containing_mem
= 0;
1179 if (dump_file
&& (dump_flags
& TDF_CSELIB
))
1181 fprintf (dump_file
, "cselib value %u:%u ", e
->uid
, hash
);
1182 if (flag_dump_noaddr
|| flag_dump_unnumbered
)
1183 fputs ("# ", dump_file
);
1185 fprintf (dump_file
, "%p ", (void*)e
);
1186 print_rtl_single (dump_file
, x
);
1187 fputc ('\n', dump_file
);
1193 /* ADDR_ELT is a value that is used as address. MEM_ELT is the value that
1194 contains the data at this address. X is a MEM that represents the
1195 value. Update the two value structures to represent this situation. */
1198 add_mem_for_addr (cselib_val
*addr_elt
, cselib_val
*mem_elt
, rtx x
)
1200 struct elt_loc_list
*l
;
1202 /* Avoid duplicates. */
1203 for (l
= mem_elt
->locs
; l
; l
= l
->next
)
1205 && CSELIB_VAL_PTR (XEXP (l
->loc
, 0)) == addr_elt
)
1207 promote_debug_loc (l
);
1211 addr_elt
->addr_list
= new_elt_list (addr_elt
->addr_list
, mem_elt
);
1213 = new_elt_loc_list (mem_elt
->locs
,
1214 replace_equiv_address_nv (x
, addr_elt
->val_rtx
));
1215 if (mem_elt
->next_containing_mem
== NULL
)
1217 mem_elt
->next_containing_mem
= first_containing_mem
;
1218 first_containing_mem
= mem_elt
;
1222 /* Subroutine of cselib_lookup. Return a value for X, which is a MEM rtx.
1223 If CREATE, make a new one if we haven't seen it before. */
1226 cselib_lookup_mem (rtx x
, int create
)
1228 enum machine_mode mode
= GET_MODE (x
);
1229 enum machine_mode addr_mode
;
1232 cselib_val
*mem_elt
;
1235 if (MEM_VOLATILE_P (x
) || mode
== BLKmode
1236 || !cselib_record_memory
1237 || (FLOAT_MODE_P (mode
) && flag_float_store
))
1240 addr_mode
= GET_MODE (XEXP (x
, 0));
1241 if (addr_mode
== VOIDmode
)
1244 /* Look up the value for the address. */
1245 addr
= cselib_lookup (XEXP (x
, 0), addr_mode
, create
, mode
);
1249 /* Find a value that describes a value of our mode at that address. */
1250 for (l
= addr
->addr_list
; l
; l
= l
->next
)
1251 if (GET_MODE (l
->elt
->val_rtx
) == mode
)
1253 promote_debug_loc (l
->elt
->locs
);
1260 mem_elt
= new_cselib_val (next_uid
, mode
, x
);
1261 add_mem_for_addr (addr
, mem_elt
, x
);
1262 slot
= cselib_find_slot (wrap_constant (mode
, x
), mem_elt
->hash
,
1268 /* Search thru the possible substitutions in P. We prefer a non reg
1269 substitution because this allows us to expand the tree further. If
1270 we find, just a reg, take the lowest regno. There may be several
1271 non-reg results, we just take the first one because they will all
1272 expand to the same place. */
1275 expand_loc (struct elt_loc_list
*p
, struct expand_value_data
*evd
,
1278 rtx reg_result
= NULL
;
1279 unsigned int regno
= UINT_MAX
;
1280 struct elt_loc_list
*p_in
= p
;
1282 for (; p
; p
= p
-> next
)
1284 /* Avoid infinite recursion trying to expand a reg into a
1286 if ((REG_P (p
->loc
))
1287 && (REGNO (p
->loc
) < regno
)
1288 && !bitmap_bit_p (evd
->regs_active
, REGNO (p
->loc
)))
1290 reg_result
= p
->loc
;
1291 regno
= REGNO (p
->loc
);
1293 /* Avoid infinite recursion and do not try to expand the
1295 else if (GET_CODE (p
->loc
) == VALUE
1296 && CSELIB_VAL_PTR (p
->loc
)->locs
== p_in
)
1298 else if (!REG_P (p
->loc
))
1301 if (dump_file
&& (dump_flags
& TDF_CSELIB
))
1303 print_inline_rtx (dump_file
, p
->loc
, 0);
1304 fprintf (dump_file
, "\n");
1306 if (GET_CODE (p
->loc
) == LO_SUM
1307 && GET_CODE (XEXP (p
->loc
, 1)) == SYMBOL_REF
1309 && (note
= find_reg_note (p
->setting_insn
, REG_EQUAL
, NULL_RTX
))
1310 && XEXP (note
, 0) == XEXP (p
->loc
, 1))
1311 return XEXP (p
->loc
, 1);
1312 result
= cselib_expand_value_rtx_1 (p
->loc
, evd
, max_depth
- 1);
1319 if (regno
!= UINT_MAX
)
1322 if (dump_file
&& (dump_flags
& TDF_CSELIB
))
1323 fprintf (dump_file
, "r%d\n", regno
);
1325 result
= cselib_expand_value_rtx_1 (reg_result
, evd
, max_depth
- 1);
1330 if (dump_file
&& (dump_flags
& TDF_CSELIB
))
1334 print_inline_rtx (dump_file
, reg_result
, 0);
1335 fprintf (dump_file
, "\n");
1338 fprintf (dump_file
, "NULL\n");
1344 /* Forward substitute and expand an expression out to its roots.
1345 This is the opposite of common subexpression. Because local value
1346 numbering is such a weak optimization, the expanded expression is
1347 pretty much unique (not from a pointer equals point of view but
1348 from a tree shape point of view.
1350 This function returns NULL if the expansion fails. The expansion
1351 will fail if there is no value number for one of the operands or if
1352 one of the operands has been overwritten between the current insn
1353 and the beginning of the basic block. For instance x has no
1359 REGS_ACTIVE is a scratch bitmap that should be clear when passing in.
1360 It is clear on return. */
1363 cselib_expand_value_rtx (rtx orig
, bitmap regs_active
, int max_depth
)
1365 struct expand_value_data evd
;
1367 evd
.regs_active
= regs_active
;
1368 evd
.callback
= NULL
;
1369 evd
.callback_arg
= NULL
;
1372 return cselib_expand_value_rtx_1 (orig
, &evd
, max_depth
);
1375 /* Same as cselib_expand_value_rtx, but using a callback to try to
1376 resolve some expressions. The CB function should return ORIG if it
1377 can't or does not want to deal with a certain RTX. Any other
1378 return value, including NULL, will be used as the expansion for
1379 VALUE, without any further changes. */
1382 cselib_expand_value_rtx_cb (rtx orig
, bitmap regs_active
, int max_depth
,
1383 cselib_expand_callback cb
, void *data
)
1385 struct expand_value_data evd
;
1387 evd
.regs_active
= regs_active
;
1389 evd
.callback_arg
= data
;
1392 return cselib_expand_value_rtx_1 (orig
, &evd
, max_depth
);
1395 /* Similar to cselib_expand_value_rtx_cb, but no rtxs are actually copied
1396 or simplified. Useful to find out whether cselib_expand_value_rtx_cb
1397 would return NULL or non-NULL, without allocating new rtx. */
1400 cselib_dummy_expand_value_rtx_cb (rtx orig
, bitmap regs_active
, int max_depth
,
1401 cselib_expand_callback cb
, void *data
)
1403 struct expand_value_data evd
;
1405 evd
.regs_active
= regs_active
;
1407 evd
.callback_arg
= data
;
1410 return cselib_expand_value_rtx_1 (orig
, &evd
, max_depth
) != NULL
;
1413 /* Internal implementation of cselib_expand_value_rtx and
1414 cselib_expand_value_rtx_cb. */
1417 cselib_expand_value_rtx_1 (rtx orig
, struct expand_value_data
*evd
,
1423 const char *format_ptr
;
1424 enum machine_mode mode
;
1426 code
= GET_CODE (orig
);
1428 /* For the context of dse, if we end up expand into a huge tree, we
1429 will not have a useful address, so we might as well just give up
1438 struct elt_list
*l
= REG_VALUES (REGNO (orig
));
1440 if (l
&& l
->elt
== NULL
)
1442 for (; l
; l
= l
->next
)
1443 if (GET_MODE (l
->elt
->val_rtx
) == GET_MODE (orig
))
1446 int regno
= REGNO (orig
);
1448 /* The only thing that we are not willing to do (this
1449 is requirement of dse and if others potential uses
1450 need this function we should add a parm to control
1451 it) is that we will not substitute the
1452 STACK_POINTER_REGNUM, FRAME_POINTER or the
1455 These expansions confuses the code that notices that
1456 stores into the frame go dead at the end of the
1457 function and that the frame is not effected by calls
1458 to subroutines. If you allow the
1459 STACK_POINTER_REGNUM substitution, then dse will
1460 think that parameter pushing also goes dead which is
1461 wrong. If you allow the FRAME_POINTER or the
1462 HARD_FRAME_POINTER then you lose the opportunity to
1463 make the frame assumptions. */
1464 if (regno
== STACK_POINTER_REGNUM
1465 || regno
== FRAME_POINTER_REGNUM
1466 || regno
== HARD_FRAME_POINTER_REGNUM
)
1469 bitmap_set_bit (evd
->regs_active
, regno
);
1471 if (dump_file
&& (dump_flags
& TDF_CSELIB
))
1472 fprintf (dump_file
, "expanding: r%d into: ", regno
);
1474 result
= expand_loc (l
->elt
->locs
, evd
, max_depth
);
1475 bitmap_clear_bit (evd
->regs_active
, regno
);
1492 /* SCRATCH must be shared because they represent distinct values. */
1495 if (REG_P (XEXP (orig
, 0)) && HARD_REGISTER_NUM_P (REGNO (XEXP (orig
, 0))))
1500 if (shared_const_p (orig
))
1510 subreg
= evd
->callback (orig
, evd
->regs_active
, max_depth
,
1516 subreg
= cselib_expand_value_rtx_1 (SUBREG_REG (orig
), evd
,
1520 scopy
= simplify_gen_subreg (GET_MODE (orig
), subreg
,
1521 GET_MODE (SUBREG_REG (orig
)),
1522 SUBREG_BYTE (orig
));
1524 || (GET_CODE (scopy
) == SUBREG
1525 && !REG_P (SUBREG_REG (scopy
))
1526 && !MEM_P (SUBREG_REG (scopy
))))
1536 if (dump_file
&& (dump_flags
& TDF_CSELIB
))
1538 fputs ("\nexpanding ", dump_file
);
1539 print_rtl_single (dump_file
, orig
);
1540 fputs (" into...", dump_file
);
1545 result
= evd
->callback (orig
, evd
->regs_active
, max_depth
,
1552 result
= expand_loc (CSELIB_VAL_PTR (orig
)->locs
, evd
, max_depth
);
1558 return evd
->callback (orig
, evd
->regs_active
, max_depth
,
1566 /* Copy the various flags, fields, and other information. We assume
1567 that all fields need copying, and then clear the fields that should
1568 not be copied. That is the sensible default behavior, and forces
1569 us to explicitly document why we are *not* copying a flag. */
1573 copy
= shallow_copy_rtx (orig
);
1575 format_ptr
= GET_RTX_FORMAT (code
);
1577 for (i
= 0; i
< GET_RTX_LENGTH (code
); i
++)
1578 switch (*format_ptr
++)
1581 if (XEXP (orig
, i
) != NULL
)
1583 rtx result
= cselib_expand_value_rtx_1 (XEXP (orig
, i
), evd
,
1588 XEXP (copy
, i
) = result
;
1594 if (XVEC (orig
, i
) != NULL
)
1597 XVEC (copy
, i
) = rtvec_alloc (XVECLEN (orig
, i
));
1598 for (j
= 0; j
< XVECLEN (orig
, i
); j
++)
1600 rtx result
= cselib_expand_value_rtx_1 (XVECEXP (orig
, i
, j
),
1601 evd
, max_depth
- 1);
1605 XVECEXP (copy
, i
, j
) = result
;
1619 /* These are left unchanged. */
1629 mode
= GET_MODE (copy
);
1630 /* If an operand has been simplified into CONST_INT, which doesn't
1631 have a mode and the mode isn't derivable from whole rtx's mode,
1632 try simplify_*_operation first with mode from original's operand
1633 and as a fallback wrap CONST_INT into gen_rtx_CONST. */
1635 switch (GET_RTX_CLASS (code
))
1638 if (CONST_INT_P (XEXP (copy
, 0))
1639 && GET_MODE (XEXP (orig
, 0)) != VOIDmode
)
1641 scopy
= simplify_unary_operation (code
, mode
, XEXP (copy
, 0),
1642 GET_MODE (XEXP (orig
, 0)));
1647 case RTX_COMM_ARITH
:
1649 /* These expressions can derive operand modes from the whole rtx's mode. */
1652 case RTX_BITFIELD_OPS
:
1653 if (CONST_INT_P (XEXP (copy
, 0))
1654 && GET_MODE (XEXP (orig
, 0)) != VOIDmode
)
1656 scopy
= simplify_ternary_operation (code
, mode
,
1657 GET_MODE (XEXP (orig
, 0)),
1658 XEXP (copy
, 0), XEXP (copy
, 1),
1665 case RTX_COMM_COMPARE
:
1666 if (CONST_INT_P (XEXP (copy
, 0))
1667 && GET_MODE (XEXP (copy
, 1)) == VOIDmode
1668 && (GET_MODE (XEXP (orig
, 0)) != VOIDmode
1669 || GET_MODE (XEXP (orig
, 1)) != VOIDmode
))
1671 scopy
= simplify_relational_operation (code
, mode
,
1672 (GET_MODE (XEXP (orig
, 0))
1674 ? GET_MODE (XEXP (orig
, 0))
1675 : GET_MODE (XEXP (orig
, 1)),
1685 scopy
= simplify_rtx (copy
);
1691 /* Walk rtx X and replace all occurrences of REG and MEM subexpressions
1692 with VALUE expressions. This way, it becomes independent of changes
1693 to registers and memory.
1694 X isn't actually modified; if modifications are needed, new rtl is
1695 allocated. However, the return value can share rtl with X.
1696 If X is within a MEM, MEMMODE must be the mode of the MEM. */
1699 cselib_subst_to_values (rtx x
, enum machine_mode memmode
)
1701 enum rtx_code code
= GET_CODE (x
);
1702 const char *fmt
= GET_RTX_FORMAT (code
);
1711 l
= REG_VALUES (REGNO (x
));
1712 if (l
&& l
->elt
== NULL
)
1714 for (; l
; l
= l
->next
)
1715 if (GET_MODE (l
->elt
->val_rtx
) == GET_MODE (x
))
1716 return l
->elt
->val_rtx
;
1721 e
= cselib_lookup_mem (x
, 0);
1722 /* This used to happen for autoincrements, but we deal with them
1723 properly now. Remove the if stmt for the next release. */
1726 /* Assign a value that doesn't match any other. */
1727 e
= new_cselib_val (next_uid
, GET_MODE (x
), x
);
1732 e
= cselib_lookup (x
, GET_MODE (x
), 0, memmode
);
1745 gcc_assert (memmode
!= VOIDmode
);
1746 i
= GET_MODE_SIZE (memmode
);
1747 if (code
== PRE_DEC
)
1749 return cselib_subst_to_values (plus_constant (XEXP (x
, 0), i
),
1753 gcc_assert (memmode
!= VOIDmode
);
1754 return cselib_subst_to_values (XEXP (x
, 1), memmode
);
1759 gcc_assert (memmode
!= VOIDmode
);
1760 return cselib_subst_to_values (XEXP (x
, 0), memmode
);
1766 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1770 rtx t
= cselib_subst_to_values (XEXP (x
, i
), memmode
);
1772 if (t
!= XEXP (x
, i
))
1775 copy
= shallow_copy_rtx (x
);
1779 else if (fmt
[i
] == 'E')
1783 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1785 rtx t
= cselib_subst_to_values (XVECEXP (x
, i
, j
), memmode
);
1787 if (t
!= XVECEXP (x
, i
, j
))
1789 if (XVEC (x
, i
) == XVEC (copy
, i
))
1792 copy
= shallow_copy_rtx (x
);
1793 XVEC (copy
, i
) = shallow_copy_rtvec (XVEC (x
, i
));
1795 XVECEXP (copy
, i
, j
) = t
;
1804 /* Look up the rtl expression X in our tables and return the value it
1805 has. If CREATE is zero, we return NULL if we don't know the value.
1806 Otherwise, we create a new one if possible, using mode MODE if X
1807 doesn't have a mode (i.e. because it's a constant). When X is part
1808 of an address, MEMMODE should be the mode of the enclosing MEM if
1809 we're tracking autoinc expressions. */
1812 cselib_lookup_1 (rtx x
, enum machine_mode mode
,
1813 int create
, enum machine_mode memmode
)
1817 unsigned int hashval
;
1819 if (GET_MODE (x
) != VOIDmode
)
1820 mode
= GET_MODE (x
);
1822 if (GET_CODE (x
) == VALUE
)
1823 return CSELIB_VAL_PTR (x
);
1828 unsigned int i
= REGNO (x
);
1831 if (l
&& l
->elt
== NULL
)
1833 for (; l
; l
= l
->next
)
1834 if (mode
== GET_MODE (l
->elt
->val_rtx
))
1836 promote_debug_loc (l
->elt
->locs
);
1843 if (i
< FIRST_PSEUDO_REGISTER
)
1845 unsigned int n
= hard_regno_nregs
[i
][mode
];
1847 if (n
> max_value_regs
)
1851 e
= new_cselib_val (next_uid
, GET_MODE (x
), x
);
1852 e
->locs
= new_elt_loc_list (e
->locs
, x
);
1853 if (REG_VALUES (i
) == 0)
1855 /* Maintain the invariant that the first entry of
1856 REG_VALUES, if present, must be the value used to set the
1857 register, or NULL. */
1858 used_regs
[n_used_regs
++] = i
;
1859 REG_VALUES (i
) = new_elt_list (REG_VALUES (i
), NULL
);
1861 else if (cselib_preserve_constants
1862 && GET_MODE_CLASS (mode
) == MODE_INT
)
1864 /* During var-tracking, try harder to find equivalences
1865 for SUBREGs. If a setter sets say a DImode register
1866 and user uses that register only in SImode, add a lowpart
1868 struct elt_list
*lwider
= NULL
;
1870 if (l
&& l
->elt
== NULL
)
1872 for (; l
; l
= l
->next
)
1873 if (GET_MODE_CLASS (GET_MODE (l
->elt
->val_rtx
)) == MODE_INT
1874 && GET_MODE_SIZE (GET_MODE (l
->elt
->val_rtx
))
1875 > GET_MODE_SIZE (mode
)
1877 || GET_MODE_SIZE (GET_MODE (l
->elt
->val_rtx
))
1878 < GET_MODE_SIZE (GET_MODE (lwider
->elt
->val_rtx
))))
1880 struct elt_loc_list
*el
;
1881 if (i
< FIRST_PSEUDO_REGISTER
1882 && hard_regno_nregs
[i
][GET_MODE (l
->elt
->val_rtx
)] != 1)
1884 for (el
= l
->elt
->locs
; el
; el
= el
->next
)
1885 if (!REG_P (el
->loc
))
1892 rtx sub
= lowpart_subreg (mode
, lwider
->elt
->val_rtx
,
1893 GET_MODE (lwider
->elt
->val_rtx
));
1895 e
->locs
->next
= new_elt_loc_list (e
->locs
->next
, sub
);
1898 REG_VALUES (i
)->next
= new_elt_list (REG_VALUES (i
)->next
, e
);
1899 slot
= cselib_find_slot (x
, e
->hash
, INSERT
, memmode
);
1905 return cselib_lookup_mem (x
, create
);
1907 hashval
= cselib_hash_rtx (x
, create
, memmode
);
1908 /* Can't even create if hashing is not possible. */
1912 slot
= cselib_find_slot (wrap_constant (mode
, x
), hashval
,
1913 create
? INSERT
: NO_INSERT
, memmode
);
1917 e
= (cselib_val
*) *slot
;
1921 e
= new_cselib_val (hashval
, mode
, x
);
1923 /* We have to fill the slot before calling cselib_subst_to_values:
1924 the hash table is inconsistent until we do so, and
1925 cselib_subst_to_values will need to do lookups. */
1927 e
->locs
= new_elt_loc_list (e
->locs
,
1928 cselib_subst_to_values (x
, memmode
));
1932 /* Wrapper for cselib_lookup, that indicates X is in INSN. */
1935 cselib_lookup_from_insn (rtx x
, enum machine_mode mode
,
1936 int create
, enum machine_mode memmode
, rtx insn
)
1940 gcc_assert (!cselib_current_insn
);
1941 cselib_current_insn
= insn
;
1943 ret
= cselib_lookup (x
, mode
, create
, memmode
);
1945 cselib_current_insn
= NULL
;
1950 /* Wrapper for cselib_lookup_1, that logs the lookup result and
1951 maintains invariants related with debug insns. */
1954 cselib_lookup (rtx x
, enum machine_mode mode
,
1955 int create
, enum machine_mode memmode
)
1957 cselib_val
*ret
= cselib_lookup_1 (x
, mode
, create
, memmode
);
1959 /* ??? Should we return NULL if we're not to create an entry, the
1960 found loc is a debug loc and cselib_current_insn is not DEBUG?
1961 If so, we should also avoid converting val to non-DEBUG; probably
1962 easiest setting cselib_current_insn to NULL before the call
1965 if (dump_file
&& (dump_flags
& TDF_CSELIB
))
1967 fputs ("cselib lookup ", dump_file
);
1968 print_inline_rtx (dump_file
, x
, 2);
1969 fprintf (dump_file
, " => %u:%u\n",
1971 ret
? ret
->hash
: 0);
1977 /* Invalidate any entries in reg_values that overlap REGNO. This is called
1978 if REGNO is changing. MODE is the mode of the assignment to REGNO, which
1979 is used to determine how many hard registers are being changed. If MODE
1980 is VOIDmode, then only REGNO is being changed; this is used when
1981 invalidating call clobbered registers across a call. */
1984 cselib_invalidate_regno (unsigned int regno
, enum machine_mode mode
)
1986 unsigned int endregno
;
1989 /* If we see pseudos after reload, something is _wrong_. */
1990 gcc_assert (!reload_completed
|| regno
< FIRST_PSEUDO_REGISTER
1991 || reg_renumber
[regno
] < 0);
1993 /* Determine the range of registers that must be invalidated. For
1994 pseudos, only REGNO is affected. For hard regs, we must take MODE
1995 into account, and we must also invalidate lower register numbers
1996 if they contain values that overlap REGNO. */
1997 if (regno
< FIRST_PSEUDO_REGISTER
)
1999 gcc_assert (mode
!= VOIDmode
);
2001 if (regno
< max_value_regs
)
2004 i
= regno
- max_value_regs
;
2006 endregno
= end_hard_regno (mode
, regno
);
2011 endregno
= regno
+ 1;
2014 for (; i
< endregno
; i
++)
2016 struct elt_list
**l
= ®_VALUES (i
);
2018 /* Go through all known values for this reg; if it overlaps the range
2019 we're invalidating, remove the value. */
2022 cselib_val
*v
= (*l
)->elt
;
2025 struct elt_loc_list
**p
;
2026 unsigned int this_last
= i
;
2028 if (i
< FIRST_PSEUDO_REGISTER
&& v
!= NULL
)
2029 this_last
= end_hard_regno (GET_MODE (v
->val_rtx
), i
) - 1;
2031 if (this_last
< regno
|| v
== NULL
2032 || (v
== cfa_base_preserved_val
2033 && i
== cfa_base_preserved_regno
))
2039 /* We have an overlap. */
2040 if (*l
== REG_VALUES (i
))
2042 /* Maintain the invariant that the first entry of
2043 REG_VALUES, if present, must be the value used to set
2044 the register, or NULL. This is also nice because
2045 then we won't push the same regno onto user_regs
2051 unchain_one_elt_list (l
);
2053 had_locs
= v
->locs
!= NULL
;
2054 setting_insn
= v
->locs
? v
->locs
->setting_insn
: NULL
;
2056 /* Now, we clear the mapping from value to reg. It must exist, so
2057 this code will crash intentionally if it doesn't. */
2058 for (p
= &v
->locs
; ; p
= &(*p
)->next
)
2062 if (REG_P (x
) && REGNO (x
) == i
)
2064 unchain_one_elt_loc_list (p
);
2069 if (had_locs
&& v
->locs
== 0 && !PRESERVED_VALUE_P (v
->val_rtx
))
2071 if (setting_insn
&& DEBUG_INSN_P (setting_insn
))
2072 n_useless_debug_values
++;
2080 /* Return 1 if X has a value that can vary even between two
2081 executions of the program. 0 means X can be compared reliably
2082 against certain constants or near-constants. */
2085 cselib_rtx_varies_p (const_rtx x ATTRIBUTE_UNUSED
, bool from_alias ATTRIBUTE_UNUSED
)
2087 /* We actually don't need to verify very hard. This is because
2088 if X has actually changed, we invalidate the memory anyway,
2089 so assume that all common memory addresses are
2094 /* Invalidate any locations in the table which are changed because of a
2095 store to MEM_RTX. If this is called because of a non-const call
2096 instruction, MEM_RTX is (mem:BLK const0_rtx). */
2099 cselib_invalidate_mem (rtx mem_rtx
)
2101 cselib_val
**vp
, *v
, *next
;
2105 mem_addr
= canon_rtx (get_addr (XEXP (mem_rtx
, 0)));
2106 mem_rtx
= canon_rtx (mem_rtx
);
2108 vp
= &first_containing_mem
;
2109 for (v
= *vp
; v
!= &dummy_val
; v
= next
)
2111 bool has_mem
= false;
2112 struct elt_loc_list
**p
= &v
->locs
;
2113 bool had_locs
= v
->locs
!= NULL
;
2114 rtx setting_insn
= v
->locs
? v
->locs
->setting_insn
: NULL
;
2120 struct elt_list
**mem_chain
;
2122 /* MEMs may occur in locations only at the top level; below
2123 that every MEM or REG is substituted by its VALUE. */
2129 if (num_mems
< PARAM_VALUE (PARAM_MAX_CSELIB_MEMORY_LOCATIONS
)
2130 && ! canon_true_dependence (mem_rtx
, GET_MODE (mem_rtx
), mem_addr
,
2131 x
, NULL_RTX
, cselib_rtx_varies_p
))
2139 /* This one overlaps. */
2140 /* We must have a mapping from this MEM's address to the
2141 value (E). Remove that, too. */
2142 addr
= cselib_lookup (XEXP (x
, 0), VOIDmode
, 0, GET_MODE (x
));
2143 mem_chain
= &addr
->addr_list
;
2146 if ((*mem_chain
)->elt
== v
)
2148 unchain_one_elt_list (mem_chain
);
2152 mem_chain
= &(*mem_chain
)->next
;
2155 unchain_one_elt_loc_list (p
);
2158 if (had_locs
&& v
->locs
== 0 && !PRESERVED_VALUE_P (v
->val_rtx
))
2160 if (setting_insn
&& DEBUG_INSN_P (setting_insn
))
2161 n_useless_debug_values
++;
2166 next
= v
->next_containing_mem
;
2170 vp
= &(*vp
)->next_containing_mem
;
2173 v
->next_containing_mem
= NULL
;
2178 /* Invalidate DEST, which is being assigned to or clobbered. */
2181 cselib_invalidate_rtx (rtx dest
)
2183 while (GET_CODE (dest
) == SUBREG
2184 || GET_CODE (dest
) == ZERO_EXTRACT
2185 || GET_CODE (dest
) == STRICT_LOW_PART
)
2186 dest
= XEXP (dest
, 0);
2189 cselib_invalidate_regno (REGNO (dest
), GET_MODE (dest
));
2190 else if (MEM_P (dest
))
2191 cselib_invalidate_mem (dest
);
2194 /* A wrapper for cselib_invalidate_rtx to be called via note_stores. */
2197 cselib_invalidate_rtx_note_stores (rtx dest
, const_rtx ignore ATTRIBUTE_UNUSED
,
2198 void *data ATTRIBUTE_UNUSED
)
2200 cselib_invalidate_rtx (dest
);
2203 /* Record the result of a SET instruction. DEST is being set; the source
2204 contains the value described by SRC_ELT. If DEST is a MEM, DEST_ADDR_ELT
2205 describes its address. */
2208 cselib_record_set (rtx dest
, cselib_val
*src_elt
, cselib_val
*dest_addr_elt
)
2210 int dreg
= REG_P (dest
) ? (int) REGNO (dest
) : -1;
2212 if (src_elt
== 0 || side_effects_p (dest
))
2217 if (dreg
< FIRST_PSEUDO_REGISTER
)
2219 unsigned int n
= hard_regno_nregs
[dreg
][GET_MODE (dest
)];
2221 if (n
> max_value_regs
)
2225 if (REG_VALUES (dreg
) == 0)
2227 used_regs
[n_used_regs
++] = dreg
;
2228 REG_VALUES (dreg
) = new_elt_list (REG_VALUES (dreg
), src_elt
);
2232 /* The register should have been invalidated. */
2233 gcc_assert (REG_VALUES (dreg
)->elt
== 0);
2234 REG_VALUES (dreg
)->elt
= src_elt
;
2237 if (src_elt
->locs
== 0 && !PRESERVED_VALUE_P (src_elt
->val_rtx
))
2239 src_elt
->locs
= new_elt_loc_list (src_elt
->locs
, dest
);
2241 else if (MEM_P (dest
) && dest_addr_elt
!= 0
2242 && cselib_record_memory
)
2244 if (src_elt
->locs
== 0 && !PRESERVED_VALUE_P (src_elt
->val_rtx
))
2246 add_mem_for_addr (dest_addr_elt
, src_elt
, dest
);
2250 /* There is no good way to determine how many elements there can be
2251 in a PARALLEL. Since it's fairly cheap, use a really large number. */
2252 #define MAX_SETS (FIRST_PSEUDO_REGISTER * 2)
2254 struct cselib_record_autoinc_data
2256 struct cselib_set
*sets
;
2260 /* Callback for for_each_inc_dec. Records in ARG the SETs implied by
2261 autoinc RTXs: SRC plus SRCOFF if non-NULL is stored in DEST. */
2264 cselib_record_autoinc_cb (rtx mem ATTRIBUTE_UNUSED
, rtx op ATTRIBUTE_UNUSED
,
2265 rtx dest
, rtx src
, rtx srcoff
, void *arg
)
2267 struct cselib_record_autoinc_data
*data
;
2268 data
= (struct cselib_record_autoinc_data
*)arg
;
2270 data
->sets
[data
->n_sets
].dest
= dest
;
2273 data
->sets
[data
->n_sets
].src
= gen_rtx_PLUS (GET_MODE (src
), src
, srcoff
);
2275 data
->sets
[data
->n_sets
].src
= src
;
2282 /* Record the effects of any sets and autoincs in INSN. */
2284 cselib_record_sets (rtx insn
)
2288 struct cselib_set sets
[MAX_SETS
];
2289 rtx body
= PATTERN (insn
);
2291 int n_sets_before_autoinc
;
2292 struct cselib_record_autoinc_data data
;
2294 body
= PATTERN (insn
);
2295 if (GET_CODE (body
) == COND_EXEC
)
2297 cond
= COND_EXEC_TEST (body
);
2298 body
= COND_EXEC_CODE (body
);
2301 /* Find all sets. */
2302 if (GET_CODE (body
) == SET
)
2304 sets
[0].src
= SET_SRC (body
);
2305 sets
[0].dest
= SET_DEST (body
);
2308 else if (GET_CODE (body
) == PARALLEL
)
2310 /* Look through the PARALLEL and record the values being
2311 set, if possible. Also handle any CLOBBERs. */
2312 for (i
= XVECLEN (body
, 0) - 1; i
>= 0; --i
)
2314 rtx x
= XVECEXP (body
, 0, i
);
2316 if (GET_CODE (x
) == SET
)
2318 sets
[n_sets
].src
= SET_SRC (x
);
2319 sets
[n_sets
].dest
= SET_DEST (x
);
2326 && MEM_P (sets
[0].src
)
2327 && !cselib_record_memory
2328 && MEM_READONLY_P (sets
[0].src
))
2330 rtx note
= find_reg_equal_equiv_note (insn
);
2332 if (note
&& CONSTANT_P (XEXP (note
, 0)))
2333 sets
[0].src
= XEXP (note
, 0);
2337 data
.n_sets
= n_sets_before_autoinc
= n_sets
;
2338 for_each_inc_dec (&insn
, cselib_record_autoinc_cb
, &data
);
2339 n_sets
= data
.n_sets
;
2341 /* Look up the values that are read. Do this before invalidating the
2342 locations that are written. */
2343 for (i
= 0; i
< n_sets
; i
++)
2345 rtx dest
= sets
[i
].dest
;
2347 /* A STRICT_LOW_PART can be ignored; we'll record the equivalence for
2348 the low part after invalidating any knowledge about larger modes. */
2349 if (GET_CODE (sets
[i
].dest
) == STRICT_LOW_PART
)
2350 sets
[i
].dest
= dest
= XEXP (dest
, 0);
2352 /* We don't know how to record anything but REG or MEM. */
2354 || (MEM_P (dest
) && cselib_record_memory
))
2356 rtx src
= sets
[i
].src
;
2358 src
= gen_rtx_IF_THEN_ELSE (GET_MODE (dest
), cond
, src
, dest
);
2359 sets
[i
].src_elt
= cselib_lookup (src
, GET_MODE (dest
), 1, VOIDmode
);
2362 enum machine_mode address_mode
2363 = targetm
.addr_space
.address_mode (MEM_ADDR_SPACE (dest
));
2365 sets
[i
].dest_addr_elt
= cselib_lookup (XEXP (dest
, 0),
2370 sets
[i
].dest_addr_elt
= 0;
2374 if (cselib_record_sets_hook
)
2375 cselib_record_sets_hook (insn
, sets
, n_sets
);
2377 /* Invalidate all locations written by this insn. Note that the elts we
2378 looked up in the previous loop aren't affected, just some of their
2379 locations may go away. */
2380 note_stores (body
, cselib_invalidate_rtx_note_stores
, NULL
);
2382 for (i
= n_sets_before_autoinc
; i
< n_sets
; i
++)
2383 cselib_invalidate_rtx (sets
[i
].dest
);
2385 /* If this is an asm, look for duplicate sets. This can happen when the
2386 user uses the same value as an output multiple times. This is valid
2387 if the outputs are not actually used thereafter. Treat this case as
2388 if the value isn't actually set. We do this by smashing the destination
2389 to pc_rtx, so that we won't record the value later. */
2390 if (n_sets
>= 2 && asm_noperands (body
) >= 0)
2392 for (i
= 0; i
< n_sets
; i
++)
2394 rtx dest
= sets
[i
].dest
;
2395 if (REG_P (dest
) || MEM_P (dest
))
2398 for (j
= i
+ 1; j
< n_sets
; j
++)
2399 if (rtx_equal_p (dest
, sets
[j
].dest
))
2401 sets
[i
].dest
= pc_rtx
;
2402 sets
[j
].dest
= pc_rtx
;
2408 /* Now enter the equivalences in our tables. */
2409 for (i
= 0; i
< n_sets
; i
++)
2411 rtx dest
= sets
[i
].dest
;
2413 || (MEM_P (dest
) && cselib_record_memory
))
2414 cselib_record_set (dest
, sets
[i
].src_elt
, sets
[i
].dest_addr_elt
);
2418 /* Record the effects of INSN. */
2421 cselib_process_insn (rtx insn
)
2426 cselib_current_insn
= insn
;
2428 /* Forget everything at a CODE_LABEL, a volatile asm, or a setjmp. */
2431 && find_reg_note (insn
, REG_SETJMP
, NULL
))
2432 || (NONJUMP_INSN_P (insn
)
2433 && GET_CODE (PATTERN (insn
)) == ASM_OPERANDS
2434 && MEM_VOLATILE_P (PATTERN (insn
))))
2436 cselib_reset_table (next_uid
);
2437 cselib_current_insn
= NULL_RTX
;
2441 if (! INSN_P (insn
))
2443 cselib_current_insn
= NULL_RTX
;
2447 /* If this is a call instruction, forget anything stored in a
2448 call clobbered register, or, if this is not a const call, in
2452 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
2453 if (call_used_regs
[i
]
2454 || (REG_VALUES (i
) && REG_VALUES (i
)->elt
2455 && HARD_REGNO_CALL_PART_CLOBBERED (i
,
2456 GET_MODE (REG_VALUES (i
)->elt
->val_rtx
))))
2457 cselib_invalidate_regno (i
, reg_raw_mode
[i
]);
2459 /* Since it is not clear how cselib is going to be used, be
2460 conservative here and treat looping pure or const functions
2461 as if they were regular functions. */
2462 if (RTL_LOOPING_CONST_OR_PURE_CALL_P (insn
)
2463 || !(RTL_CONST_OR_PURE_CALL_P (insn
)))
2464 cselib_invalidate_mem (callmem
);
2467 cselib_record_sets (insn
);
2469 /* Look for any CLOBBERs in CALL_INSN_FUNCTION_USAGE, but only
2470 after we have processed the insn. */
2472 for (x
= CALL_INSN_FUNCTION_USAGE (insn
); x
; x
= XEXP (x
, 1))
2473 if (GET_CODE (XEXP (x
, 0)) == CLOBBER
)
2474 cselib_invalidate_rtx (XEXP (XEXP (x
, 0), 0));
2476 cselib_current_insn
= NULL_RTX
;
2478 if (n_useless_values
> MAX_USELESS_VALUES
2479 /* remove_useless_values is linear in the hash table size. Avoid
2480 quadratic behavior for very large hashtables with very few
2481 useless elements. */
2482 && ((unsigned int)n_useless_values
2483 > (cselib_hash_table
->n_elements
2484 - cselib_hash_table
->n_deleted
2485 - n_debug_values
) / 4))
2486 remove_useless_values ();
2489 /* Initialize cselib for one pass. The caller must also call
2490 init_alias_analysis. */
2493 cselib_init (int record_what
)
2495 elt_list_pool
= create_alloc_pool ("elt_list",
2496 sizeof (struct elt_list
), 10);
2497 elt_loc_list_pool
= create_alloc_pool ("elt_loc_list",
2498 sizeof (struct elt_loc_list
), 10);
2499 cselib_val_pool
= create_alloc_pool ("cselib_val_list",
2500 sizeof (cselib_val
), 10);
2501 value_pool
= create_alloc_pool ("value", RTX_CODE_SIZE (VALUE
), 100);
2502 cselib_record_memory
= record_what
& CSELIB_RECORD_MEMORY
;
2503 cselib_preserve_constants
= record_what
& CSELIB_PRESERVE_CONSTANTS
;
2505 /* (mem:BLK (scratch)) is a special mechanism to conflict with everything,
2506 see canon_true_dependence. This is only created once. */
2508 callmem
= gen_rtx_MEM (BLKmode
, gen_rtx_SCRATCH (VOIDmode
));
2510 cselib_nregs
= max_reg_num ();
2512 /* We preserve reg_values to allow expensive clearing of the whole thing.
2513 Reallocate it however if it happens to be too large. */
2514 if (!reg_values
|| reg_values_size
< cselib_nregs
2515 || (reg_values_size
> 10 && reg_values_size
> cselib_nregs
* 4))
2518 /* Some space for newly emit instructions so we don't end up
2519 reallocating in between passes. */
2520 reg_values_size
= cselib_nregs
+ (63 + cselib_nregs
) / 16;
2521 reg_values
= XCNEWVEC (struct elt_list
*, reg_values_size
);
2523 used_regs
= XNEWVEC (unsigned int, cselib_nregs
);
2525 cselib_hash_table
= htab_create (31, get_value_hash
,
2526 entry_and_rtx_equal_p
, NULL
);
2530 /* Called when the current user is done with cselib. */
2533 cselib_finish (void)
2535 cselib_discard_hook
= NULL
;
2536 cselib_preserve_constants
= false;
2537 cfa_base_preserved_val
= NULL
;
2538 cfa_base_preserved_regno
= INVALID_REGNUM
;
2539 free_alloc_pool (elt_list_pool
);
2540 free_alloc_pool (elt_loc_list_pool
);
2541 free_alloc_pool (cselib_val_pool
);
2542 free_alloc_pool (value_pool
);
2543 cselib_clear_table ();
2544 htab_delete (cselib_hash_table
);
2547 cselib_hash_table
= 0;
2548 n_useless_values
= 0;
2549 n_useless_debug_values
= 0;
2554 /* Dump the cselib_val *X to FILE *info. */
2557 dump_cselib_val (void **x
, void *info
)
2559 cselib_val
*v
= (cselib_val
*)*x
;
2560 FILE *out
= (FILE *)info
;
2561 bool need_lf
= true;
2563 print_inline_rtx (out
, v
->val_rtx
, 0);
2567 struct elt_loc_list
*l
= v
->locs
;
2573 fputs (" locs:", out
);
2576 fprintf (out
, "\n from insn %i ",
2577 INSN_UID (l
->setting_insn
));
2578 print_inline_rtx (out
, l
->loc
, 4);
2580 while ((l
= l
->next
));
2585 fputs (" no locs", out
);
2591 struct elt_list
*e
= v
->addr_list
;
2597 fputs (" addr list:", out
);
2601 print_inline_rtx (out
, e
->elt
->val_rtx
, 2);
2603 while ((e
= e
->next
));
2608 fputs (" no addrs", out
);
2612 if (v
->next_containing_mem
== &dummy_val
)
2613 fputs (" last mem\n", out
);
2614 else if (v
->next_containing_mem
)
2616 fputs (" next mem ", out
);
2617 print_inline_rtx (out
, v
->next_containing_mem
->val_rtx
, 2);
2626 /* Dump to OUT everything in the CSELIB table. */
2629 dump_cselib_table (FILE *out
)
2631 fprintf (out
, "cselib hash table:\n");
2632 htab_traverse (cselib_hash_table
, dump_cselib_val
, out
);
2633 if (first_containing_mem
!= &dummy_val
)
2635 fputs ("first mem ", out
);
2636 print_inline_rtx (out
, first_containing_mem
->val_rtx
, 2);
2639 fprintf (out
, "next uid %i\n", next_uid
);
2642 #include "gt-cselib.h"