Mercurial > hg > CbC > CbC_gcc
annotate gcc/tree-ssanames.c @ 131:84e7813d76e9
gcc-8.2
| author | mir3636 |
|---|---|
| date | Thu, 25 Oct 2018 07:37:49 +0900 |
| parents | 04ced10e8804 |
| children | 1830386684a0 |
| rev | line source |
|---|---|
| 0 | 1 /* Generic routines for manipulating SSA_NAME expressions |
| 131 | 2 Copyright (C) 2003-2018 Free Software Foundation, Inc. |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
3 |
| 0 | 4 This file is part of GCC. |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
5 |
| 0 | 6 GCC is free software; you can redistribute it and/or modify |
| 7 it under the terms of the GNU General Public License as published by | |
| 8 the Free Software Foundation; either version 3, or (at your option) | |
| 9 any later version. | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
10 |
| 0 | 11 GCC is distributed in the hope that it will be useful, |
| 12 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| 14 GNU General Public License for more details. | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
15 |
| 0 | 16 You should have received a copy of the GNU General Public License |
| 17 along with GCC; see the file COPYING3. If not see | |
| 18 <http://www.gnu.org/licenses/>. */ | |
| 19 | |
| 20 #include "config.h" | |
| 21 #include "system.h" | |
| 22 #include "coretypes.h" | |
| 111 | 23 #include "backend.h" |
| 0 | 24 #include "tree.h" |
| 111 | 25 #include "gimple.h" |
| 0 | 26 #include "tree-pass.h" |
| 111 | 27 #include "ssa.h" |
| 28 #include "gimple-iterator.h" | |
| 29 #include "stor-layout.h" | |
| 30 #include "tree-into-ssa.h" | |
| 31 #include "tree-ssa.h" | |
| 131 | 32 #include "cfgloop.h" |
| 33 #include "tree-scalar-evolution.h" | |
| 0 | 34 |
| 35 /* Rewriting a function into SSA form can create a huge number of SSA_NAMEs, | |
| 36 many of which may be thrown away shortly after their creation if jumps | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
37 were threaded through PHI nodes. |
| 0 | 38 |
| 39 While our garbage collection mechanisms will handle this situation, it | |
| 40 is extremely wasteful to create nodes and throw them away, especially | |
| 41 when the nodes can be reused. | |
| 42 | |
| 43 For PR 8361, we can significantly reduce the number of nodes allocated | |
| 44 and thus the total amount of memory allocated by managing SSA_NAMEs a | |
| 45 little. This additionally helps reduce the amount of work done by the | |
| 46 garbage collector. Similar results have been seen on a wider variety | |
| 47 of tests (such as the compiler itself). | |
| 48 | |
| 49 Right now we maintain our free list on a per-function basis. It may | |
| 50 or may not make sense to maintain the free list for the duration of | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
51 a compilation unit. |
| 0 | 52 |
| 53 External code should rely solely upon HIGHEST_SSA_VERSION and the | |
| 54 externally defined functions. External code should not know about | |
| 55 the details of the free list management. | |
| 56 | |
| 57 External code should also not assume the version number on nodes is | |
| 58 monotonically increasing. We reuse the version number when we | |
| 59 reuse an SSA_NAME expression. This helps keep arrays and bitmaps | |
| 111 | 60 more compact. */ |
| 0 | 61 |
| 62 | |
| 63 /* Version numbers with special meanings. We start allocating new version | |
| 64 numbers after the special ones. */ | |
| 65 #define UNUSED_NAME_VERSION 0 | |
| 66 | |
| 67 unsigned int ssa_name_nodes_reused; | |
| 68 unsigned int ssa_name_nodes_created; | |
| 111 | 69 |
| 70 #define FREE_SSANAMES(fun) (fun)->gimple_df->free_ssanames | |
| 71 #define FREE_SSANAMES_QUEUE(fun) (fun)->gimple_df->free_ssanames_queue | |
| 72 | |
| 0 | 73 |
| 74 /* Initialize management of SSA_NAMEs to default SIZE. If SIZE is | |
| 75 zero use default. */ | |
| 76 | |
| 77 void | |
| 78 init_ssanames (struct function *fn, int size) | |
| 79 { | |
| 80 if (size < 50) | |
| 81 size = 50; | |
| 82 | |
| 111 | 83 vec_alloc (SSANAMES (fn), size); |
| 0 | 84 |
| 85 /* Version 0 is special, so reserve the first slot in the table. Though | |
| 86 currently unused, we may use version 0 in alias analysis as part of | |
| 87 the heuristics used to group aliases when the alias sets are too | |
| 88 large. | |
| 89 | |
| 111 | 90 We use vec::quick_push here because we know that SSA_NAMES has at |
| 0 | 91 least 50 elements reserved in it. */ |
| 111 | 92 SSANAMES (fn)->quick_push (NULL_TREE); |
| 0 | 93 FREE_SSANAMES (fn) = NULL; |
| 111 | 94 FREE_SSANAMES_QUEUE (fn) = NULL; |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
95 |
| 111 | 96 fn->gimple_df->ssa_renaming_needed = 0; |
| 97 fn->gimple_df->rename_vops = 0; | |
| 0 | 98 } |
| 99 | |
| 100 /* Finalize management of SSA_NAMEs. */ | |
| 101 | |
| 102 void | |
| 111 | 103 fini_ssanames (struct function *fn) |
| 0 | 104 { |
| 111 | 105 vec_free (SSANAMES (fn)); |
| 106 vec_free (FREE_SSANAMES (fn)); | |
| 107 vec_free (FREE_SSANAMES_QUEUE (fn)); | |
| 0 | 108 } |
| 109 | |
| 110 /* Dump some simple statistics regarding the re-use of SSA_NAME nodes. */ | |
| 111 | |
| 112 void | |
| 113 ssanames_print_statistics (void) | |
| 114 { | |
| 115 fprintf (stderr, "SSA_NAME nodes allocated: %u\n", ssa_name_nodes_created); | |
| 116 fprintf (stderr, "SSA_NAME nodes reused: %u\n", ssa_name_nodes_reused); | |
| 117 } | |
| 111 | 118 |
| 119 /* Verify the state of the SSA_NAME lists. | |
| 120 | |
| 121 There must be no duplicates on the free list. | |
| 122 Every name on the free list must be marked as on the free list. | |
| 123 Any name on the free list must not appear in the IL. | |
| 124 No names can be leaked. */ | |
| 125 | |
| 126 DEBUG_FUNCTION void | |
| 127 verify_ssaname_freelists (struct function *fun) | |
| 128 { | |
| 129 if (!gimple_in_ssa_p (fun)) | |
| 130 return; | |
| 131 | |
| 132 auto_bitmap names_in_il; | |
| 133 | |
| 134 /* Walk the entire IL noting every SSA_NAME we see. */ | |
| 135 basic_block bb; | |
| 136 FOR_EACH_BB_FN (bb, fun) | |
| 137 { | |
| 138 tree t; | |
| 139 /* First note the result and arguments of PHI nodes. */ | |
| 140 for (gphi_iterator gsi = gsi_start_phis (bb); | |
| 141 !gsi_end_p (gsi); | |
| 142 gsi_next (&gsi)) | |
| 143 { | |
| 144 gphi *phi = gsi.phi (); | |
| 145 t = gimple_phi_result (phi); | |
| 146 bitmap_set_bit (names_in_il, SSA_NAME_VERSION (t)); | |
| 147 | |
| 148 for (unsigned int i = 0; i < gimple_phi_num_args (phi); i++) | |
| 149 { | |
| 150 t = gimple_phi_arg_def (phi, i); | |
| 151 if (TREE_CODE (t) == SSA_NAME) | |
| 152 bitmap_set_bit (names_in_il, SSA_NAME_VERSION (t)); | |
| 153 } | |
| 154 } | |
| 155 | |
| 156 /* Then note the operands of each statement. */ | |
| 157 for (gimple_stmt_iterator gsi = gsi_start_bb (bb); | |
| 158 !gsi_end_p (gsi); | |
| 159 gsi_next (&gsi)) | |
| 160 { | |
| 161 ssa_op_iter iter; | |
| 162 gimple *stmt = gsi_stmt (gsi); | |
| 163 FOR_EACH_SSA_TREE_OPERAND (t, stmt, iter, SSA_OP_ALL_OPERANDS) | |
| 164 bitmap_set_bit (names_in_il, SSA_NAME_VERSION (t)); | |
| 165 } | |
| 166 } | |
| 167 | |
| 168 /* Now walk the free list noting what we find there and verifying | |
| 169 there are no duplicates. */ | |
| 170 auto_bitmap names_in_freelists; | |
| 171 if (FREE_SSANAMES (fun)) | |
| 172 { | |
| 173 for (unsigned int i = 0; i < FREE_SSANAMES (fun)->length (); i++) | |
| 174 { | |
| 175 tree t = (*FREE_SSANAMES (fun))[i]; | |
| 176 | |
| 177 /* Verify that the name is marked as being in the free list. */ | |
| 178 gcc_assert (SSA_NAME_IN_FREE_LIST (t)); | |
| 179 | |
| 180 /* Verify the name has not already appeared in the free list and | |
| 181 note it in the list of names found in the free list. */ | |
| 182 gcc_assert (!bitmap_bit_p (names_in_freelists, SSA_NAME_VERSION (t))); | |
| 183 bitmap_set_bit (names_in_freelists, SSA_NAME_VERSION (t)); | |
| 184 } | |
| 185 } | |
| 186 | |
| 187 /* Similarly for the names in the pending free list. */ | |
| 188 if (FREE_SSANAMES_QUEUE (fun)) | |
| 189 { | |
| 190 for (unsigned int i = 0; i < FREE_SSANAMES_QUEUE (fun)->length (); i++) | |
| 191 { | |
| 192 tree t = (*FREE_SSANAMES_QUEUE (fun))[i]; | |
| 193 | |
| 194 /* Verify that the name is marked as being in the free list. */ | |
| 195 gcc_assert (SSA_NAME_IN_FREE_LIST (t)); | |
| 196 | |
| 197 /* Verify the name has not already appeared in the free list and | |
| 198 note it in the list of names found in the free list. */ | |
| 199 gcc_assert (!bitmap_bit_p (names_in_freelists, SSA_NAME_VERSION (t))); | |
| 200 bitmap_set_bit (names_in_freelists, SSA_NAME_VERSION (t)); | |
| 201 } | |
| 202 } | |
| 203 | |
| 204 /* If any name appears in both the IL and the freelists, then | |
| 205 something horrible has happened. */ | |
| 206 bool intersect_p = bitmap_intersect_p (names_in_il, names_in_freelists); | |
| 207 gcc_assert (!intersect_p); | |
| 208 | |
| 209 /* Names can be queued up for release if there is an ssa update | |
| 210 pending. Pretend we saw them in the IL. */ | |
| 211 if (names_to_release) | |
| 212 bitmap_ior_into (names_in_il, names_to_release); | |
| 213 | |
| 214 /* Function splitting can "lose" SSA_NAMEs in an effort to ensure that | |
| 215 debug/non-debug compilations have the same SSA_NAMEs. So for each | |
| 216 lost SSA_NAME, see if it's likely one from that wart. These will always | |
| 217 be marked as default definitions. So we loosely assume that anything | |
| 218 marked as a default definition isn't leaked by pretending they are | |
| 219 in the IL. */ | |
| 220 for (unsigned int i = UNUSED_NAME_VERSION + 1; i < num_ssa_names; i++) | |
| 221 if (ssa_name (i) && SSA_NAME_IS_DEFAULT_DEF (ssa_name (i))) | |
| 222 bitmap_set_bit (names_in_il, i); | |
| 223 | |
| 224 unsigned int i; | |
| 225 bitmap_iterator bi; | |
| 226 auto_bitmap all_names; | |
| 227 bitmap_set_range (all_names, UNUSED_NAME_VERSION + 1, num_ssa_names - 1); | |
| 228 bitmap_ior_into (names_in_il, names_in_freelists); | |
| 229 | |
| 230 /* Any name not mentioned in the IL and not in the feelists | |
| 231 has been leaked. */ | |
| 232 EXECUTE_IF_AND_COMPL_IN_BITMAP(all_names, names_in_il, | |
| 233 UNUSED_NAME_VERSION + 1, i, bi) | |
| 234 gcc_assert (!ssa_name (i)); | |
| 235 } | |
| 236 | |
| 237 /* Move all SSA_NAMEs from FREE_SSA_NAMES_QUEUE to FREE_SSA_NAMES. | |
| 238 | |
| 239 We do not, but should have a mode to verify the state of the SSA_NAMEs | |
| 240 lists. In particular at this point every name must be in the IL, | |
| 241 on the free list or in the queue. Anything else is an error. */ | |
| 242 | |
| 243 void | |
| 244 flush_ssaname_freelist (void) | |
| 245 { | |
| 131 | 246 /* If there were any SSA names released reset the SCEV cache. */ |
| 247 if (! vec_safe_is_empty (FREE_SSANAMES_QUEUE (cfun))) | |
| 248 scev_reset_htab (); | |
| 111 | 249 vec_safe_splice (FREE_SSANAMES (cfun), FREE_SSANAMES_QUEUE (cfun)); |
| 250 vec_safe_truncate (FREE_SSANAMES_QUEUE (cfun), 0); | |
| 251 } | |
| 0 | 252 |
| 253 /* Return an SSA_NAME node for variable VAR defined in statement STMT | |
| 254 in function FN. STMT may be an empty statement for artificial | |
| 255 references (e.g., default definitions created when a variable is | |
| 111 | 256 used without a preceding definition). If VERISON is not zero then |
| 257 allocate the SSA name with that version. */ | |
| 0 | 258 |
| 259 tree | |
| 111 | 260 make_ssa_name_fn (struct function *fn, tree var, gimple *stmt, |
| 261 unsigned int version) | |
| 0 | 262 { |
| 263 tree t; | |
| 264 use_operand_p imm; | |
| 265 | |
| 111 | 266 gcc_assert (VAR_P (var) |
| 267 || TREE_CODE (var) == PARM_DECL | |
| 268 || TREE_CODE (var) == RESULT_DECL | |
| 269 || (TYPE_P (var) && is_gimple_reg_type (var))); | |
| 0 | 270 |
| 111 | 271 /* Get the specified SSA name version. */ |
| 272 if (version != 0) | |
| 0 | 273 { |
| 111 | 274 t = make_node (SSA_NAME); |
| 275 SSA_NAME_VERSION (t) = version; | |
| 276 if (version >= SSANAMES (fn)->length ()) | |
| 277 vec_safe_grow_cleared (SSANAMES (fn), version + 1); | |
| 278 gcc_assert ((*SSANAMES (fn))[version] == NULL); | |
| 279 (*SSANAMES (fn))[version] = t; | |
| 280 ssa_name_nodes_created++; | |
| 281 } | |
| 282 /* If our free list has an element, then use it. */ | |
| 283 else if (!vec_safe_is_empty (FREE_SSANAMES (fn))) | |
| 284 { | |
| 285 t = FREE_SSANAMES (fn)->pop (); | |
| 0 | 286 ssa_name_nodes_reused++; |
| 287 | |
| 288 /* The node was cleared out when we put it on the free list, so | |
| 289 there is no need to do so again here. */ | |
| 111 | 290 gcc_assert ((*SSANAMES (fn))[SSA_NAME_VERSION (t)] == NULL); |
| 291 (*SSANAMES (fn))[SSA_NAME_VERSION (t)] = t; | |
| 0 | 292 } |
| 293 else | |
| 294 { | |
| 295 t = make_node (SSA_NAME); | |
| 111 | 296 SSA_NAME_VERSION (t) = SSANAMES (fn)->length (); |
| 297 vec_safe_push (SSANAMES (fn), t); | |
| 0 | 298 ssa_name_nodes_created++; |
| 299 } | |
| 300 | |
| 111 | 301 if (TYPE_P (var)) |
| 302 { | |
| 303 TREE_TYPE (t) = TYPE_MAIN_VARIANT (var); | |
| 304 SET_SSA_NAME_VAR_OR_IDENTIFIER (t, NULL_TREE); | |
| 305 } | |
| 306 else | |
| 307 { | |
| 308 TREE_TYPE (t) = TREE_TYPE (var); | |
| 309 SET_SSA_NAME_VAR_OR_IDENTIFIER (t, var); | |
| 310 } | |
| 0 | 311 SSA_NAME_DEF_STMT (t) = stmt; |
| 111 | 312 if (POINTER_TYPE_P (TREE_TYPE (t))) |
| 313 SSA_NAME_PTR_INFO (t) = NULL; | |
| 314 else | |
| 315 SSA_NAME_RANGE_INFO (t) = NULL; | |
| 316 | |
| 0 | 317 SSA_NAME_IN_FREE_LIST (t) = 0; |
| 318 SSA_NAME_IS_DEFAULT_DEF (t) = 0; | |
| 319 imm = &(SSA_NAME_IMM_USE_NODE (t)); | |
| 320 imm->use = NULL; | |
| 321 imm->prev = imm; | |
| 322 imm->next = imm; | |
| 323 imm->loc.ssa_name = t; | |
| 324 | |
| 325 return t; | |
| 326 } | |
| 327 | |
| 111 | 328 /* Helper function for set_range_info. |
| 329 | |
| 330 Store range information RANGE_TYPE, MIN, and MAX to tree ssa_name | |
| 331 NAME. */ | |
| 332 | |
| 333 void | |
| 131 | 334 set_range_info_raw (tree name, enum value_range_kind range_type, |
| 111 | 335 const wide_int_ref &min, const wide_int_ref &max) |
| 336 { | |
| 337 gcc_assert (!POINTER_TYPE_P (TREE_TYPE (name))); | |
| 338 gcc_assert (range_type == VR_RANGE || range_type == VR_ANTI_RANGE); | |
| 339 range_info_def *ri = SSA_NAME_RANGE_INFO (name); | |
| 340 unsigned int precision = TYPE_PRECISION (TREE_TYPE (name)); | |
| 341 | |
| 342 /* Allocate if not available. */ | |
| 343 if (ri == NULL) | |
| 344 { | |
| 345 size_t size = (sizeof (range_info_def) | |
| 346 + trailing_wide_ints <3>::extra_size (precision)); | |
| 347 ri = static_cast<range_info_def *> (ggc_internal_alloc (size)); | |
| 348 ri->ints.set_precision (precision); | |
| 349 SSA_NAME_RANGE_INFO (name) = ri; | |
| 350 ri->set_nonzero_bits (wi::shwi (-1, precision)); | |
| 351 } | |
| 352 | |
| 353 /* Record the range type. */ | |
| 354 if (SSA_NAME_RANGE_TYPE (name) != range_type) | |
| 355 SSA_NAME_ANTI_RANGE_P (name) = (range_type == VR_ANTI_RANGE); | |
| 356 | |
| 357 /* Set the values. */ | |
| 358 ri->set_min (min); | |
| 359 ri->set_max (max); | |
| 360 | |
| 361 /* If it is a range, try to improve nonzero_bits from the min/max. */ | |
| 362 if (range_type == VR_RANGE) | |
| 363 { | |
| 364 wide_int xorv = ri->get_min () ^ ri->get_max (); | |
| 365 if (xorv != 0) | |
| 366 xorv = wi::mask (precision - wi::clz (xorv), false, precision); | |
| 367 ri->set_nonzero_bits (ri->get_nonzero_bits () & (ri->get_min () | xorv)); | |
| 368 } | |
| 369 } | |
| 370 | |
| 371 /* Store range information RANGE_TYPE, MIN, and MAX to tree ssa_name | |
| 372 NAME while making sure we don't store useless range info. */ | |
| 373 | |
| 374 void | |
| 131 | 375 set_range_info (tree name, enum value_range_kind range_type, |
| 111 | 376 const wide_int_ref &min, const wide_int_ref &max) |
| 377 { | |
| 378 gcc_assert (!POINTER_TYPE_P (TREE_TYPE (name))); | |
| 379 | |
| 380 /* A range of the entire domain is really no range at all. */ | |
| 381 tree type = TREE_TYPE (name); | |
| 382 if (min == wi::min_value (TYPE_PRECISION (type), TYPE_SIGN (type)) | |
| 383 && max == wi::max_value (TYPE_PRECISION (type), TYPE_SIGN (type))) | |
| 384 { | |
| 385 range_info_def *ri = SSA_NAME_RANGE_INFO (name); | |
| 386 if (ri == NULL) | |
| 387 return; | |
| 388 if (ri->get_nonzero_bits () == -1) | |
| 389 { | |
| 390 ggc_free (ri); | |
| 391 SSA_NAME_RANGE_INFO (name) = NULL; | |
| 392 return; | |
| 393 } | |
| 394 } | |
| 395 | |
| 396 set_range_info_raw (name, range_type, min, max); | |
| 397 } | |
| 398 | |
| 399 | |
| 131 | 400 /* Gets range information MIN, MAX and returns enum value_range_kind |
| 401 corresponding to tree ssa_name NAME. enum value_range_kind returned | |
| 111 | 402 is used to determine if MIN and MAX are valid values. */ |
| 403 | |
| 131 | 404 enum value_range_kind |
| 111 | 405 get_range_info (const_tree name, wide_int *min, wide_int *max) |
| 406 { | |
| 407 gcc_assert (!POINTER_TYPE_P (TREE_TYPE (name))); | |
| 408 gcc_assert (min && max); | |
| 409 range_info_def *ri = SSA_NAME_RANGE_INFO (name); | |
| 410 | |
| 411 /* Return VR_VARYING for SSA_NAMEs with NULL RANGE_INFO or SSA_NAMEs | |
| 412 with integral types width > 2 * HOST_BITS_PER_WIDE_INT precision. */ | |
| 413 if (!ri || (GET_MODE_PRECISION (SCALAR_INT_TYPE_MODE (TREE_TYPE (name))) | |
| 414 > 2 * HOST_BITS_PER_WIDE_INT)) | |
| 415 return VR_VARYING; | |
| 416 | |
| 417 *min = ri->get_min (); | |
| 418 *max = ri->get_max (); | |
| 419 return SSA_NAME_RANGE_TYPE (name); | |
| 420 } | |
| 421 | |
| 422 /* Set nonnull attribute to pointer NAME. */ | |
| 423 | |
| 424 void | |
| 425 set_ptr_nonnull (tree name) | |
| 426 { | |
| 427 gcc_assert (POINTER_TYPE_P (TREE_TYPE (name))); | |
| 428 struct ptr_info_def *pi = get_ptr_info (name); | |
| 429 pi->pt.null = 0; | |
| 430 } | |
| 431 | |
| 432 /* Return nonnull attribute of pointer NAME. */ | |
| 433 bool | |
| 434 get_ptr_nonnull (const_tree name) | |
| 435 { | |
| 436 gcc_assert (POINTER_TYPE_P (TREE_TYPE (name))); | |
| 437 struct ptr_info_def *pi = SSA_NAME_PTR_INFO (name); | |
| 438 if (pi == NULL) | |
| 439 return false; | |
| 440 /* TODO Now pt->null is conservatively set to true in PTA | |
| 441 analysis. vrp is the only pass (including ipa-vrp) | |
| 442 that clears pt.null via set_ptr_nonull when it knows | |
| 443 for sure. PTA will preserves the pt.null value set by VRP. | |
| 444 | |
| 445 When PTA analysis is improved, pt.anything, pt.nonlocal | |
| 446 and pt.escaped may also has to be considered before | |
| 447 deciding that pointer cannot point to NULL. */ | |
| 448 return !pi->pt.null; | |
| 449 } | |
| 450 | |
| 451 /* Change non-zero bits bitmask of NAME. */ | |
| 452 | |
| 453 void | |
| 454 set_nonzero_bits (tree name, const wide_int_ref &mask) | |
| 455 { | |
| 456 gcc_assert (!POINTER_TYPE_P (TREE_TYPE (name))); | |
| 457 if (SSA_NAME_RANGE_INFO (name) == NULL) | |
| 458 { | |
| 459 if (mask == -1) | |
| 460 return; | |
| 461 set_range_info_raw (name, VR_RANGE, | |
| 462 wi::to_wide (TYPE_MIN_VALUE (TREE_TYPE (name))), | |
| 463 wi::to_wide (TYPE_MAX_VALUE (TREE_TYPE (name)))); | |
| 464 } | |
| 465 range_info_def *ri = SSA_NAME_RANGE_INFO (name); | |
| 466 ri->set_nonzero_bits (mask); | |
| 467 } | |
| 468 | |
| 469 /* Return a widest_int with potentially non-zero bits in SSA_NAME | |
| 470 NAME, the constant for INTEGER_CST, or -1 if unknown. */ | |
| 471 | |
| 472 wide_int | |
| 473 get_nonzero_bits (const_tree name) | |
| 474 { | |
| 475 if (TREE_CODE (name) == INTEGER_CST) | |
| 476 return wi::to_wide (name); | |
| 477 | |
| 478 /* Use element_precision instead of TYPE_PRECISION so complex and | |
| 479 vector types get a non-zero precision. */ | |
| 480 unsigned int precision = element_precision (TREE_TYPE (name)); | |
| 481 if (POINTER_TYPE_P (TREE_TYPE (name))) | |
| 482 { | |
| 483 struct ptr_info_def *pi = SSA_NAME_PTR_INFO (name); | |
| 484 if (pi && pi->align) | |
| 485 return wi::shwi (-(HOST_WIDE_INT) pi->align | |
| 486 | (HOST_WIDE_INT) pi->misalign, precision); | |
| 487 return wi::shwi (-1, precision); | |
| 488 } | |
| 489 | |
| 490 range_info_def *ri = SSA_NAME_RANGE_INFO (name); | |
| 491 if (!ri) | |
| 492 return wi::shwi (-1, precision); | |
| 493 | |
| 494 return ri->get_nonzero_bits (); | |
| 495 } | |
| 496 | |
| 497 /* Return TRUE is OP, an SSA_NAME has a range of values [0..1], false | |
| 498 otherwise. | |
| 499 | |
| 500 This can be because it is a boolean type, any unsigned integral | |
| 501 type with a single bit of precision, or has known range of [0..1] | |
| 502 via VRP analysis. */ | |
| 503 | |
| 504 bool | |
| 505 ssa_name_has_boolean_range (tree op) | |
| 506 { | |
| 507 gcc_assert (TREE_CODE (op) == SSA_NAME); | |
| 508 | |
| 509 /* Boolean types always have a range [0..1]. */ | |
| 510 if (TREE_CODE (TREE_TYPE (op)) == BOOLEAN_TYPE) | |
| 511 return true; | |
| 512 | |
| 513 /* An integral type with a single bit of precision. */ | |
| 514 if (INTEGRAL_TYPE_P (TREE_TYPE (op)) | |
| 515 && TYPE_UNSIGNED (TREE_TYPE (op)) | |
| 516 && TYPE_PRECISION (TREE_TYPE (op)) == 1) | |
| 517 return true; | |
| 518 | |
| 519 /* An integral type with more precision, but the object | |
| 520 only takes on values [0..1] as determined by VRP | |
| 521 analysis. */ | |
| 522 if (INTEGRAL_TYPE_P (TREE_TYPE (op)) | |
| 523 && (TYPE_PRECISION (TREE_TYPE (op)) > 1) | |
| 524 && wi::eq_p (get_nonzero_bits (op), 1)) | |
| 525 return true; | |
| 526 | |
| 527 return false; | |
| 528 } | |
| 0 | 529 |
| 530 /* We no longer need the SSA_NAME expression VAR, release it so that | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
531 it may be reused. |
| 0 | 532 |
| 533 Note it is assumed that no calls to make_ssa_name will be made | |
| 534 until all uses of the ssa name are released and that the only | |
| 535 use of the SSA_NAME expression is to check its SSA_NAME_VAR. All | |
| 536 other fields must be assumed clobbered. */ | |
| 537 | |
| 538 void | |
| 111 | 539 release_ssa_name_fn (struct function *fn, tree var) |
| 0 | 540 { |
| 541 if (!var) | |
| 542 return; | |
| 543 | |
| 544 /* Never release the default definition for a symbol. It's a | |
| 545 special SSA name that should always exist once it's created. */ | |
| 546 if (SSA_NAME_IS_DEFAULT_DEF (var)) | |
| 547 return; | |
| 548 | |
| 549 /* If VAR has been registered for SSA updating, don't remove it. | |
| 550 After update_ssa has run, the name will be released. */ | |
| 551 if (name_registered_for_update_p (var)) | |
| 552 { | |
| 553 release_ssa_name_after_update_ssa (var); | |
| 554 return; | |
| 555 } | |
| 556 | |
| 557 /* release_ssa_name can be called multiple times on a single SSA_NAME. | |
| 558 However, it should only end up on our free list one time. We | |
| 559 keep a status bit in the SSA_NAME node itself to indicate it has | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
560 been put on the free list. |
| 0 | 561 |
| 562 Note that once on the freelist you can not reference the SSA_NAME's | |
| 563 defining statement. */ | |
| 564 if (! SSA_NAME_IN_FREE_LIST (var)) | |
| 565 { | |
| 566 tree saved_ssa_name_var = SSA_NAME_VAR (var); | |
| 567 int saved_ssa_name_version = SSA_NAME_VERSION (var); | |
| 568 use_operand_p imm = &(SSA_NAME_IMM_USE_NODE (var)); | |
| 569 | |
| 131 | 570 if (MAY_HAVE_DEBUG_BIND_STMTS) |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
571 insert_debug_temp_for_var_def (NULL, var); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
572 |
| 111 | 573 if (flag_checking) |
| 574 verify_imm_links (stderr, var); | |
| 0 | 575 while (imm->next != imm) |
| 576 delink_imm_use (imm->next); | |
| 577 | |
| 111 | 578 (*SSANAMES (fn))[SSA_NAME_VERSION (var)] = NULL_TREE; |
| 0 | 579 memset (var, 0, tree_size (var)); |
| 580 | |
| 581 imm->prev = imm; | |
| 582 imm->next = imm; | |
| 583 imm->loc.ssa_name = var; | |
| 584 | |
| 585 /* First put back the right tree node so that the tree checking | |
| 586 macros do not complain. */ | |
| 587 TREE_SET_CODE (var, SSA_NAME); | |
| 588 | |
| 589 /* Restore the version number. */ | |
| 590 SSA_NAME_VERSION (var) = saved_ssa_name_version; | |
| 591 | |
| 592 /* Hopefully this can go away once we have the new incremental | |
| 593 SSA updating code installed. */ | |
| 111 | 594 SET_SSA_NAME_VAR_OR_IDENTIFIER (var, saved_ssa_name_var); |
| 0 | 595 |
| 596 /* Note this SSA_NAME is now in the first list. */ | |
| 597 SSA_NAME_IN_FREE_LIST (var) = 1; | |
| 598 | |
| 111 | 599 /* And finally queue it so that it will be put on the free list. */ |
| 600 vec_safe_push (FREE_SSANAMES_QUEUE (fn), var); | |
| 0 | 601 } |
| 602 } | |
| 603 | |
| 111 | 604 /* If the alignment of the pointer described by PI is known, return true and |
| 605 store the alignment and the deviation from it into *ALIGNP and *MISALIGNP | |
| 606 respectively. Otherwise return false. */ | |
| 607 | |
| 608 bool | |
| 609 get_ptr_info_alignment (struct ptr_info_def *pi, unsigned int *alignp, | |
| 610 unsigned int *misalignp) | |
| 611 { | |
| 612 if (pi->align) | |
| 613 { | |
| 614 *alignp = pi->align; | |
| 615 *misalignp = pi->misalign; | |
| 616 return true; | |
| 617 } | |
| 618 else | |
| 619 return false; | |
| 620 } | |
| 621 | |
| 622 /* State that the pointer described by PI has unknown alignment. */ | |
| 623 | |
| 624 void | |
| 625 mark_ptr_info_alignment_unknown (struct ptr_info_def *pi) | |
| 626 { | |
| 627 pi->align = 0; | |
| 628 pi->misalign = 0; | |
| 629 } | |
| 630 | |
| 631 /* Store the power-of-two byte alignment and the deviation from that | |
| 632 alignment of pointer described by PI to ALIOGN and MISALIGN | |
| 633 respectively. */ | |
| 634 | |
| 635 void | |
| 636 set_ptr_info_alignment (struct ptr_info_def *pi, unsigned int align, | |
| 637 unsigned int misalign) | |
| 638 { | |
| 639 gcc_checking_assert (align != 0); | |
| 640 gcc_assert ((align & (align - 1)) == 0); | |
| 641 gcc_assert ((misalign & ~(align - 1)) == 0); | |
| 642 | |
| 643 pi->align = align; | |
| 644 pi->misalign = misalign; | |
| 645 } | |
| 646 | |
| 647 /* If pointer described by PI has known alignment, increase its known | |
| 648 misalignment by INCREMENT modulo its current alignment. */ | |
| 649 | |
| 650 void | |
| 131 | 651 adjust_ptr_info_misalignment (struct ptr_info_def *pi, poly_uint64 increment) |
| 111 | 652 { |
| 653 if (pi->align != 0) | |
| 654 { | |
| 131 | 655 increment += pi->misalign; |
| 656 if (!known_misalignment (increment, pi->align, &pi->misalign)) | |
| 657 { | |
| 658 pi->align = known_alignment (increment); | |
| 659 pi->misalign = 0; | |
| 660 } | |
| 111 | 661 } |
| 662 } | |
| 0 | 663 |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
664 /* Return the alias information associated with pointer T. It creates a |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
665 new instance if none existed. */ |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
666 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
667 struct ptr_info_def * |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
668 get_ptr_info (tree t) |
| 0 | 669 { |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
670 struct ptr_info_def *pi; |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
671 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
672 gcc_assert (POINTER_TYPE_P (TREE_TYPE (t))); |
| 0 | 673 |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
674 pi = SSA_NAME_PTR_INFO (t); |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
675 if (pi == NULL) |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
676 { |
| 111 | 677 pi = ggc_cleared_alloc<ptr_info_def> (); |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
678 pt_solution_reset (&pi->pt); |
| 111 | 679 mark_ptr_info_alignment_unknown (pi); |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
680 SSA_NAME_PTR_INFO (t) = pi; |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
681 } |
| 0 | 682 |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
683 return pi; |
| 0 | 684 } |
| 685 | |
| 111 | 686 |
| 687 /* Creates a new SSA name using the template NAME tobe defined by | |
| 688 statement STMT in function FN. */ | |
| 689 | |
| 690 tree | |
| 691 copy_ssa_name_fn (struct function *fn, tree name, gimple *stmt) | |
| 692 { | |
| 693 tree new_name; | |
| 694 | |
| 695 if (SSA_NAME_VAR (name)) | |
| 696 new_name = make_ssa_name_fn (fn, SSA_NAME_VAR (name), stmt); | |
| 697 else | |
| 698 { | |
| 699 new_name = make_ssa_name_fn (fn, TREE_TYPE (name), stmt); | |
| 700 SET_SSA_NAME_VAR_OR_IDENTIFIER (new_name, SSA_NAME_IDENTIFIER (name)); | |
| 701 } | |
| 702 | |
| 703 return new_name; | |
| 704 } | |
| 705 | |
| 706 | |
| 0 | 707 /* Creates a duplicate of the ptr_info_def at PTR_INFO for use by |
| 708 the SSA name NAME. */ | |
| 709 | |
| 710 void | |
| 711 duplicate_ssa_name_ptr_info (tree name, struct ptr_info_def *ptr_info) | |
| 712 { | |
| 713 struct ptr_info_def *new_ptr_info; | |
| 714 | |
| 715 gcc_assert (POINTER_TYPE_P (TREE_TYPE (name))); | |
| 716 gcc_assert (!SSA_NAME_PTR_INFO (name)); | |
| 717 | |
| 718 if (!ptr_info) | |
| 719 return; | |
| 720 | |
| 111 | 721 new_ptr_info = ggc_alloc<ptr_info_def> (); |
| 0 | 722 *new_ptr_info = *ptr_info; |
| 723 | |
| 724 SSA_NAME_PTR_INFO (name) = new_ptr_info; | |
| 725 } | |
| 726 | |
| 111 | 727 /* Creates a duplicate of the range_info_def at RANGE_INFO of type |
| 728 RANGE_TYPE for use by the SSA name NAME. */ | |
| 729 void | |
| 131 | 730 duplicate_ssa_name_range_info (tree name, enum value_range_kind range_type, |
| 111 | 731 struct range_info_def *range_info) |
| 732 { | |
| 733 struct range_info_def *new_range_info; | |
| 0 | 734 |
| 111 | 735 gcc_assert (!POINTER_TYPE_P (TREE_TYPE (name))); |
| 736 gcc_assert (!SSA_NAME_RANGE_INFO (name)); | |
| 737 | |
| 738 if (!range_info) | |
| 739 return; | |
| 740 | |
| 741 unsigned int precision = TYPE_PRECISION (TREE_TYPE (name)); | |
| 742 size_t size = (sizeof (range_info_def) | |
| 743 + trailing_wide_ints <3>::extra_size (precision)); | |
| 744 new_range_info = static_cast<range_info_def *> (ggc_internal_alloc (size)); | |
| 745 memcpy (new_range_info, range_info, size); | |
| 746 | |
| 747 gcc_assert (range_type == VR_RANGE || range_type == VR_ANTI_RANGE); | |
| 748 SSA_NAME_ANTI_RANGE_P (name) = (range_type == VR_ANTI_RANGE); | |
| 749 SSA_NAME_RANGE_INFO (name) = new_range_info; | |
| 750 } | |
| 751 | |
| 752 | |
| 753 | |
| 754 /* Creates a duplicate of a ssa name NAME tobe defined by statement STMT | |
| 755 in function FN. */ | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
756 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
757 tree |
| 111 | 758 duplicate_ssa_name_fn (struct function *fn, tree name, gimple *stmt) |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
759 { |
| 111 | 760 tree new_name = copy_ssa_name_fn (fn, name, stmt); |
| 761 if (POINTER_TYPE_P (TREE_TYPE (name))) | |
| 762 { | |
| 763 struct ptr_info_def *old_ptr_info = SSA_NAME_PTR_INFO (name); | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
764 |
| 111 | 765 if (old_ptr_info) |
| 766 duplicate_ssa_name_ptr_info (new_name, old_ptr_info); | |
| 767 } | |
| 768 else | |
| 769 { | |
| 770 struct range_info_def *old_range_info = SSA_NAME_RANGE_INFO (name); | |
| 771 | |
| 772 if (old_range_info) | |
| 773 duplicate_ssa_name_range_info (new_name, SSA_NAME_RANGE_TYPE (name), | |
| 774 old_range_info); | |
| 775 } | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
776 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
777 return new_name; |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
778 } |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
779 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
780 |
| 111 | 781 /* Reset all flow sensitive data on NAME such as range-info, nonzero |
| 782 bits and alignment. */ | |
| 783 | |
| 784 void | |
| 785 reset_flow_sensitive_info (tree name) | |
| 786 { | |
| 787 if (POINTER_TYPE_P (TREE_TYPE (name))) | |
| 788 { | |
| 789 /* points-to info is not flow-sensitive. */ | |
| 790 if (SSA_NAME_PTR_INFO (name)) | |
| 791 mark_ptr_info_alignment_unknown (SSA_NAME_PTR_INFO (name)); | |
| 792 } | |
| 793 else | |
| 794 SSA_NAME_RANGE_INFO (name) = NULL; | |
| 795 } | |
| 796 | |
| 797 /* Clear all flow sensitive data from all statements and PHI definitions | |
| 798 in BB. */ | |
| 799 | |
| 800 void | |
| 801 reset_flow_sensitive_info_in_bb (basic_block bb) | |
| 802 { | |
| 803 for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi); | |
| 804 gsi_next (&gsi)) | |
| 805 { | |
| 806 gimple *stmt = gsi_stmt (gsi); | |
| 807 ssa_op_iter i; | |
| 808 tree op; | |
| 809 FOR_EACH_SSA_TREE_OPERAND (op, stmt, i, SSA_OP_DEF) | |
| 810 reset_flow_sensitive_info (op); | |
| 811 } | |
| 812 | |
| 813 for (gphi_iterator gsi = gsi_start_phis (bb); !gsi_end_p (gsi); | |
| 814 gsi_next (&gsi)) | |
| 815 { | |
| 816 tree phi_def = gimple_phi_result (gsi.phi ()); | |
| 817 reset_flow_sensitive_info (phi_def); | |
| 818 } | |
| 819 } | |
| 820 | |
| 0 | 821 /* Release all the SSA_NAMEs created by STMT. */ |
| 822 | |
| 823 void | |
| 111 | 824 release_defs (gimple *stmt) |
| 0 | 825 { |
| 826 tree def; | |
| 827 ssa_op_iter iter; | |
| 828 | |
| 829 FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_ALL_DEFS) | |
| 830 if (TREE_CODE (def) == SSA_NAME) | |
| 831 release_ssa_name (def); | |
| 832 } | |
| 833 | |
| 834 | |
| 835 /* Replace the symbol associated with SSA_NAME with SYM. */ | |
| 836 | |
| 837 void | |
| 838 replace_ssa_name_symbol (tree ssa_name, tree sym) | |
| 839 { | |
| 111 | 840 SET_SSA_NAME_VAR_OR_IDENTIFIER (ssa_name, sym); |
| 0 | 841 TREE_TYPE (ssa_name) = TREE_TYPE (sym); |
| 842 } | |
| 843 | |
| 111 | 844 /* Release the vector of free SSA_NAMEs and compact the vector of SSA_NAMEs |
| 845 that are live. */ | |
| 846 | |
| 847 static void | |
| 848 release_free_names_and_compact_live_names (function *fun) | |
| 0 | 849 { |
| 111 | 850 unsigned i, j; |
| 851 int n = vec_safe_length (FREE_SSANAMES (fun)); | |
| 0 | 852 |
| 853 /* Now release the freelist. */ | |
| 111 | 854 vec_free (FREE_SSANAMES (fun)); |
| 855 | |
| 856 /* And compact the SSA number space. We make sure to not change the | |
| 857 relative order of SSA versions. */ | |
| 858 for (i = 1, j = 1; i < fun->gimple_df->ssa_names->length (); ++i) | |
| 0 | 859 { |
| 111 | 860 tree name = ssa_name (i); |
| 861 if (name) | |
| 862 { | |
| 863 if (i != j) | |
| 864 { | |
| 865 SSA_NAME_VERSION (name) = j; | |
| 866 (*fun->gimple_df->ssa_names)[j] = name; | |
| 867 } | |
| 868 j++; | |
| 869 } | |
| 0 | 870 } |
| 111 | 871 fun->gimple_df->ssa_names->truncate (j); |
| 872 | |
| 873 statistics_counter_event (fun, "SSA names released", n); | |
| 874 statistics_counter_event (fun, "SSA name holes removed", i - j); | |
| 875 if (dump_file) | |
| 876 fprintf (dump_file, "Released %i names, %.2f%%, removed %i holes\n", | |
| 877 n, n * 100.0 / num_ssa_names, i - j); | |
| 878 } | |
| 879 | |
| 880 /* Return SSA names that are unused to GGC memory and compact the SSA | |
| 881 version namespace. This is used to keep footprint of compiler during | |
| 882 interprocedural optimization. */ | |
| 883 | |
| 884 namespace { | |
| 0 | 885 |
| 111 | 886 const pass_data pass_data_release_ssa_names = |
| 887 { | |
| 888 GIMPLE_PASS, /* type */ | |
| 889 "release_ssa", /* name */ | |
| 890 OPTGROUP_NONE, /* optinfo_flags */ | |
| 891 TV_TREE_SSA_OTHER, /* tv_id */ | |
| 892 PROP_ssa, /* properties_required */ | |
| 893 0, /* properties_provided */ | |
| 894 0, /* properties_destroyed */ | |
| 895 TODO_remove_unused_locals, /* todo_flags_start */ | |
| 896 0, /* todo_flags_finish */ | |
| 897 }; | |
| 898 | |
| 899 class pass_release_ssa_names : public gimple_opt_pass | |
| 900 { | |
| 901 public: | |
| 902 pass_release_ssa_names (gcc::context *ctxt) | |
| 903 : gimple_opt_pass (pass_data_release_ssa_names, ctxt) | |
| 904 {} | |
| 905 | |
| 906 /* opt_pass methods: */ | |
| 907 virtual unsigned int execute (function *); | |
| 908 | |
| 909 }; // class pass_release_ssa_names | |
| 910 | |
| 911 unsigned int | |
| 912 pass_release_ssa_names::execute (function *fun) | |
| 913 { | |
| 914 release_free_names_and_compact_live_names (fun); | |
| 0 | 915 return 0; |
| 916 } | |
| 917 | |
| 111 | 918 } // anon namespace |
| 919 | |
| 920 gimple_opt_pass * | |
| 921 make_pass_release_ssa_names (gcc::context *ctxt) | |
| 0 | 922 { |
| 111 | 923 return new pass_release_ssa_names (ctxt); |
| 924 } |