Mercurial > hg > CbC > CbC_gcc
annotate gcc/cselib.c @ 56:3c8a44c06a95
Added tag gcc-4.4.5 for changeset 77e2b8dfacca
| author | ryoma <e075725@ie.u-ryukyu.ac.jp> |
|---|---|
| date | Fri, 12 Feb 2010 23:41:23 +0900 |
| parents | 77e2b8dfacca |
| children | b7f97abdc517 |
| rev | line source |
|---|---|
| 0 | 1 /* Common subexpression elimination library for GNU compiler. |
| 2 Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, | |
|
19
58ad6c70ea60
update gcc from 4.4.0 to 4.4.1.
kent@firefly.cr.ie.u-ryukyu.ac.jp
parents:
0
diff
changeset
|
3 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007, 2008, 2009 |
| 0 | 4 Free Software Foundation, Inc. |
| 5 | |
| 6 This file is part of GCC. | |
| 7 | |
| 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 | |
| 11 version. | |
| 12 | |
| 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 | |
| 16 for more details. | |
| 17 | |
| 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/>. */ | |
| 21 | |
| 22 #include "config.h" | |
| 23 #include "system.h" | |
| 24 #include "coretypes.h" | |
| 25 #include "tm.h" | |
| 26 | |
| 27 #include "rtl.h" | |
| 28 #include "tm_p.h" | |
| 29 #include "regs.h" | |
| 30 #include "hard-reg-set.h" | |
| 31 #include "flags.h" | |
| 32 #include "real.h" | |
| 33 #include "insn-config.h" | |
| 34 #include "recog.h" | |
| 35 #include "function.h" | |
| 36 #include "emit-rtl.h" | |
| 37 #include "toplev.h" | |
| 38 #include "output.h" | |
| 39 #include "ggc.h" | |
| 40 #include "hashtab.h" | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
41 #include "tree-pass.h" |
| 0 | 42 #include "cselib.h" |
| 43 #include "params.h" | |
| 44 #include "alloc-pool.h" | |
| 45 #include "target.h" | |
| 46 | |
| 47 static bool cselib_record_memory; | |
| 48 static int entry_and_rtx_equal_p (const void *, const void *); | |
| 49 static hashval_t get_value_hash (const void *); | |
| 50 static struct elt_list *new_elt_list (struct elt_list *, cselib_val *); | |
| 51 static struct elt_loc_list *new_elt_loc_list (struct elt_loc_list *, rtx); | |
| 52 static void unchain_one_value (cselib_val *); | |
| 53 static void unchain_one_elt_list (struct elt_list **); | |
| 54 static void unchain_one_elt_loc_list (struct elt_loc_list **); | |
| 55 static int discard_useless_locs (void **, void *); | |
| 56 static int discard_useless_values (void **, void *); | |
| 57 static void remove_useless_values (void); | |
| 58 static unsigned int cselib_hash_rtx (rtx, int); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
59 static cselib_val *new_cselib_val (unsigned int, enum machine_mode, rtx); |
| 0 | 60 static void add_mem_for_addr (cselib_val *, cselib_val *, rtx); |
| 61 static cselib_val *cselib_lookup_mem (rtx, int); | |
| 62 static void cselib_invalidate_regno (unsigned int, enum machine_mode); | |
| 63 static void cselib_invalidate_mem (rtx); | |
| 64 static void cselib_record_set (rtx, cselib_val *, cselib_val *); | |
| 65 static void cselib_record_sets (rtx); | |
| 66 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
67 struct expand_value_data |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
68 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
69 bitmap regs_active; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
70 cselib_expand_callback callback; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
71 void *callback_arg; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
72 }; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
73 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
74 static rtx cselib_expand_value_rtx_1 (rtx, struct expand_value_data *, int); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
75 |
| 0 | 76 /* There are three ways in which cselib can look up an rtx: |
| 77 - for a REG, the reg_values table (which is indexed by regno) is used | |
| 78 - for a MEM, we recursively look up its address and then follow the | |
| 79 addr_list of that value | |
| 80 - for everything else, we compute a hash value and go through the hash | |
| 81 table. Since different rtx's can still have the same hash value, | |
| 82 this involves walking the table entries for a given value and comparing | |
| 83 the locations of the entries with the rtx we are looking up. */ | |
| 84 | |
| 85 /* A table that enables us to look up elts by their value. */ | |
| 86 static htab_t cselib_hash_table; | |
| 87 | |
| 88 /* This is a global so we don't have to pass this through every function. | |
| 89 It is used in new_elt_loc_list to set SETTING_INSN. */ | |
| 90 static rtx cselib_current_insn; | |
| 91 | |
| 92 /* Every new unknown value gets a unique number. */ | |
| 93 static unsigned int next_unknown_value; | |
| 94 | |
| 95 /* The number of registers we had when the varrays were last resized. */ | |
| 96 static unsigned int cselib_nregs; | |
| 97 | |
| 98 /* Count values without known locations. Whenever this grows too big, we | |
| 99 remove these useless values from the table. */ | |
| 100 static int n_useless_values; | |
| 101 | |
| 102 /* Number of useless values before we remove them from the hash table. */ | |
| 103 #define MAX_USELESS_VALUES 32 | |
| 104 | |
| 105 /* This table maps from register number to values. It does not | |
| 106 contain pointers to cselib_val structures, but rather elt_lists. | |
| 107 The purpose is to be able to refer to the same register in | |
| 108 different modes. The first element of the list defines the mode in | |
| 109 which the register was set; if the mode is unknown or the value is | |
| 110 no longer valid in that mode, ELT will be NULL for the first | |
| 111 element. */ | |
| 112 static struct elt_list **reg_values; | |
| 113 static unsigned int reg_values_size; | |
| 114 #define REG_VALUES(i) reg_values[i] | |
| 115 | |
| 116 /* The largest number of hard regs used by any entry added to the | |
| 117 REG_VALUES table. Cleared on each cselib_clear_table() invocation. */ | |
| 118 static unsigned int max_value_regs; | |
| 119 | |
| 120 /* Here the set of indices I with REG_VALUES(I) != 0 is saved. This is used | |
| 121 in cselib_clear_table() for fast emptying. */ | |
| 122 static unsigned int *used_regs; | |
| 123 static unsigned int n_used_regs; | |
| 124 | |
| 125 /* We pass this to cselib_invalidate_mem to invalidate all of | |
| 126 memory for a non-const call instruction. */ | |
| 127 static GTY(()) rtx callmem; | |
| 128 | |
| 129 /* Set by discard_useless_locs if it deleted the last location of any | |
| 130 value. */ | |
| 131 static int values_became_useless; | |
| 132 | |
| 133 /* Used as stop element of the containing_mem list so we can check | |
| 134 presence in the list by checking the next pointer. */ | |
| 135 static cselib_val dummy_val; | |
| 136 | |
| 137 /* Used to list all values that contain memory reference. | |
| 138 May or may not contain the useless values - the list is compacted | |
| 139 each time memory is invalidated. */ | |
| 140 static cselib_val *first_containing_mem = &dummy_val; | |
| 141 static alloc_pool elt_loc_list_pool, elt_list_pool, cselib_val_pool, value_pool; | |
| 142 | |
| 143 /* If nonnull, cselib will call this function before freeing useless | |
| 144 VALUEs. A VALUE is deemed useless if its "locs" field is null. */ | |
| 145 void (*cselib_discard_hook) (cselib_val *); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
146 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
147 /* If nonnull, cselib will call this function before recording sets or |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
148 even clobbering outputs of INSN. All the recorded sets will be |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
149 represented in the array sets[n_sets]. new_val_min can be used to |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
150 tell whether values present in sets are introduced by this |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
151 instruction. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
152 void (*cselib_record_sets_hook) (rtx insn, struct cselib_set *sets, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
153 int n_sets); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
154 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
155 #define PRESERVED_VALUE_P(RTX) \ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
156 (RTL_FLAG_CHECK1("PRESERVED_VALUE_P", (RTX), VALUE)->unchanging) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
157 #define LONG_TERM_PRESERVED_VALUE_P(RTX) \ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
158 (RTL_FLAG_CHECK1("LONG_TERM_PRESERVED_VALUE_P", (RTX), VALUE)->in_struct) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
159 |
| 0 | 160 |
| 161 | |
| 162 /* Allocate a struct elt_list and fill in its two elements with the | |
| 163 arguments. */ | |
| 164 | |
| 165 static inline struct elt_list * | |
| 166 new_elt_list (struct elt_list *next, cselib_val *elt) | |
| 167 { | |
| 168 struct elt_list *el; | |
| 169 el = (struct elt_list *) pool_alloc (elt_list_pool); | |
| 170 el->next = next; | |
| 171 el->elt = elt; | |
| 172 return el; | |
| 173 } | |
| 174 | |
| 175 /* Allocate a struct elt_loc_list and fill in its two elements with the | |
| 176 arguments. */ | |
| 177 | |
| 178 static inline struct elt_loc_list * | |
| 179 new_elt_loc_list (struct elt_loc_list *next, rtx loc) | |
| 180 { | |
| 181 struct elt_loc_list *el; | |
| 182 el = (struct elt_loc_list *) pool_alloc (elt_loc_list_pool); | |
| 183 el->next = next; | |
| 184 el->loc = loc; | |
| 185 el->setting_insn = cselib_current_insn; | |
| 186 return el; | |
| 187 } | |
| 188 | |
| 189 /* The elt_list at *PL is no longer needed. Unchain it and free its | |
| 190 storage. */ | |
| 191 | |
| 192 static inline void | |
| 193 unchain_one_elt_list (struct elt_list **pl) | |
| 194 { | |
| 195 struct elt_list *l = *pl; | |
| 196 | |
| 197 *pl = l->next; | |
| 198 pool_free (elt_list_pool, l); | |
| 199 } | |
| 200 | |
| 201 /* Likewise for elt_loc_lists. */ | |
| 202 | |
| 203 static void | |
| 204 unchain_one_elt_loc_list (struct elt_loc_list **pl) | |
| 205 { | |
| 206 struct elt_loc_list *l = *pl; | |
| 207 | |
| 208 *pl = l->next; | |
| 209 pool_free (elt_loc_list_pool, l); | |
| 210 } | |
| 211 | |
| 212 /* Likewise for cselib_vals. This also frees the addr_list associated with | |
| 213 V. */ | |
| 214 | |
| 215 static void | |
| 216 unchain_one_value (cselib_val *v) | |
| 217 { | |
| 218 while (v->addr_list) | |
| 219 unchain_one_elt_list (&v->addr_list); | |
| 220 | |
| 221 pool_free (cselib_val_pool, v); | |
| 222 } | |
| 223 | |
| 224 /* Remove all entries from the hash table. Also used during | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
225 initialization. */ |
| 0 | 226 |
| 227 void | |
| 228 cselib_clear_table (void) | |
| 229 { | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
230 cselib_reset_table_with_next_value (0); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
231 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
232 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
233 /* Remove all entries from the hash table, arranging for the next |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
234 value to be numbered NUM. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
235 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
236 void |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
237 cselib_reset_table_with_next_value (unsigned int num) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
238 { |
| 0 | 239 unsigned int i; |
| 240 | |
| 241 for (i = 0; i < n_used_regs; i++) | |
| 242 REG_VALUES (used_regs[i]) = 0; | |
| 243 | |
| 244 max_value_regs = 0; | |
| 245 | |
| 246 n_used_regs = 0; | |
| 247 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
248 /* ??? Preserve constants? */ |
| 0 | 249 htab_empty (cselib_hash_table); |
| 250 | |
| 251 n_useless_values = 0; | |
| 252 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
253 next_unknown_value = num; |
| 0 | 254 |
| 255 first_containing_mem = &dummy_val; | |
| 256 } | |
| 257 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
258 /* Return the number of the next value that will be generated. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
259 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
260 unsigned int |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
261 cselib_get_next_unknown_value (void) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
262 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
263 return next_unknown_value; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
264 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
265 |
| 0 | 266 /* The equality test for our hash table. The first argument ENTRY is a table |
| 267 element (i.e. a cselib_val), while the second arg X is an rtx. We know | |
| 268 that all callers of htab_find_slot_with_hash will wrap CONST_INTs into a | |
| 269 CONST of an appropriate mode. */ | |
| 270 | |
| 271 static int | |
| 272 entry_and_rtx_equal_p (const void *entry, const void *x_arg) | |
| 273 { | |
| 274 struct elt_loc_list *l; | |
| 275 const cselib_val *const v = (const cselib_val *) entry; | |
| 276 rtx x = CONST_CAST_RTX ((const_rtx)x_arg); | |
| 277 enum machine_mode mode = GET_MODE (x); | |
| 278 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
279 gcc_assert (!CONST_INT_P (x) && GET_CODE (x) != CONST_FIXED |
| 0 | 280 && (mode != VOIDmode || GET_CODE (x) != CONST_DOUBLE)); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
281 |
| 0 | 282 if (mode != GET_MODE (v->val_rtx)) |
| 283 return 0; | |
| 284 | |
| 285 /* Unwrap X if necessary. */ | |
| 286 if (GET_CODE (x) == CONST | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
287 && (CONST_INT_P (XEXP (x, 0)) |
| 0 | 288 || GET_CODE (XEXP (x, 0)) == CONST_FIXED |
| 289 || GET_CODE (XEXP (x, 0)) == CONST_DOUBLE)) | |
| 290 x = XEXP (x, 0); | |
| 291 | |
| 292 /* We don't guarantee that distinct rtx's have different hash values, | |
| 293 so we need to do a comparison. */ | |
| 294 for (l = v->locs; l; l = l->next) | |
| 295 if (rtx_equal_for_cselib_p (l->loc, x)) | |
| 296 return 1; | |
| 297 | |
| 298 return 0; | |
| 299 } | |
| 300 | |
| 301 /* The hash function for our hash table. The value is always computed with | |
| 302 cselib_hash_rtx when adding an element; this function just extracts the | |
| 303 hash value from a cselib_val structure. */ | |
| 304 | |
| 305 static hashval_t | |
| 306 get_value_hash (const void *entry) | |
| 307 { | |
| 308 const cselib_val *const v = (const cselib_val *) entry; | |
| 309 return v->value; | |
| 310 } | |
| 311 | |
| 312 /* Return true if X contains a VALUE rtx. If ONLY_USELESS is set, we | |
| 313 only return true for values which point to a cselib_val whose value | |
| 314 element has been set to zero, which implies the cselib_val will be | |
| 315 removed. */ | |
| 316 | |
| 317 int | |
| 318 references_value_p (const_rtx x, int only_useless) | |
| 319 { | |
| 320 const enum rtx_code code = GET_CODE (x); | |
| 321 const char *fmt = GET_RTX_FORMAT (code); | |
| 322 int i, j; | |
| 323 | |
| 324 if (GET_CODE (x) == VALUE | |
| 325 && (! only_useless || CSELIB_VAL_PTR (x)->locs == 0)) | |
| 326 return 1; | |
| 327 | |
| 328 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) | |
| 329 { | |
| 330 if (fmt[i] == 'e' && references_value_p (XEXP (x, i), only_useless)) | |
| 331 return 1; | |
| 332 else if (fmt[i] == 'E') | |
| 333 for (j = 0; j < XVECLEN (x, i); j++) | |
| 334 if (references_value_p (XVECEXP (x, i, j), only_useless)) | |
| 335 return 1; | |
| 336 } | |
| 337 | |
| 338 return 0; | |
| 339 } | |
| 340 | |
| 341 /* For all locations found in X, delete locations that reference useless | |
| 342 values (i.e. values without any location). Called through | |
| 343 htab_traverse. */ | |
| 344 | |
| 345 static int | |
| 346 discard_useless_locs (void **x, void *info ATTRIBUTE_UNUSED) | |
| 347 { | |
| 348 cselib_val *v = (cselib_val *)*x; | |
| 349 struct elt_loc_list **p = &v->locs; | |
| 350 int had_locs = v->locs != 0; | |
| 351 | |
| 352 while (*p) | |
| 353 { | |
| 354 if (references_value_p ((*p)->loc, 1)) | |
| 355 unchain_one_elt_loc_list (p); | |
| 356 else | |
| 357 p = &(*p)->next; | |
| 358 } | |
| 359 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
360 if (had_locs && v->locs == 0 && !PRESERVED_VALUE_P (v->val_rtx)) |
| 0 | 361 { |
| 362 n_useless_values++; | |
| 363 values_became_useless = 1; | |
| 364 } | |
| 365 return 1; | |
| 366 } | |
| 367 | |
| 368 /* If X is a value with no locations, remove it from the hashtable. */ | |
| 369 | |
| 370 static int | |
| 371 discard_useless_values (void **x, void *info ATTRIBUTE_UNUSED) | |
| 372 { | |
| 373 cselib_val *v = (cselib_val *)*x; | |
| 374 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
375 if (v->locs == 0 && !PRESERVED_VALUE_P (v->val_rtx)) |
| 0 | 376 { |
| 377 if (cselib_discard_hook) | |
| 378 cselib_discard_hook (v); | |
| 379 | |
| 380 CSELIB_VAL_PTR (v->val_rtx) = NULL; | |
| 381 htab_clear_slot (cselib_hash_table, x); | |
| 382 unchain_one_value (v); | |
| 383 n_useless_values--; | |
| 384 } | |
| 385 | |
| 386 return 1; | |
| 387 } | |
| 388 | |
| 389 /* Clean out useless values (i.e. those which no longer have locations | |
| 390 associated with them) from the hash table. */ | |
| 391 | |
| 392 static void | |
| 393 remove_useless_values (void) | |
| 394 { | |
| 395 cselib_val **p, *v; | |
| 396 /* First pass: eliminate locations that reference the value. That in | |
| 397 turn can make more values useless. */ | |
| 398 do | |
| 399 { | |
| 400 values_became_useless = 0; | |
| 401 htab_traverse (cselib_hash_table, discard_useless_locs, 0); | |
| 402 } | |
| 403 while (values_became_useless); | |
| 404 | |
| 405 /* Second pass: actually remove the values. */ | |
| 406 | |
| 407 p = &first_containing_mem; | |
| 408 for (v = *p; v != &dummy_val; v = v->next_containing_mem) | |
| 409 if (v->locs) | |
| 410 { | |
| 411 *p = v; | |
| 412 p = &(*p)->next_containing_mem; | |
| 413 } | |
| 414 *p = &dummy_val; | |
| 415 | |
| 416 htab_traverse (cselib_hash_table, discard_useless_values, 0); | |
| 417 | |
| 418 gcc_assert (!n_useless_values); | |
| 419 } | |
| 420 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
421 /* Arrange for a value to not be removed from the hash table even if |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
422 it becomes useless. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
423 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
424 void |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
425 cselib_preserve_value (cselib_val *v) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
426 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
427 PRESERVED_VALUE_P (v->val_rtx) = 1; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
428 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
429 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
430 /* Test whether a value is preserved. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
431 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
432 bool |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
433 cselib_preserved_value_p (cselib_val *v) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
434 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
435 return PRESERVED_VALUE_P (v->val_rtx); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
436 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
437 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
438 /* Mark preserved values as preserved for the long term. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
439 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
440 static int |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
441 cselib_preserve_definitely (void **slot, void *info ATTRIBUTE_UNUSED) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
442 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
443 cselib_val *v = (cselib_val *)*slot; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
444 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
445 if (PRESERVED_VALUE_P (v->val_rtx) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
446 && !LONG_TERM_PRESERVED_VALUE_P (v->val_rtx)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
447 LONG_TERM_PRESERVED_VALUE_P (v->val_rtx) = true; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
448 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
449 return 1; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
450 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
451 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
452 /* Clear the preserve marks for values not preserved for the long |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
453 term. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
454 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
455 static int |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
456 cselib_clear_preserve (void **slot, void *info ATTRIBUTE_UNUSED) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
457 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
458 cselib_val *v = (cselib_val *)*slot; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
459 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
460 if (PRESERVED_VALUE_P (v->val_rtx) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
461 && !LONG_TERM_PRESERVED_VALUE_P (v->val_rtx)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
462 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
463 PRESERVED_VALUE_P (v->val_rtx) = false; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
464 if (!v->locs) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
465 n_useless_values++; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
466 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
467 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
468 return 1; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
469 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
470 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
471 /* Clean all non-constant expressions in the hash table, but retain |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
472 their values. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
473 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
474 void |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
475 cselib_preserve_only_values (bool retain) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
476 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
477 int i; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
478 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
479 htab_traverse (cselib_hash_table, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
480 retain ? cselib_preserve_definitely : cselib_clear_preserve, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
481 NULL); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
482 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
483 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
484 cselib_invalidate_regno (i, reg_raw_mode[i]); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
485 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
486 cselib_invalidate_mem (callmem); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
487 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
488 remove_useless_values (); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
489 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
490 gcc_assert (first_containing_mem == &dummy_val); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
491 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
492 |
| 0 | 493 /* Return the mode in which a register was last set. If X is not a |
| 494 register, return its mode. If the mode in which the register was | |
| 495 set is not known, or the value was already clobbered, return | |
| 496 VOIDmode. */ | |
| 497 | |
| 498 enum machine_mode | |
| 499 cselib_reg_set_mode (const_rtx x) | |
| 500 { | |
| 501 if (!REG_P (x)) | |
| 502 return GET_MODE (x); | |
| 503 | |
| 504 if (REG_VALUES (REGNO (x)) == NULL | |
| 505 || REG_VALUES (REGNO (x))->elt == NULL) | |
| 506 return VOIDmode; | |
| 507 | |
| 508 return GET_MODE (REG_VALUES (REGNO (x))->elt->val_rtx); | |
| 509 } | |
| 510 | |
| 511 /* Return nonzero if we can prove that X and Y contain the same value, taking | |
| 512 our gathered information into account. */ | |
| 513 | |
| 514 int | |
| 515 rtx_equal_for_cselib_p (rtx x, rtx y) | |
| 516 { | |
| 517 enum rtx_code code; | |
| 518 const char *fmt; | |
| 519 int i; | |
| 520 | |
| 521 if (REG_P (x) || MEM_P (x)) | |
| 522 { | |
| 523 cselib_val *e = cselib_lookup (x, GET_MODE (x), 0); | |
| 524 | |
| 525 if (e) | |
| 526 x = e->val_rtx; | |
| 527 } | |
| 528 | |
| 529 if (REG_P (y) || MEM_P (y)) | |
| 530 { | |
| 531 cselib_val *e = cselib_lookup (y, GET_MODE (y), 0); | |
| 532 | |
| 533 if (e) | |
| 534 y = e->val_rtx; | |
| 535 } | |
| 536 | |
| 537 if (x == y) | |
| 538 return 1; | |
| 539 | |
| 540 if (GET_CODE (x) == VALUE && GET_CODE (y) == VALUE) | |
| 541 return CSELIB_VAL_PTR (x) == CSELIB_VAL_PTR (y); | |
| 542 | |
| 543 if (GET_CODE (x) == VALUE) | |
| 544 { | |
| 545 cselib_val *e = CSELIB_VAL_PTR (x); | |
| 546 struct elt_loc_list *l; | |
| 547 | |
| 548 for (l = e->locs; l; l = l->next) | |
| 549 { | |
| 550 rtx t = l->loc; | |
| 551 | |
| 552 /* Avoid infinite recursion. */ | |
| 553 if (REG_P (t) || MEM_P (t)) | |
| 554 continue; | |
| 555 else if (rtx_equal_for_cselib_p (t, y)) | |
| 556 return 1; | |
| 557 } | |
| 558 | |
| 559 return 0; | |
| 560 } | |
| 561 | |
| 562 if (GET_CODE (y) == VALUE) | |
| 563 { | |
| 564 cselib_val *e = CSELIB_VAL_PTR (y); | |
| 565 struct elt_loc_list *l; | |
| 566 | |
| 567 for (l = e->locs; l; l = l->next) | |
| 568 { | |
| 569 rtx t = l->loc; | |
| 570 | |
| 571 if (REG_P (t) || MEM_P (t)) | |
| 572 continue; | |
| 573 else if (rtx_equal_for_cselib_p (x, t)) | |
| 574 return 1; | |
| 575 } | |
| 576 | |
| 577 return 0; | |
| 578 } | |
| 579 | |
| 580 if (GET_CODE (x) != GET_CODE (y) || GET_MODE (x) != GET_MODE (y)) | |
| 581 return 0; | |
| 582 | |
| 583 /* These won't be handled correctly by the code below. */ | |
| 584 switch (GET_CODE (x)) | |
| 585 { | |
| 586 case CONST_DOUBLE: | |
| 587 case CONST_FIXED: | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
588 case DEBUG_EXPR: |
| 0 | 589 return 0; |
| 590 | |
| 591 case LABEL_REF: | |
| 592 return XEXP (x, 0) == XEXP (y, 0); | |
| 593 | |
| 594 default: | |
| 595 break; | |
| 596 } | |
| 597 | |
| 598 code = GET_CODE (x); | |
| 599 fmt = GET_RTX_FORMAT (code); | |
| 600 | |
| 601 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) | |
| 602 { | |
| 603 int j; | |
| 604 | |
| 605 switch (fmt[i]) | |
| 606 { | |
| 607 case 'w': | |
| 608 if (XWINT (x, i) != XWINT (y, i)) | |
| 609 return 0; | |
| 610 break; | |
| 611 | |
| 612 case 'n': | |
| 613 case 'i': | |
| 614 if (XINT (x, i) != XINT (y, i)) | |
| 615 return 0; | |
| 616 break; | |
| 617 | |
| 618 case 'V': | |
| 619 case 'E': | |
| 620 /* Two vectors must have the same length. */ | |
| 621 if (XVECLEN (x, i) != XVECLEN (y, i)) | |
| 622 return 0; | |
| 623 | |
| 624 /* And the corresponding elements must match. */ | |
| 625 for (j = 0; j < XVECLEN (x, i); j++) | |
| 626 if (! rtx_equal_for_cselib_p (XVECEXP (x, i, j), | |
| 627 XVECEXP (y, i, j))) | |
| 628 return 0; | |
| 629 break; | |
| 630 | |
| 631 case 'e': | |
| 632 if (i == 1 | |
| 633 && targetm.commutative_p (x, UNKNOWN) | |
| 634 && rtx_equal_for_cselib_p (XEXP (x, 1), XEXP (y, 0)) | |
| 635 && rtx_equal_for_cselib_p (XEXP (x, 0), XEXP (y, 1))) | |
| 636 return 1; | |
| 637 if (! rtx_equal_for_cselib_p (XEXP (x, i), XEXP (y, i))) | |
| 638 return 0; | |
| 639 break; | |
| 640 | |
| 641 case 'S': | |
| 642 case 's': | |
| 643 if (strcmp (XSTR (x, i), XSTR (y, i))) | |
| 644 return 0; | |
| 645 break; | |
| 646 | |
| 647 case 'u': | |
| 648 /* These are just backpointers, so they don't matter. */ | |
| 649 break; | |
| 650 | |
| 651 case '0': | |
| 652 case 't': | |
| 653 break; | |
| 654 | |
| 655 /* It is believed that rtx's at this level will never | |
| 656 contain anything but integers and other rtx's, | |
| 657 except for within LABEL_REFs and SYMBOL_REFs. */ | |
| 658 default: | |
| 659 gcc_unreachable (); | |
| 660 } | |
| 661 } | |
| 662 return 1; | |
| 663 } | |
| 664 | |
| 665 /* We need to pass down the mode of constants through the hash table | |
| 666 functions. For that purpose, wrap them in a CONST of the appropriate | |
| 667 mode. */ | |
| 668 static rtx | |
| 669 wrap_constant (enum machine_mode mode, rtx x) | |
| 670 { | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
671 if (!CONST_INT_P (x) && GET_CODE (x) != CONST_FIXED |
| 0 | 672 && (GET_CODE (x) != CONST_DOUBLE || GET_MODE (x) != VOIDmode)) |
| 673 return x; | |
| 674 gcc_assert (mode != VOIDmode); | |
| 675 return gen_rtx_CONST (mode, x); | |
| 676 } | |
| 677 | |
| 678 /* Hash an rtx. Return 0 if we couldn't hash the rtx. | |
| 679 For registers and memory locations, we look up their cselib_val structure | |
| 680 and return its VALUE element. | |
| 681 Possible reasons for return 0 are: the object is volatile, or we couldn't | |
| 682 find a register or memory location in the table and CREATE is zero. If | |
| 683 CREATE is nonzero, table elts are created for regs and mem. | |
| 684 N.B. this hash function returns the same hash value for RTXes that | |
| 685 differ only in the order of operands, thus it is suitable for comparisons | |
| 686 that take commutativity into account. | |
| 687 If we wanted to also support associative rules, we'd have to use a different | |
| 688 strategy to avoid returning spurious 0, e.g. return ~(~0U >> 1) . | |
| 689 We used to have a MODE argument for hashing for CONST_INTs, but that | |
| 690 didn't make sense, since it caused spurious hash differences between | |
| 691 (set (reg:SI 1) (const_int)) | |
| 692 (plus:SI (reg:SI 2) (reg:SI 1)) | |
| 693 and | |
| 694 (plus:SI (reg:SI 2) (const_int)) | |
| 695 If the mode is important in any context, it must be checked specifically | |
| 696 in a comparison anyway, since relying on hash differences is unsafe. */ | |
| 697 | |
| 698 static unsigned int | |
| 699 cselib_hash_rtx (rtx x, int create) | |
| 700 { | |
| 701 cselib_val *e; | |
| 702 int i, j; | |
| 703 enum rtx_code code; | |
| 704 const char *fmt; | |
| 705 unsigned int hash = 0; | |
| 706 | |
| 707 code = GET_CODE (x); | |
| 708 hash += (unsigned) code + (unsigned) GET_MODE (x); | |
| 709 | |
| 710 switch (code) | |
| 711 { | |
| 712 case MEM: | |
| 713 case REG: | |
| 714 e = cselib_lookup (x, GET_MODE (x), create); | |
| 715 if (! e) | |
| 716 return 0; | |
| 717 | |
| 718 return e->value; | |
| 719 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
720 case DEBUG_EXPR: |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
721 hash += ((unsigned) DEBUG_EXPR << 7) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
722 + DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (x)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
723 return hash ? hash : (unsigned int) DEBUG_EXPR; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
724 |
| 0 | 725 case CONST_INT: |
| 726 hash += ((unsigned) CONST_INT << 7) + INTVAL (x); | |
| 727 return hash ? hash : (unsigned int) CONST_INT; | |
| 728 | |
| 729 case CONST_DOUBLE: | |
| 730 /* This is like the general case, except that it only counts | |
| 731 the integers representing the constant. */ | |
| 732 hash += (unsigned) code + (unsigned) GET_MODE (x); | |
| 733 if (GET_MODE (x) != VOIDmode) | |
| 734 hash += real_hash (CONST_DOUBLE_REAL_VALUE (x)); | |
| 735 else | |
| 736 hash += ((unsigned) CONST_DOUBLE_LOW (x) | |
| 737 + (unsigned) CONST_DOUBLE_HIGH (x)); | |
| 738 return hash ? hash : (unsigned int) CONST_DOUBLE; | |
| 739 | |
| 740 case CONST_FIXED: | |
| 741 hash += (unsigned int) code + (unsigned int) GET_MODE (x); | |
| 742 hash += fixed_hash (CONST_FIXED_VALUE (x)); | |
| 743 return hash ? hash : (unsigned int) CONST_FIXED; | |
| 744 | |
| 745 case CONST_VECTOR: | |
| 746 { | |
| 747 int units; | |
| 748 rtx elt; | |
| 749 | |
| 750 units = CONST_VECTOR_NUNITS (x); | |
| 751 | |
| 752 for (i = 0; i < units; ++i) | |
| 753 { | |
| 754 elt = CONST_VECTOR_ELT (x, i); | |
| 755 hash += cselib_hash_rtx (elt, 0); | |
| 756 } | |
| 757 | |
| 758 return hash; | |
| 759 } | |
| 760 | |
| 761 /* Assume there is only one rtx object for any given label. */ | |
| 762 case LABEL_REF: | |
| 763 /* We don't hash on the address of the CODE_LABEL to avoid bootstrap | |
| 764 differences and differences between each stage's debugging dumps. */ | |
| 765 hash += (((unsigned int) LABEL_REF << 7) | |
| 766 + CODE_LABEL_NUMBER (XEXP (x, 0))); | |
| 767 return hash ? hash : (unsigned int) LABEL_REF; | |
| 768 | |
| 769 case SYMBOL_REF: | |
| 770 { | |
| 771 /* Don't hash on the symbol's address to avoid bootstrap differences. | |
| 772 Different hash values may cause expressions to be recorded in | |
| 773 different orders and thus different registers to be used in the | |
| 774 final assembler. This also avoids differences in the dump files | |
| 775 between various stages. */ | |
| 776 unsigned int h = 0; | |
| 777 const unsigned char *p = (const unsigned char *) XSTR (x, 0); | |
| 778 | |
| 779 while (*p) | |
| 780 h += (h << 7) + *p++; /* ??? revisit */ | |
| 781 | |
| 782 hash += ((unsigned int) SYMBOL_REF << 7) + h; | |
| 783 return hash ? hash : (unsigned int) SYMBOL_REF; | |
| 784 } | |
| 785 | |
| 786 case PRE_DEC: | |
| 787 case PRE_INC: | |
| 788 case POST_DEC: | |
| 789 case POST_INC: | |
| 790 case POST_MODIFY: | |
| 791 case PRE_MODIFY: | |
| 792 case PC: | |
| 793 case CC0: | |
| 794 case CALL: | |
| 795 case UNSPEC_VOLATILE: | |
| 796 return 0; | |
| 797 | |
| 798 case ASM_OPERANDS: | |
| 799 if (MEM_VOLATILE_P (x)) | |
| 800 return 0; | |
| 801 | |
| 802 break; | |
| 803 | |
| 804 default: | |
| 805 break; | |
| 806 } | |
| 807 | |
| 808 i = GET_RTX_LENGTH (code) - 1; | |
| 809 fmt = GET_RTX_FORMAT (code); | |
| 810 for (; i >= 0; i--) | |
| 811 { | |
| 812 switch (fmt[i]) | |
| 813 { | |
| 814 case 'e': | |
| 815 { | |
| 816 rtx tem = XEXP (x, i); | |
| 817 unsigned int tem_hash = cselib_hash_rtx (tem, create); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
818 |
| 0 | 819 if (tem_hash == 0) |
| 820 return 0; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
821 |
| 0 | 822 hash += tem_hash; |
| 823 } | |
| 824 break; | |
| 825 case 'E': | |
| 826 for (j = 0; j < XVECLEN (x, i); j++) | |
| 827 { | |
| 828 unsigned int tem_hash | |
| 829 = cselib_hash_rtx (XVECEXP (x, i, j), create); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
830 |
| 0 | 831 if (tem_hash == 0) |
| 832 return 0; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
833 |
| 0 | 834 hash += tem_hash; |
| 835 } | |
| 836 break; | |
| 837 | |
| 838 case 's': | |
| 839 { | |
| 840 const unsigned char *p = (const unsigned char *) XSTR (x, i); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
841 |
| 0 | 842 if (p) |
| 843 while (*p) | |
| 844 hash += *p++; | |
| 845 break; | |
| 846 } | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
847 |
| 0 | 848 case 'i': |
| 849 hash += XINT (x, i); | |
| 850 break; | |
| 851 | |
| 852 case '0': | |
| 853 case 't': | |
| 854 /* unused */ | |
| 855 break; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
856 |
| 0 | 857 default: |
| 858 gcc_unreachable (); | |
| 859 } | |
| 860 } | |
| 861 | |
| 862 return hash ? hash : 1 + (unsigned int) GET_CODE (x); | |
| 863 } | |
| 864 | |
| 865 /* Create a new value structure for VALUE and initialize it. The mode of the | |
| 866 value is MODE. */ | |
| 867 | |
| 868 static inline cselib_val * | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
869 new_cselib_val (unsigned int value, enum machine_mode mode, rtx x) |
| 0 | 870 { |
| 871 cselib_val *e = (cselib_val *) pool_alloc (cselib_val_pool); | |
| 872 | |
| 873 gcc_assert (value); | |
| 874 | |
| 875 e->value = value; | |
| 876 /* We use an alloc pool to allocate this RTL construct because it | |
| 877 accounts for about 8% of the overall memory usage. We know | |
| 878 precisely when we can have VALUE RTXen (when cselib is active) | |
| 879 so we don't need to put them in garbage collected memory. | |
| 880 ??? Why should a VALUE be an RTX in the first place? */ | |
| 881 e->val_rtx = (rtx) pool_alloc (value_pool); | |
| 882 memset (e->val_rtx, 0, RTX_HDR_SIZE); | |
| 883 PUT_CODE (e->val_rtx, VALUE); | |
| 884 PUT_MODE (e->val_rtx, mode); | |
| 885 CSELIB_VAL_PTR (e->val_rtx) = e; | |
| 886 e->addr_list = 0; | |
| 887 e->locs = 0; | |
| 888 e->next_containing_mem = 0; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
889 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
890 if (dump_file && (dump_flags & TDF_DETAILS)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
891 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
892 fprintf (dump_file, "cselib value %u ", value); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
893 if (flag_dump_noaddr || flag_dump_unnumbered) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
894 fputs ("# ", dump_file); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
895 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
896 fprintf (dump_file, "%p ", (void*)e); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
897 print_rtl_single (dump_file, x); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
898 fputc ('\n', dump_file); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
899 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
900 |
| 0 | 901 return e; |
| 902 } | |
| 903 | |
| 904 /* ADDR_ELT is a value that is used as address. MEM_ELT is the value that | |
| 905 contains the data at this address. X is a MEM that represents the | |
| 906 value. Update the two value structures to represent this situation. */ | |
| 907 | |
| 908 static void | |
| 909 add_mem_for_addr (cselib_val *addr_elt, cselib_val *mem_elt, rtx x) | |
| 910 { | |
| 911 struct elt_loc_list *l; | |
| 912 | |
| 913 /* Avoid duplicates. */ | |
| 914 for (l = mem_elt->locs; l; l = l->next) | |
| 915 if (MEM_P (l->loc) | |
| 916 && CSELIB_VAL_PTR (XEXP (l->loc, 0)) == addr_elt) | |
| 917 return; | |
| 918 | |
| 919 addr_elt->addr_list = new_elt_list (addr_elt->addr_list, mem_elt); | |
| 920 mem_elt->locs | |
| 921 = new_elt_loc_list (mem_elt->locs, | |
| 922 replace_equiv_address_nv (x, addr_elt->val_rtx)); | |
| 923 if (mem_elt->next_containing_mem == NULL) | |
| 924 { | |
| 925 mem_elt->next_containing_mem = first_containing_mem; | |
| 926 first_containing_mem = mem_elt; | |
| 927 } | |
| 928 } | |
| 929 | |
| 930 /* Subroutine of cselib_lookup. Return a value for X, which is a MEM rtx. | |
| 931 If CREATE, make a new one if we haven't seen it before. */ | |
| 932 | |
| 933 static cselib_val * | |
| 934 cselib_lookup_mem (rtx x, int create) | |
| 935 { | |
| 936 enum machine_mode mode = GET_MODE (x); | |
| 937 void **slot; | |
| 938 cselib_val *addr; | |
| 939 cselib_val *mem_elt; | |
| 940 struct elt_list *l; | |
| 941 | |
| 942 if (MEM_VOLATILE_P (x) || mode == BLKmode | |
| 943 || !cselib_record_memory | |
| 944 || (FLOAT_MODE_P (mode) && flag_float_store)) | |
| 945 return 0; | |
| 946 | |
| 947 /* Look up the value for the address. */ | |
| 948 addr = cselib_lookup (XEXP (x, 0), mode, create); | |
| 949 if (! addr) | |
| 950 return 0; | |
| 951 | |
| 952 /* Find a value that describes a value of our mode at that address. */ | |
| 953 for (l = addr->addr_list; l; l = l->next) | |
| 954 if (GET_MODE (l->elt->val_rtx) == mode) | |
| 955 return l->elt; | |
| 956 | |
| 957 if (! create) | |
| 958 return 0; | |
| 959 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
960 mem_elt = new_cselib_val (++next_unknown_value, mode, x); |
| 0 | 961 add_mem_for_addr (addr, mem_elt, x); |
| 962 slot = htab_find_slot_with_hash (cselib_hash_table, wrap_constant (mode, x), | |
| 963 mem_elt->value, INSERT); | |
| 964 *slot = mem_elt; | |
| 965 return mem_elt; | |
| 966 } | |
| 967 | |
| 968 /* Search thru the possible substitutions in P. We prefer a non reg | |
| 969 substitution because this allows us to expand the tree further. If | |
| 970 we find, just a reg, take the lowest regno. There may be several | |
| 971 non-reg results, we just take the first one because they will all | |
| 972 expand to the same place. */ | |
| 973 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
974 static rtx |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
975 expand_loc (struct elt_loc_list *p, struct expand_value_data *evd, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
976 int max_depth) |
| 0 | 977 { |
| 978 rtx reg_result = NULL; | |
| 979 unsigned int regno = UINT_MAX; | |
| 980 struct elt_loc_list *p_in = p; | |
| 981 | |
| 982 for (; p; p = p -> next) | |
| 983 { | |
| 984 /* Avoid infinite recursion trying to expand a reg into a | |
| 985 the same reg. */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
986 if ((REG_P (p->loc)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
987 && (REGNO (p->loc) < regno) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
988 && !bitmap_bit_p (evd->regs_active, REGNO (p->loc))) |
| 0 | 989 { |
| 990 reg_result = p->loc; | |
| 991 regno = REGNO (p->loc); | |
| 992 } | |
| 993 /* Avoid infinite recursion and do not try to expand the | |
| 994 value. */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
995 else if (GET_CODE (p->loc) == VALUE |
| 0 | 996 && CSELIB_VAL_PTR (p->loc)->locs == p_in) |
| 997 continue; | |
| 998 else if (!REG_P (p->loc)) | |
| 999 { | |
| 1000 rtx result, note; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1001 if (dump_file && (dump_flags & TDF_DETAILS)) |
| 0 | 1002 { |
| 1003 print_inline_rtx (dump_file, p->loc, 0); | |
| 1004 fprintf (dump_file, "\n"); | |
| 1005 } | |
| 1006 if (GET_CODE (p->loc) == LO_SUM | |
| 1007 && GET_CODE (XEXP (p->loc, 1)) == SYMBOL_REF | |
| 1008 && p->setting_insn | |
| 1009 && (note = find_reg_note (p->setting_insn, REG_EQUAL, NULL_RTX)) | |
| 1010 && XEXP (note, 0) == XEXP (p->loc, 1)) | |
| 1011 return XEXP (p->loc, 1); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1012 result = cselib_expand_value_rtx_1 (p->loc, evd, max_depth - 1); |
| 0 | 1013 if (result) |
| 1014 return result; | |
| 1015 } | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1016 |
| 0 | 1017 } |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1018 |
| 0 | 1019 if (regno != UINT_MAX) |
| 1020 { | |
| 1021 rtx result; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1022 if (dump_file && (dump_flags & TDF_DETAILS)) |
| 0 | 1023 fprintf (dump_file, "r%d\n", regno); |
| 1024 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1025 result = cselib_expand_value_rtx_1 (reg_result, evd, max_depth - 1); |
| 0 | 1026 if (result) |
| 1027 return result; | |
| 1028 } | |
| 1029 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1030 if (dump_file && (dump_flags & TDF_DETAILS)) |
| 0 | 1031 { |
| 1032 if (reg_result) | |
| 1033 { | |
| 1034 print_inline_rtx (dump_file, reg_result, 0); | |
| 1035 fprintf (dump_file, "\n"); | |
| 1036 } | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1037 else |
| 0 | 1038 fprintf (dump_file, "NULL\n"); |
| 1039 } | |
| 1040 return reg_result; | |
| 1041 } | |
| 1042 | |
| 1043 | |
| 1044 /* Forward substitute and expand an expression out to its roots. | |
| 1045 This is the opposite of common subexpression. Because local value | |
| 1046 numbering is such a weak optimization, the expanded expression is | |
| 1047 pretty much unique (not from a pointer equals point of view but | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1048 from a tree shape point of view. |
| 0 | 1049 |
| 1050 This function returns NULL if the expansion fails. The expansion | |
| 1051 will fail if there is no value number for one of the operands or if | |
| 1052 one of the operands has been overwritten between the current insn | |
| 1053 and the beginning of the basic block. For instance x has no | |
| 1054 expansion in: | |
| 1055 | |
| 1056 r1 <- r1 + 3 | |
| 1057 x <- r1 + 8 | |
| 1058 | |
| 1059 REGS_ACTIVE is a scratch bitmap that should be clear when passing in. | |
| 1060 It is clear on return. */ | |
| 1061 | |
| 1062 rtx | |
| 1063 cselib_expand_value_rtx (rtx orig, bitmap regs_active, int max_depth) | |
| 1064 { | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1065 struct expand_value_data evd; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1066 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1067 evd.regs_active = regs_active; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1068 evd.callback = NULL; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1069 evd.callback_arg = NULL; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1070 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1071 return cselib_expand_value_rtx_1 (orig, &evd, max_depth); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1072 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1073 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1074 /* Same as cselib_expand_value_rtx, but using a callback to try to |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1075 resolve some expressions. The CB function should return ORIG if it |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1076 can't or does not want to deal with a certain RTX. Any other |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1077 return value, including NULL, will be used as the expansion for |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1078 VALUE, without any further changes. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1079 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1080 rtx |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1081 cselib_expand_value_rtx_cb (rtx orig, bitmap regs_active, int max_depth, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1082 cselib_expand_callback cb, void *data) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1083 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1084 struct expand_value_data evd; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1085 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1086 evd.regs_active = regs_active; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1087 evd.callback = cb; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1088 evd.callback_arg = data; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1089 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1090 return cselib_expand_value_rtx_1 (orig, &evd, max_depth); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1091 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1092 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1093 /* Internal implementation of cselib_expand_value_rtx and |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1094 cselib_expand_value_rtx_cb. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1095 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1096 static rtx |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1097 cselib_expand_value_rtx_1 (rtx orig, struct expand_value_data *evd, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1098 int max_depth) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1099 { |
| 0 | 1100 rtx copy, scopy; |
| 1101 int i, j; | |
| 1102 RTX_CODE code; | |
| 1103 const char *format_ptr; | |
| 1104 enum machine_mode mode; | |
| 1105 | |
| 1106 code = GET_CODE (orig); | |
| 1107 | |
| 1108 /* For the context of dse, if we end up expand into a huge tree, we | |
| 1109 will not have a useful address, so we might as well just give up | |
| 1110 quickly. */ | |
| 1111 if (max_depth <= 0) | |
| 1112 return NULL; | |
| 1113 | |
| 1114 switch (code) | |
| 1115 { | |
| 1116 case REG: | |
| 1117 { | |
| 1118 struct elt_list *l = REG_VALUES (REGNO (orig)); | |
| 1119 | |
| 1120 if (l && l->elt == NULL) | |
| 1121 l = l->next; | |
| 1122 for (; l; l = l->next) | |
| 1123 if (GET_MODE (l->elt->val_rtx) == GET_MODE (orig)) | |
| 1124 { | |
| 1125 rtx result; | |
| 1126 int regno = REGNO (orig); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1127 |
| 0 | 1128 /* The only thing that we are not willing to do (this |
| 1129 is requirement of dse and if others potential uses | |
| 1130 need this function we should add a parm to control | |
| 1131 it) is that we will not substitute the | |
| 1132 STACK_POINTER_REGNUM, FRAME_POINTER or the | |
| 1133 HARD_FRAME_POINTER. | |
| 1134 | |
| 1135 These expansions confuses the code that notices that | |
| 1136 stores into the frame go dead at the end of the | |
| 1137 function and that the frame is not effected by calls | |
| 1138 to subroutines. If you allow the | |
| 1139 STACK_POINTER_REGNUM substitution, then dse will | |
| 1140 think that parameter pushing also goes dead which is | |
| 1141 wrong. If you allow the FRAME_POINTER or the | |
| 1142 HARD_FRAME_POINTER then you lose the opportunity to | |
| 1143 make the frame assumptions. */ | |
| 1144 if (regno == STACK_POINTER_REGNUM | |
| 1145 || regno == FRAME_POINTER_REGNUM | |
| 1146 || regno == HARD_FRAME_POINTER_REGNUM) | |
| 1147 return orig; | |
| 1148 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1149 bitmap_set_bit (evd->regs_active, regno); |
| 0 | 1150 |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1151 if (dump_file && (dump_flags & TDF_DETAILS)) |
| 0 | 1152 fprintf (dump_file, "expanding: r%d into: ", regno); |
| 1153 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1154 result = expand_loc (l->elt->locs, evd, max_depth); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1155 bitmap_clear_bit (evd->regs_active, regno); |
| 0 | 1156 |
| 1157 if (result) | |
| 1158 return result; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1159 else |
| 0 | 1160 return orig; |
| 1161 } | |
| 1162 } | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1163 |
| 0 | 1164 case CONST_INT: |
| 1165 case CONST_DOUBLE: | |
| 1166 case CONST_VECTOR: | |
| 1167 case SYMBOL_REF: | |
| 1168 case CODE_LABEL: | |
| 1169 case PC: | |
| 1170 case CC0: | |
| 1171 case SCRATCH: | |
| 1172 /* SCRATCH must be shared because they represent distinct values. */ | |
| 1173 return orig; | |
| 1174 case CLOBBER: | |
| 1175 if (REG_P (XEXP (orig, 0)) && HARD_REGISTER_NUM_P (REGNO (XEXP (orig, 0)))) | |
| 1176 return orig; | |
| 1177 break; | |
| 1178 | |
| 1179 case CONST: | |
| 1180 if (shared_const_p (orig)) | |
| 1181 return orig; | |
| 1182 break; | |
| 1183 | |
| 1184 case SUBREG: | |
| 1185 { | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1186 rtx subreg; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1187 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1188 if (evd->callback) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1189 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1190 subreg = evd->callback (orig, evd->regs_active, max_depth, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1191 evd->callback_arg); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1192 if (subreg != orig) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1193 return subreg; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1194 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1195 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1196 subreg = cselib_expand_value_rtx_1 (SUBREG_REG (orig), evd, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1197 max_depth - 1); |
| 0 | 1198 if (!subreg) |
| 1199 return NULL; | |
| 1200 scopy = simplify_gen_subreg (GET_MODE (orig), subreg, | |
| 1201 GET_MODE (SUBREG_REG (orig)), | |
| 1202 SUBREG_BYTE (orig)); | |
| 1203 if (scopy == NULL | |
| 1204 || (GET_CODE (scopy) == SUBREG | |
| 1205 && !REG_P (SUBREG_REG (scopy)) | |
| 1206 && !MEM_P (SUBREG_REG (scopy)))) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1207 return NULL; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1208 |
| 0 | 1209 return scopy; |
| 1210 } | |
| 1211 | |
| 1212 case VALUE: | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1213 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1214 rtx result; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1215 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1216 if (dump_file && (dump_flags & TDF_DETAILS)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1217 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1218 fputs ("\nexpanding ", dump_file); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1219 print_rtl_single (dump_file, orig); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1220 fputs (" into...", dump_file); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1221 } |
| 0 | 1222 |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1223 if (evd->callback) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1224 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1225 result = evd->callback (orig, evd->regs_active, max_depth, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1226 evd->callback_arg); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1227 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1228 if (result != orig) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1229 return result; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1230 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1231 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1232 result = expand_loc (CSELIB_VAL_PTR (orig)->locs, evd, max_depth); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1233 return result; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1234 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1235 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1236 case DEBUG_EXPR: |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1237 if (evd->callback) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1238 return evd->callback (orig, evd->regs_active, max_depth, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1239 evd->callback_arg); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1240 return orig; |
| 0 | 1241 |
| 1242 default: | |
| 1243 break; | |
| 1244 } | |
| 1245 | |
| 1246 /* Copy the various flags, fields, and other information. We assume | |
| 1247 that all fields need copying, and then clear the fields that should | |
| 1248 not be copied. That is the sensible default behavior, and forces | |
| 1249 us to explicitly document why we are *not* copying a flag. */ | |
| 1250 copy = shallow_copy_rtx (orig); | |
| 1251 | |
| 1252 format_ptr = GET_RTX_FORMAT (code); | |
| 1253 | |
| 1254 for (i = 0; i < GET_RTX_LENGTH (code); i++) | |
| 1255 switch (*format_ptr++) | |
| 1256 { | |
| 1257 case 'e': | |
| 1258 if (XEXP (orig, i) != NULL) | |
| 1259 { | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1260 rtx result = cselib_expand_value_rtx_1 (XEXP (orig, i), evd, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1261 max_depth - 1); |
| 0 | 1262 if (!result) |
| 1263 return NULL; | |
| 1264 XEXP (copy, i) = result; | |
| 1265 } | |
| 1266 break; | |
| 1267 | |
| 1268 case 'E': | |
| 1269 case 'V': | |
| 1270 if (XVEC (orig, i) != NULL) | |
| 1271 { | |
| 1272 XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i)); | |
| 1273 for (j = 0; j < XVECLEN (copy, i); j++) | |
| 1274 { | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1275 rtx result = cselib_expand_value_rtx_1 (XVECEXP (orig, i, j), |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1276 evd, max_depth - 1); |
| 0 | 1277 if (!result) |
| 1278 return NULL; | |
| 1279 XVECEXP (copy, i, j) = result; | |
| 1280 } | |
| 1281 } | |
| 1282 break; | |
| 1283 | |
| 1284 case 't': | |
| 1285 case 'w': | |
| 1286 case 'i': | |
| 1287 case 's': | |
| 1288 case 'S': | |
| 1289 case 'T': | |
| 1290 case 'u': | |
| 1291 case 'B': | |
| 1292 case '0': | |
| 1293 /* These are left unchanged. */ | |
| 1294 break; | |
| 1295 | |
| 1296 default: | |
| 1297 gcc_unreachable (); | |
| 1298 } | |
| 1299 | |
| 1300 mode = GET_MODE (copy); | |
| 1301 /* If an operand has been simplified into CONST_INT, which doesn't | |
| 1302 have a mode and the mode isn't derivable from whole rtx's mode, | |
| 1303 try simplify_*_operation first with mode from original's operand | |
| 1304 and as a fallback wrap CONST_INT into gen_rtx_CONST. */ | |
| 1305 scopy = copy; | |
| 1306 switch (GET_RTX_CLASS (code)) | |
| 1307 { | |
| 1308 case RTX_UNARY: | |
| 1309 if (CONST_INT_P (XEXP (copy, 0)) | |
| 1310 && GET_MODE (XEXP (orig, 0)) != VOIDmode) | |
| 1311 { | |
| 1312 scopy = simplify_unary_operation (code, mode, XEXP (copy, 0), | |
| 1313 GET_MODE (XEXP (orig, 0))); | |
| 1314 if (scopy) | |
| 1315 return scopy; | |
| 1316 } | |
| 1317 break; | |
| 1318 case RTX_COMM_ARITH: | |
| 1319 case RTX_BIN_ARITH: | |
| 1320 /* These expressions can derive operand modes from the whole rtx's mode. */ | |
| 1321 break; | |
| 1322 case RTX_TERNARY: | |
| 1323 case RTX_BITFIELD_OPS: | |
| 1324 if (CONST_INT_P (XEXP (copy, 0)) | |
| 1325 && GET_MODE (XEXP (orig, 0)) != VOIDmode) | |
| 1326 { | |
| 1327 scopy = simplify_ternary_operation (code, mode, | |
| 1328 GET_MODE (XEXP (orig, 0)), | |
| 1329 XEXP (copy, 0), XEXP (copy, 1), | |
| 1330 XEXP (copy, 2)); | |
| 1331 if (scopy) | |
| 1332 return scopy; | |
| 1333 } | |
| 1334 break; | |
| 1335 case RTX_COMPARE: | |
| 1336 case RTX_COMM_COMPARE: | |
| 1337 if (CONST_INT_P (XEXP (copy, 0)) | |
| 1338 && GET_MODE (XEXP (copy, 1)) == VOIDmode | |
| 1339 && (GET_MODE (XEXP (orig, 0)) != VOIDmode | |
| 1340 || GET_MODE (XEXP (orig, 1)) != VOIDmode)) | |
| 1341 { | |
| 1342 scopy = simplify_relational_operation (code, mode, | |
| 1343 (GET_MODE (XEXP (orig, 0)) | |
| 1344 != VOIDmode) | |
| 1345 ? GET_MODE (XEXP (orig, 0)) | |
| 1346 : GET_MODE (XEXP (orig, 1)), | |
| 1347 XEXP (copy, 0), | |
| 1348 XEXP (copy, 1)); | |
| 1349 if (scopy) | |
| 1350 return scopy; | |
| 1351 } | |
| 1352 break; | |
| 1353 default: | |
| 1354 break; | |
| 1355 } | |
| 1356 scopy = simplify_rtx (copy); | |
| 1357 if (scopy) | |
| 1358 return scopy; | |
| 1359 return copy; | |
| 1360 } | |
| 1361 | |
| 1362 /* Walk rtx X and replace all occurrences of REG and MEM subexpressions | |
| 1363 with VALUE expressions. This way, it becomes independent of changes | |
| 1364 to registers and memory. | |
| 1365 X isn't actually modified; if modifications are needed, new rtl is | |
| 1366 allocated. However, the return value can share rtl with X. */ | |
| 1367 | |
| 1368 rtx | |
| 1369 cselib_subst_to_values (rtx x) | |
| 1370 { | |
| 1371 enum rtx_code code = GET_CODE (x); | |
| 1372 const char *fmt = GET_RTX_FORMAT (code); | |
| 1373 cselib_val *e; | |
| 1374 struct elt_list *l; | |
| 1375 rtx copy = x; | |
| 1376 int i; | |
| 1377 | |
| 1378 switch (code) | |
| 1379 { | |
| 1380 case REG: | |
| 1381 l = REG_VALUES (REGNO (x)); | |
| 1382 if (l && l->elt == NULL) | |
| 1383 l = l->next; | |
| 1384 for (; l; l = l->next) | |
| 1385 if (GET_MODE (l->elt->val_rtx) == GET_MODE (x)) | |
| 1386 return l->elt->val_rtx; | |
| 1387 | |
| 1388 gcc_unreachable (); | |
| 1389 | |
| 1390 case MEM: | |
| 1391 e = cselib_lookup_mem (x, 0); | |
| 1392 if (! e) | |
| 1393 { | |
| 1394 /* This happens for autoincrements. Assign a value that doesn't | |
| 1395 match any other. */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1396 e = new_cselib_val (++next_unknown_value, GET_MODE (x), x); |
| 0 | 1397 } |
| 1398 return e->val_rtx; | |
| 1399 | |
| 1400 case CONST_DOUBLE: | |
| 1401 case CONST_VECTOR: | |
| 1402 case CONST_INT: | |
| 1403 case CONST_FIXED: | |
| 1404 return x; | |
| 1405 | |
| 1406 case POST_INC: | |
| 1407 case PRE_INC: | |
| 1408 case POST_DEC: | |
| 1409 case PRE_DEC: | |
| 1410 case POST_MODIFY: | |
| 1411 case PRE_MODIFY: | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1412 e = new_cselib_val (++next_unknown_value, GET_MODE (x), x); |
| 0 | 1413 return e->val_rtx; |
| 1414 | |
| 1415 default: | |
| 1416 break; | |
| 1417 } | |
| 1418 | |
| 1419 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) | |
| 1420 { | |
| 1421 if (fmt[i] == 'e') | |
| 1422 { | |
| 1423 rtx t = cselib_subst_to_values (XEXP (x, i)); | |
| 1424 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1425 if (t != XEXP (x, i)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1426 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1427 if (x == copy) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1428 copy = shallow_copy_rtx (x); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1429 XEXP (copy, i) = t; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1430 } |
| 0 | 1431 } |
| 1432 else if (fmt[i] == 'E') | |
| 1433 { | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1434 int j; |
| 0 | 1435 |
| 1436 for (j = 0; j < XVECLEN (x, i); j++) | |
| 1437 { | |
| 1438 rtx t = cselib_subst_to_values (XVECEXP (x, i, j)); | |
| 1439 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1440 if (t != XVECEXP (x, i, j)) |
| 0 | 1441 { |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1442 if (XVEC (x, i) == XVEC (copy, i)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1443 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1444 if (x == copy) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1445 copy = shallow_copy_rtx (x); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1446 XVEC (copy, i) = shallow_copy_rtvec (XVEC (x, i)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1447 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1448 XVECEXP (copy, i, j) = t; |
| 0 | 1449 } |
| 1450 } | |
| 1451 } | |
| 1452 } | |
| 1453 | |
| 1454 return copy; | |
| 1455 } | |
| 1456 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1457 /* Log a lookup of X to the cselib table along with the result RET. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1458 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1459 static cselib_val * |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1460 cselib_log_lookup (rtx x, cselib_val *ret) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1461 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1462 if (dump_file && (dump_flags & TDF_DETAILS)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1463 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1464 fputs ("cselib lookup ", dump_file); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1465 print_inline_rtx (dump_file, x, 2); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1466 fprintf (dump_file, " => %u\n", ret ? ret->value : 0); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1467 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1468 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1469 return ret; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1470 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1471 |
| 0 | 1472 /* Look up the rtl expression X in our tables and return the value it has. |
| 1473 If CREATE is zero, we return NULL if we don't know the value. Otherwise, | |
| 1474 we create a new one if possible, using mode MODE if X doesn't have a mode | |
| 1475 (i.e. because it's a constant). */ | |
| 1476 | |
| 1477 cselib_val * | |
| 1478 cselib_lookup (rtx x, enum machine_mode mode, int create) | |
| 1479 { | |
| 1480 void **slot; | |
| 1481 cselib_val *e; | |
| 1482 unsigned int hashval; | |
| 1483 | |
| 1484 if (GET_MODE (x) != VOIDmode) | |
| 1485 mode = GET_MODE (x); | |
| 1486 | |
| 1487 if (GET_CODE (x) == VALUE) | |
| 1488 return CSELIB_VAL_PTR (x); | |
| 1489 | |
| 1490 if (REG_P (x)) | |
| 1491 { | |
| 1492 struct elt_list *l; | |
| 1493 unsigned int i = REGNO (x); | |
| 1494 | |
| 1495 l = REG_VALUES (i); | |
| 1496 if (l && l->elt == NULL) | |
| 1497 l = l->next; | |
| 1498 for (; l; l = l->next) | |
| 1499 if (mode == GET_MODE (l->elt->val_rtx)) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1500 return cselib_log_lookup (x, l->elt); |
| 0 | 1501 |
| 1502 if (! create) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1503 return cselib_log_lookup (x, 0); |
| 0 | 1504 |
| 1505 if (i < FIRST_PSEUDO_REGISTER) | |
| 1506 { | |
| 1507 unsigned int n = hard_regno_nregs[i][mode]; | |
| 1508 | |
| 1509 if (n > max_value_regs) | |
| 1510 max_value_regs = n; | |
| 1511 } | |
| 1512 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1513 e = new_cselib_val (++next_unknown_value, GET_MODE (x), x); |
| 0 | 1514 e->locs = new_elt_loc_list (e->locs, x); |
| 1515 if (REG_VALUES (i) == 0) | |
| 1516 { | |
| 1517 /* Maintain the invariant that the first entry of | |
| 1518 REG_VALUES, if present, must be the value used to set the | |
| 1519 register, or NULL. */ | |
| 1520 used_regs[n_used_regs++] = i; | |
| 1521 REG_VALUES (i) = new_elt_list (REG_VALUES (i), NULL); | |
| 1522 } | |
| 1523 REG_VALUES (i)->next = new_elt_list (REG_VALUES (i)->next, e); | |
| 1524 slot = htab_find_slot_with_hash (cselib_hash_table, x, e->value, INSERT); | |
| 1525 *slot = e; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1526 return cselib_log_lookup (x, e); |
| 0 | 1527 } |
| 1528 | |
| 1529 if (MEM_P (x)) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1530 return cselib_log_lookup (x, cselib_lookup_mem (x, create)); |
| 0 | 1531 |
| 1532 hashval = cselib_hash_rtx (x, create); | |
| 1533 /* Can't even create if hashing is not possible. */ | |
| 1534 if (! hashval) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1535 return cselib_log_lookup (x, 0); |
| 0 | 1536 |
| 1537 slot = htab_find_slot_with_hash (cselib_hash_table, wrap_constant (mode, x), | |
| 1538 hashval, create ? INSERT : NO_INSERT); | |
| 1539 if (slot == 0) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1540 return cselib_log_lookup (x, 0); |
| 0 | 1541 |
| 1542 e = (cselib_val *) *slot; | |
| 1543 if (e) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1544 return cselib_log_lookup (x, e); |
| 0 | 1545 |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1546 e = new_cselib_val (hashval, mode, x); |
| 0 | 1547 |
| 1548 /* We have to fill the slot before calling cselib_subst_to_values: | |
| 1549 the hash table is inconsistent until we do so, and | |
| 1550 cselib_subst_to_values will need to do lookups. */ | |
| 1551 *slot = (void *) e; | |
| 1552 e->locs = new_elt_loc_list (e->locs, cselib_subst_to_values (x)); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1553 return cselib_log_lookup (x, e); |
| 0 | 1554 } |
| 1555 | |
| 1556 /* Invalidate any entries in reg_values that overlap REGNO. This is called | |
| 1557 if REGNO is changing. MODE is the mode of the assignment to REGNO, which | |
| 1558 is used to determine how many hard registers are being changed. If MODE | |
| 1559 is VOIDmode, then only REGNO is being changed; this is used when | |
| 1560 invalidating call clobbered registers across a call. */ | |
| 1561 | |
| 1562 static void | |
| 1563 cselib_invalidate_regno (unsigned int regno, enum machine_mode mode) | |
| 1564 { | |
| 1565 unsigned int endregno; | |
| 1566 unsigned int i; | |
| 1567 | |
| 1568 /* If we see pseudos after reload, something is _wrong_. */ | |
| 1569 gcc_assert (!reload_completed || regno < FIRST_PSEUDO_REGISTER | |
| 1570 || reg_renumber[regno] < 0); | |
| 1571 | |
| 1572 /* Determine the range of registers that must be invalidated. For | |
| 1573 pseudos, only REGNO is affected. For hard regs, we must take MODE | |
| 1574 into account, and we must also invalidate lower register numbers | |
| 1575 if they contain values that overlap REGNO. */ | |
| 1576 if (regno < FIRST_PSEUDO_REGISTER) | |
| 1577 { | |
| 1578 gcc_assert (mode != VOIDmode); | |
| 1579 | |
| 1580 if (regno < max_value_regs) | |
| 1581 i = 0; | |
| 1582 else | |
| 1583 i = regno - max_value_regs; | |
| 1584 | |
| 1585 endregno = end_hard_regno (mode, regno); | |
| 1586 } | |
| 1587 else | |
| 1588 { | |
| 1589 i = regno; | |
| 1590 endregno = regno + 1; | |
| 1591 } | |
| 1592 | |
| 1593 for (; i < endregno; i++) | |
| 1594 { | |
| 1595 struct elt_list **l = ®_VALUES (i); | |
| 1596 | |
| 1597 /* Go through all known values for this reg; if it overlaps the range | |
| 1598 we're invalidating, remove the value. */ | |
| 1599 while (*l) | |
| 1600 { | |
| 1601 cselib_val *v = (*l)->elt; | |
| 1602 struct elt_loc_list **p; | |
| 1603 unsigned int this_last = i; | |
| 1604 | |
| 1605 if (i < FIRST_PSEUDO_REGISTER && v != NULL) | |
| 1606 this_last = end_hard_regno (GET_MODE (v->val_rtx), i) - 1; | |
| 1607 | |
| 1608 if (this_last < regno || v == NULL) | |
| 1609 { | |
| 1610 l = &(*l)->next; | |
| 1611 continue; | |
| 1612 } | |
| 1613 | |
| 1614 /* We have an overlap. */ | |
| 1615 if (*l == REG_VALUES (i)) | |
| 1616 { | |
| 1617 /* Maintain the invariant that the first entry of | |
| 1618 REG_VALUES, if present, must be the value used to set | |
| 1619 the register, or NULL. This is also nice because | |
| 1620 then we won't push the same regno onto user_regs | |
| 1621 multiple times. */ | |
| 1622 (*l)->elt = NULL; | |
| 1623 l = &(*l)->next; | |
| 1624 } | |
| 1625 else | |
| 1626 unchain_one_elt_list (l); | |
| 1627 | |
| 1628 /* Now, we clear the mapping from value to reg. It must exist, so | |
| 1629 this code will crash intentionally if it doesn't. */ | |
| 1630 for (p = &v->locs; ; p = &(*p)->next) | |
| 1631 { | |
| 1632 rtx x = (*p)->loc; | |
| 1633 | |
| 1634 if (REG_P (x) && REGNO (x) == i) | |
| 1635 { | |
| 1636 unchain_one_elt_loc_list (p); | |
| 1637 break; | |
| 1638 } | |
| 1639 } | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1640 if (v->locs == 0 && !PRESERVED_VALUE_P (v->val_rtx)) |
| 0 | 1641 n_useless_values++; |
| 1642 } | |
| 1643 } | |
| 1644 } | |
| 1645 | |
| 1646 /* Return 1 if X has a value that can vary even between two | |
| 1647 executions of the program. 0 means X can be compared reliably | |
| 1648 against certain constants or near-constants. */ | |
| 1649 | |
| 1650 static bool | |
| 1651 cselib_rtx_varies_p (const_rtx x ATTRIBUTE_UNUSED, bool from_alias ATTRIBUTE_UNUSED) | |
| 1652 { | |
| 1653 /* We actually don't need to verify very hard. This is because | |
| 1654 if X has actually changed, we invalidate the memory anyway, | |
| 1655 so assume that all common memory addresses are | |
| 1656 invariant. */ | |
| 1657 return 0; | |
| 1658 } | |
| 1659 | |
| 1660 /* Invalidate any locations in the table which are changed because of a | |
| 1661 store to MEM_RTX. If this is called because of a non-const call | |
| 1662 instruction, MEM_RTX is (mem:BLK const0_rtx). */ | |
| 1663 | |
| 1664 static void | |
| 1665 cselib_invalidate_mem (rtx mem_rtx) | |
| 1666 { | |
| 1667 cselib_val **vp, *v, *next; | |
| 1668 int num_mems = 0; | |
| 1669 rtx mem_addr; | |
| 1670 | |
| 1671 mem_addr = canon_rtx (get_addr (XEXP (mem_rtx, 0))); | |
| 1672 mem_rtx = canon_rtx (mem_rtx); | |
| 1673 | |
| 1674 vp = &first_containing_mem; | |
| 1675 for (v = *vp; v != &dummy_val; v = next) | |
| 1676 { | |
| 1677 bool has_mem = false; | |
| 1678 struct elt_loc_list **p = &v->locs; | |
| 1679 int had_locs = v->locs != 0; | |
| 1680 | |
| 1681 while (*p) | |
| 1682 { | |
| 1683 rtx x = (*p)->loc; | |
| 1684 cselib_val *addr; | |
| 1685 struct elt_list **mem_chain; | |
| 1686 | |
| 1687 /* MEMs may occur in locations only at the top level; below | |
| 1688 that every MEM or REG is substituted by its VALUE. */ | |
| 1689 if (!MEM_P (x)) | |
| 1690 { | |
| 1691 p = &(*p)->next; | |
| 1692 continue; | |
| 1693 } | |
| 1694 if (num_mems < PARAM_VALUE (PARAM_MAX_CSELIB_MEMORY_LOCATIONS) | |
| 1695 && ! canon_true_dependence (mem_rtx, GET_MODE (mem_rtx), mem_addr, | |
|
19
58ad6c70ea60
update gcc from 4.4.0 to 4.4.1.
kent@firefly.cr.ie.u-ryukyu.ac.jp
parents:
0
diff
changeset
|
1696 x, NULL_RTX, cselib_rtx_varies_p)) |
| 0 | 1697 { |
| 1698 has_mem = true; | |
| 1699 num_mems++; | |
| 1700 p = &(*p)->next; | |
| 1701 continue; | |
| 1702 } | |
| 1703 | |
| 1704 /* This one overlaps. */ | |
| 1705 /* We must have a mapping from this MEM's address to the | |
| 1706 value (E). Remove that, too. */ | |
| 1707 addr = cselib_lookup (XEXP (x, 0), VOIDmode, 0); | |
| 1708 mem_chain = &addr->addr_list; | |
| 1709 for (;;) | |
| 1710 { | |
| 1711 if ((*mem_chain)->elt == v) | |
| 1712 { | |
| 1713 unchain_one_elt_list (mem_chain); | |
| 1714 break; | |
| 1715 } | |
| 1716 | |
| 1717 mem_chain = &(*mem_chain)->next; | |
| 1718 } | |
| 1719 | |
| 1720 unchain_one_elt_loc_list (p); | |
| 1721 } | |
| 1722 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1723 if (had_locs && v->locs == 0 && !PRESERVED_VALUE_P (v->val_rtx)) |
| 0 | 1724 n_useless_values++; |
| 1725 | |
| 1726 next = v->next_containing_mem; | |
| 1727 if (has_mem) | |
| 1728 { | |
| 1729 *vp = v; | |
| 1730 vp = &(*vp)->next_containing_mem; | |
| 1731 } | |
| 1732 else | |
| 1733 v->next_containing_mem = NULL; | |
| 1734 } | |
| 1735 *vp = &dummy_val; | |
| 1736 } | |
| 1737 | |
| 1738 /* Invalidate DEST, which is being assigned to or clobbered. */ | |
| 1739 | |
| 1740 void | |
| 1741 cselib_invalidate_rtx (rtx dest) | |
| 1742 { | |
| 1743 while (GET_CODE (dest) == SUBREG | |
| 1744 || GET_CODE (dest) == ZERO_EXTRACT | |
| 1745 || GET_CODE (dest) == STRICT_LOW_PART) | |
| 1746 dest = XEXP (dest, 0); | |
| 1747 | |
| 1748 if (REG_P (dest)) | |
| 1749 cselib_invalidate_regno (REGNO (dest), GET_MODE (dest)); | |
| 1750 else if (MEM_P (dest)) | |
| 1751 cselib_invalidate_mem (dest); | |
| 1752 | |
| 1753 /* Some machines don't define AUTO_INC_DEC, but they still use push | |
| 1754 instructions. We need to catch that case here in order to | |
| 1755 invalidate the stack pointer correctly. Note that invalidating | |
| 1756 the stack pointer is different from invalidating DEST. */ | |
| 1757 if (push_operand (dest, GET_MODE (dest))) | |
| 1758 cselib_invalidate_rtx (stack_pointer_rtx); | |
| 1759 } | |
| 1760 | |
| 1761 /* A wrapper for cselib_invalidate_rtx to be called via note_stores. */ | |
| 1762 | |
| 1763 static void | |
| 1764 cselib_invalidate_rtx_note_stores (rtx dest, const_rtx ignore ATTRIBUTE_UNUSED, | |
| 1765 void *data ATTRIBUTE_UNUSED) | |
| 1766 { | |
| 1767 cselib_invalidate_rtx (dest); | |
| 1768 } | |
| 1769 | |
| 1770 /* Record the result of a SET instruction. DEST is being set; the source | |
| 1771 contains the value described by SRC_ELT. If DEST is a MEM, DEST_ADDR_ELT | |
| 1772 describes its address. */ | |
| 1773 | |
| 1774 static void | |
| 1775 cselib_record_set (rtx dest, cselib_val *src_elt, cselib_val *dest_addr_elt) | |
| 1776 { | |
| 1777 int dreg = REG_P (dest) ? (int) REGNO (dest) : -1; | |
| 1778 | |
| 1779 if (src_elt == 0 || side_effects_p (dest)) | |
| 1780 return; | |
| 1781 | |
| 1782 if (dreg >= 0) | |
| 1783 { | |
| 1784 if (dreg < FIRST_PSEUDO_REGISTER) | |
| 1785 { | |
| 1786 unsigned int n = hard_regno_nregs[dreg][GET_MODE (dest)]; | |
| 1787 | |
| 1788 if (n > max_value_regs) | |
| 1789 max_value_regs = n; | |
| 1790 } | |
| 1791 | |
| 1792 if (REG_VALUES (dreg) == 0) | |
| 1793 { | |
| 1794 used_regs[n_used_regs++] = dreg; | |
| 1795 REG_VALUES (dreg) = new_elt_list (REG_VALUES (dreg), src_elt); | |
| 1796 } | |
| 1797 else | |
| 1798 { | |
| 1799 /* The register should have been invalidated. */ | |
| 1800 gcc_assert (REG_VALUES (dreg)->elt == 0); | |
| 1801 REG_VALUES (dreg)->elt = src_elt; | |
| 1802 } | |
| 1803 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1804 if (src_elt->locs == 0 && !PRESERVED_VALUE_P (src_elt->val_rtx)) |
| 0 | 1805 n_useless_values--; |
| 1806 src_elt->locs = new_elt_loc_list (src_elt->locs, dest); | |
| 1807 } | |
| 1808 else if (MEM_P (dest) && dest_addr_elt != 0 | |
| 1809 && cselib_record_memory) | |
| 1810 { | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1811 if (src_elt->locs == 0 && !PRESERVED_VALUE_P (src_elt->val_rtx)) |
| 0 | 1812 n_useless_values--; |
| 1813 add_mem_for_addr (dest_addr_elt, src_elt, dest); | |
| 1814 } | |
| 1815 } | |
| 1816 | |
| 1817 /* There is no good way to determine how many elements there can be | |
| 1818 in a PARALLEL. Since it's fairly cheap, use a really large number. */ | |
| 1819 #define MAX_SETS (FIRST_PSEUDO_REGISTER * 2) | |
| 1820 | |
| 1821 /* Record the effects of any sets in INSN. */ | |
| 1822 static void | |
| 1823 cselib_record_sets (rtx insn) | |
| 1824 { | |
| 1825 int n_sets = 0; | |
| 1826 int i; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1827 struct cselib_set sets[MAX_SETS]; |
| 0 | 1828 rtx body = PATTERN (insn); |
| 1829 rtx cond = 0; | |
| 1830 | |
| 1831 body = PATTERN (insn); | |
| 1832 if (GET_CODE (body) == COND_EXEC) | |
| 1833 { | |
| 1834 cond = COND_EXEC_TEST (body); | |
| 1835 body = COND_EXEC_CODE (body); | |
| 1836 } | |
| 1837 | |
| 1838 /* Find all sets. */ | |
| 1839 if (GET_CODE (body) == SET) | |
| 1840 { | |
| 1841 sets[0].src = SET_SRC (body); | |
| 1842 sets[0].dest = SET_DEST (body); | |
| 1843 n_sets = 1; | |
| 1844 } | |
| 1845 else if (GET_CODE (body) == PARALLEL) | |
| 1846 { | |
| 1847 /* Look through the PARALLEL and record the values being | |
| 1848 set, if possible. Also handle any CLOBBERs. */ | |
| 1849 for (i = XVECLEN (body, 0) - 1; i >= 0; --i) | |
| 1850 { | |
| 1851 rtx x = XVECEXP (body, 0, i); | |
| 1852 | |
| 1853 if (GET_CODE (x) == SET) | |
| 1854 { | |
| 1855 sets[n_sets].src = SET_SRC (x); | |
| 1856 sets[n_sets].dest = SET_DEST (x); | |
| 1857 n_sets++; | |
| 1858 } | |
| 1859 } | |
| 1860 } | |
| 1861 | |
| 1862 if (n_sets == 1 | |
| 1863 && MEM_P (sets[0].src) | |
| 1864 && !cselib_record_memory | |
| 1865 && MEM_READONLY_P (sets[0].src)) | |
| 1866 { | |
| 1867 rtx note = find_reg_equal_equiv_note (insn); | |
| 1868 | |
| 1869 if (note && CONSTANT_P (XEXP (note, 0))) | |
| 1870 sets[0].src = XEXP (note, 0); | |
| 1871 } | |
| 1872 | |
| 1873 /* Look up the values that are read. Do this before invalidating the | |
| 1874 locations that are written. */ | |
| 1875 for (i = 0; i < n_sets; i++) | |
| 1876 { | |
| 1877 rtx dest = sets[i].dest; | |
| 1878 | |
| 1879 /* A STRICT_LOW_PART can be ignored; we'll record the equivalence for | |
| 1880 the low part after invalidating any knowledge about larger modes. */ | |
| 1881 if (GET_CODE (sets[i].dest) == STRICT_LOW_PART) | |
| 1882 sets[i].dest = dest = XEXP (dest, 0); | |
| 1883 | |
| 1884 /* We don't know how to record anything but REG or MEM. */ | |
| 1885 if (REG_P (dest) | |
| 1886 || (MEM_P (dest) && cselib_record_memory)) | |
| 1887 { | |
| 1888 rtx src = sets[i].src; | |
| 1889 if (cond) | |
| 1890 src = gen_rtx_IF_THEN_ELSE (GET_MODE (dest), cond, src, dest); | |
| 1891 sets[i].src_elt = cselib_lookup (src, GET_MODE (dest), 1); | |
| 1892 if (MEM_P (dest)) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1893 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1894 enum machine_mode address_mode |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1895 = targetm.addr_space.address_mode (MEM_ADDR_SPACE (dest)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1896 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1897 sets[i].dest_addr_elt = cselib_lookup (XEXP (dest, 0), |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1898 address_mode, 1); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1899 } |
| 0 | 1900 else |
| 1901 sets[i].dest_addr_elt = 0; | |
| 1902 } | |
| 1903 } | |
| 1904 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1905 if (cselib_record_sets_hook) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1906 cselib_record_sets_hook (insn, sets, n_sets); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1907 |
| 0 | 1908 /* Invalidate all locations written by this insn. Note that the elts we |
| 1909 looked up in the previous loop aren't affected, just some of their | |
| 1910 locations may go away. */ | |
| 1911 note_stores (body, cselib_invalidate_rtx_note_stores, NULL); | |
| 1912 | |
| 1913 /* If this is an asm, look for duplicate sets. This can happen when the | |
| 1914 user uses the same value as an output multiple times. This is valid | |
| 1915 if the outputs are not actually used thereafter. Treat this case as | |
| 1916 if the value isn't actually set. We do this by smashing the destination | |
| 1917 to pc_rtx, so that we won't record the value later. */ | |
| 1918 if (n_sets >= 2 && asm_noperands (body) >= 0) | |
| 1919 { | |
| 1920 for (i = 0; i < n_sets; i++) | |
| 1921 { | |
| 1922 rtx dest = sets[i].dest; | |
| 1923 if (REG_P (dest) || MEM_P (dest)) | |
| 1924 { | |
| 1925 int j; | |
| 1926 for (j = i + 1; j < n_sets; j++) | |
| 1927 if (rtx_equal_p (dest, sets[j].dest)) | |
| 1928 { | |
| 1929 sets[i].dest = pc_rtx; | |
| 1930 sets[j].dest = pc_rtx; | |
| 1931 } | |
| 1932 } | |
| 1933 } | |
| 1934 } | |
| 1935 | |
| 1936 /* Now enter the equivalences in our tables. */ | |
| 1937 for (i = 0; i < n_sets; i++) | |
| 1938 { | |
| 1939 rtx dest = sets[i].dest; | |
| 1940 if (REG_P (dest) | |
| 1941 || (MEM_P (dest) && cselib_record_memory)) | |
| 1942 cselib_record_set (dest, sets[i].src_elt, sets[i].dest_addr_elt); | |
| 1943 } | |
| 1944 } | |
| 1945 | |
| 1946 /* Record the effects of INSN. */ | |
| 1947 | |
| 1948 void | |
| 1949 cselib_process_insn (rtx insn) | |
| 1950 { | |
| 1951 int i; | |
| 1952 rtx x; | |
| 1953 | |
| 1954 cselib_current_insn = insn; | |
| 1955 | |
| 1956 /* Forget everything at a CODE_LABEL, a volatile asm, or a setjmp. */ | |
| 1957 if (LABEL_P (insn) | |
| 1958 || (CALL_P (insn) | |
| 1959 && find_reg_note (insn, REG_SETJMP, NULL)) | |
| 1960 || (NONJUMP_INSN_P (insn) | |
| 1961 && GET_CODE (PATTERN (insn)) == ASM_OPERANDS | |
| 1962 && MEM_VOLATILE_P (PATTERN (insn)))) | |
| 1963 { | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1964 cselib_reset_table_with_next_value (next_unknown_value); |
| 0 | 1965 return; |
| 1966 } | |
| 1967 | |
| 1968 if (! INSN_P (insn)) | |
| 1969 { | |
| 1970 cselib_current_insn = 0; | |
| 1971 return; | |
| 1972 } | |
| 1973 | |
| 1974 /* If this is a call instruction, forget anything stored in a | |
| 1975 call clobbered register, or, if this is not a const call, in | |
| 1976 memory. */ | |
| 1977 if (CALL_P (insn)) | |
| 1978 { | |
| 1979 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) | |
| 1980 if (call_used_regs[i] | |
| 1981 || (REG_VALUES (i) && REG_VALUES (i)->elt | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
1982 && HARD_REGNO_CALL_PART_CLOBBERED (i, |
| 0 | 1983 GET_MODE (REG_VALUES (i)->elt->val_rtx)))) |
| 1984 cselib_invalidate_regno (i, reg_raw_mode[i]); | |
| 1985 | |
| 1986 /* Since it is not clear how cselib is going to be used, be | |
| 1987 conservative here and treat looping pure or const functions | |
| 1988 as if they were regular functions. */ | |
| 1989 if (RTL_LOOPING_CONST_OR_PURE_CALL_P (insn) | |
| 1990 || !(RTL_CONST_OR_PURE_CALL_P (insn))) | |
| 1991 cselib_invalidate_mem (callmem); | |
| 1992 } | |
| 1993 | |
| 1994 cselib_record_sets (insn); | |
| 1995 | |
| 1996 #ifdef AUTO_INC_DEC | |
| 1997 /* Clobber any registers which appear in REG_INC notes. We | |
| 1998 could keep track of the changes to their values, but it is | |
| 1999 unlikely to help. */ | |
| 2000 for (x = REG_NOTES (insn); x; x = XEXP (x, 1)) | |
| 2001 if (REG_NOTE_KIND (x) == REG_INC) | |
| 2002 cselib_invalidate_rtx (XEXP (x, 0)); | |
| 2003 #endif | |
| 2004 | |
| 2005 /* Look for any CLOBBERs in CALL_INSN_FUNCTION_USAGE, but only | |
| 2006 after we have processed the insn. */ | |
| 2007 if (CALL_P (insn)) | |
| 2008 for (x = CALL_INSN_FUNCTION_USAGE (insn); x; x = XEXP (x, 1)) | |
| 2009 if (GET_CODE (XEXP (x, 0)) == CLOBBER) | |
| 2010 cselib_invalidate_rtx (XEXP (XEXP (x, 0), 0)); | |
| 2011 | |
| 2012 cselib_current_insn = 0; | |
| 2013 | |
| 2014 if (n_useless_values > MAX_USELESS_VALUES | |
| 2015 /* remove_useless_values is linear in the hash table size. Avoid | |
| 2016 quadratic behavior for very large hashtables with very few | |
| 2017 useless elements. */ | |
| 2018 && (unsigned int)n_useless_values > cselib_hash_table->n_elements / 4) | |
| 2019 remove_useless_values (); | |
| 2020 } | |
| 2021 | |
| 2022 /* Initialize cselib for one pass. The caller must also call | |
| 2023 init_alias_analysis. */ | |
| 2024 | |
| 2025 void | |
| 2026 cselib_init (bool record_memory) | |
| 2027 { | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2028 elt_list_pool = create_alloc_pool ("elt_list", |
| 0 | 2029 sizeof (struct elt_list), 10); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2030 elt_loc_list_pool = create_alloc_pool ("elt_loc_list", |
| 0 | 2031 sizeof (struct elt_loc_list), 10); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2032 cselib_val_pool = create_alloc_pool ("cselib_val_list", |
| 0 | 2033 sizeof (cselib_val), 10); |
| 2034 value_pool = create_alloc_pool ("value", RTX_CODE_SIZE (VALUE), 100); | |
| 2035 cselib_record_memory = record_memory; | |
| 2036 | |
| 2037 /* (mem:BLK (scratch)) is a special mechanism to conflict with everything, | |
| 2038 see canon_true_dependence. This is only created once. */ | |
| 2039 if (! callmem) | |
| 2040 callmem = gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode)); | |
| 2041 | |
| 2042 cselib_nregs = max_reg_num (); | |
| 2043 | |
| 2044 /* We preserve reg_values to allow expensive clearing of the whole thing. | |
| 2045 Reallocate it however if it happens to be too large. */ | |
| 2046 if (!reg_values || reg_values_size < cselib_nregs | |
| 2047 || (reg_values_size > 10 && reg_values_size > cselib_nregs * 4)) | |
| 2048 { | |
| 2049 if (reg_values) | |
| 2050 free (reg_values); | |
| 2051 /* Some space for newly emit instructions so we don't end up | |
| 2052 reallocating in between passes. */ | |
| 2053 reg_values_size = cselib_nregs + (63 + cselib_nregs) / 16; | |
| 2054 reg_values = XCNEWVEC (struct elt_list *, reg_values_size); | |
| 2055 } | |
| 2056 used_regs = XNEWVEC (unsigned int, cselib_nregs); | |
| 2057 n_used_regs = 0; | |
| 2058 cselib_hash_table = htab_create (31, get_value_hash, | |
| 2059 entry_and_rtx_equal_p, NULL); | |
| 2060 } | |
| 2061 | |
| 2062 /* Called when the current user is done with cselib. */ | |
| 2063 | |
| 2064 void | |
| 2065 cselib_finish (void) | |
| 2066 { | |
| 2067 cselib_discard_hook = NULL; | |
| 2068 free_alloc_pool (elt_list_pool); | |
| 2069 free_alloc_pool (elt_loc_list_pool); | |
| 2070 free_alloc_pool (cselib_val_pool); | |
| 2071 free_alloc_pool (value_pool); | |
| 2072 cselib_clear_table (); | |
| 2073 htab_delete (cselib_hash_table); | |
| 2074 free (used_regs); | |
| 2075 used_regs = 0; | |
| 2076 cselib_hash_table = 0; | |
| 2077 n_useless_values = 0; | |
| 2078 next_unknown_value = 0; | |
| 2079 } | |
| 2080 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2081 /* Dump the cselib_val *X to FILE *info. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2082 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2083 static int |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2084 dump_cselib_val (void **x, void *info) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2085 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2086 cselib_val *v = (cselib_val *)*x; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2087 FILE *out = (FILE *)info; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2088 bool need_lf = true; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2089 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2090 print_inline_rtx (out, v->val_rtx, 0); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2091 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2092 if (v->locs) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2093 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2094 struct elt_loc_list *l = v->locs; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2095 if (need_lf) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2096 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2097 fputc ('\n', out); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2098 need_lf = false; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2099 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2100 fputs (" locs:", out); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2101 do |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2102 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2103 fprintf (out, "\n from insn %i ", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2104 INSN_UID (l->setting_insn)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2105 print_inline_rtx (out, l->loc, 4); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2106 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2107 while ((l = l->next)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2108 fputc ('\n', out); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2109 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2110 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2111 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2112 fputs (" no locs", out); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2113 need_lf = true; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2114 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2115 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2116 if (v->addr_list) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2117 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2118 struct elt_list *e = v->addr_list; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2119 if (need_lf) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2120 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2121 fputc ('\n', out); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2122 need_lf = false; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2123 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2124 fputs (" addr list:", out); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2125 do |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2126 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2127 fputs ("\n ", out); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2128 print_inline_rtx (out, e->elt->val_rtx, 2); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2129 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2130 while ((e = e->next)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2131 fputc ('\n', out); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2132 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2133 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2134 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2135 fputs (" no addrs", out); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2136 need_lf = true; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2137 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2138 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2139 if (v->next_containing_mem == &dummy_val) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2140 fputs (" last mem\n", out); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2141 else if (v->next_containing_mem) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2142 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2143 fputs (" next mem ", out); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2144 print_inline_rtx (out, v->next_containing_mem->val_rtx, 2); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2145 fputc ('\n', out); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2146 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2147 else if (need_lf) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2148 fputc ('\n', out); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2149 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2150 return 1; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2151 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2152 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2153 /* Dump to OUT everything in the CSELIB table. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2154 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2155 void |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2156 dump_cselib_table (FILE *out) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2157 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2158 fprintf (out, "cselib hash table:\n"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2159 htab_traverse (cselib_hash_table, dump_cselib_val, out); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2160 if (first_containing_mem != &dummy_val) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2161 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2162 fputs ("first mem ", out); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2163 print_inline_rtx (out, first_containing_mem->val_rtx, 2); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2164 fputc ('\n', out); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2165 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2166 fprintf (out, "last unknown value %i\n", next_unknown_value); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2167 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
2168 |
| 0 | 2169 #include "gt-cselib.h" |