Mercurial > hg > CbC > CbC_gcc
annotate gcc/tree-ssa-dce.c @ 158:494b0b89df80 default tip
...
| author | Shinji KONO <kono@ie.u-ryukyu.ac.jp> |
|---|---|
| date | Mon, 25 May 2020 18:13:55 +0900 |
| parents | 1830386684a0 |
| children |
| rev | line source |
|---|---|
| 0 | 1 /* Dead code elimination pass for the GNU compiler. |
| 145 | 2 Copyright (C) 2002-2020 Free Software Foundation, Inc. |
| 0 | 3 Contributed by Ben Elliston <bje@redhat.com> |
| 4 and Andrew MacLeod <amacleod@redhat.com> | |
| 5 Adapted to use control dependence by Steven Bosscher, SUSE Labs. | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
6 |
| 0 | 7 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
|
8 |
| 0 | 9 GCC is free software; you can redistribute it and/or modify it |
| 10 under the terms of the GNU General Public License as published by the | |
| 11 Free Software Foundation; either version 3, or (at your option) any | |
| 12 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
|
13 |
| 0 | 14 GCC is distributed in the hope that it will be useful, but WITHOUT |
| 15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 17 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
|
18 |
| 0 | 19 You should have received a copy of the GNU General Public License |
| 20 along with GCC; see the file COPYING3. If not see | |
| 21 <http://www.gnu.org/licenses/>. */ | |
| 22 | |
| 23 /* Dead code elimination. | |
| 24 | |
| 25 References: | |
| 26 | |
| 27 Building an Optimizing Compiler, | |
| 28 Robert Morgan, Butterworth-Heinemann, 1998, Section 8.9. | |
| 29 | |
| 30 Advanced Compiler Design and Implementation, | |
| 31 Steven Muchnick, Morgan Kaufmann, 1997, Section 18.10. | |
| 32 | |
| 33 Dead-code elimination is the removal of statements which have no | |
| 34 impact on the program's output. "Dead statements" have no impact | |
| 35 on the program's output, while "necessary statements" may have | |
| 36 impact on the output. | |
| 37 | |
| 38 The algorithm consists of three phases: | |
| 39 1. Marking as necessary all statements known to be necessary, | |
| 40 e.g. most function calls, writing a value to memory, etc; | |
| 41 2. Propagating necessary statements, e.g., the statements | |
| 42 giving values to operands in necessary statements; and | |
| 43 3. Removing dead statements. */ | |
| 44 | |
| 45 #include "config.h" | |
| 46 #include "system.h" | |
| 47 #include "coretypes.h" | |
| 111 | 48 #include "backend.h" |
| 49 #include "rtl.h" | |
| 0 | 50 #include "tree.h" |
| 111 | 51 #include "gimple.h" |
| 52 #include "cfghooks.h" | |
| 53 #include "tree-pass.h" | |
| 54 #include "ssa.h" | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
55 #include "gimple-pretty-print.h" |
| 111 | 56 #include "fold-const.h" |
| 57 #include "calls.h" | |
| 58 #include "cfganal.h" | |
| 59 #include "tree-eh.h" | |
| 60 #include "gimplify.h" | |
| 61 #include "gimple-iterator.h" | |
| 62 #include "tree-cfg.h" | |
| 63 #include "tree-ssa-loop-niter.h" | |
| 64 #include "tree-into-ssa.h" | |
| 65 #include "tree-dfa.h" | |
| 0 | 66 #include "cfgloop.h" |
| 67 #include "tree-scalar-evolution.h" | |
| 111 | 68 #include "tree-ssa-propagate.h" |
| 69 #include "gimple-fold.h" | |
| 0 | 70 |
| 71 static struct stmt_stats | |
| 72 { | |
| 73 int total; | |
| 74 int total_phis; | |
| 75 int removed; | |
| 76 int removed_phis; | |
| 77 } stats; | |
| 78 | |
| 79 #define STMT_NECESSARY GF_PLF_1 | |
| 80 | |
| 111 | 81 static vec<gimple *> worklist; |
| 0 | 82 |
| 83 /* Vector indicating an SSA name has already been processed and marked | |
| 84 as necessary. */ | |
| 85 static sbitmap processed; | |
| 86 | |
|
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
|
87 /* Vector indicating that the last statement of a basic block has already |
|
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
|
88 been marked as necessary. */ |
| 0 | 89 static sbitmap last_stmt_necessary; |
| 90 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
91 /* Vector indicating that BB contains statements that are live. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
92 static sbitmap bb_contains_live_stmts; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
93 |
| 0 | 94 /* Before we can determine whether a control branch is dead, we need to |
| 95 compute which blocks are control dependent on which edges. | |
| 96 | |
| 97 We expect each block to be control dependent on very few edges so we | |
| 98 use a bitmap for each block recording its edges. An array holds the | |
| 99 bitmap. The Ith bit in the bitmap is set if that block is dependent | |
| 100 on the Ith edge. */ | |
| 111 | 101 static control_dependences *cd; |
| 0 | 102 |
| 103 /* Vector indicating that a basic block has already had all the edges | |
| 104 processed that it is control dependent on. */ | |
| 105 static sbitmap visited_control_parents; | |
| 106 | |
| 107 /* TRUE if this pass alters the CFG (by removing control statements). | |
| 108 FALSE otherwise. | |
| 109 | |
| 110 If this pass alters the CFG, then it will arrange for the dominators | |
| 111 to be recomputed. */ | |
| 112 static bool cfg_altered; | |
| 113 | |
| 111 | 114 /* When non-NULL holds map from basic block index into the postorder. */ |
| 115 static int *bb_postorder; | |
| 0 | 116 |
| 117 | |
| 145 | 118 /* True if we should treat any stmt with a vdef as necessary. */ |
| 119 | |
| 120 static inline bool | |
| 121 keep_all_vdefs_p () | |
| 122 { | |
| 123 return optimize_debug; | |
| 124 } | |
| 125 | |
| 0 | 126 /* If STMT is not already marked necessary, mark it, and add it to the |
| 127 worklist if ADD_TO_WORKLIST is true. */ | |
|
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
|
128 |
| 0 | 129 static inline void |
| 111 | 130 mark_stmt_necessary (gimple *stmt, bool add_to_worklist) |
| 0 | 131 { |
| 132 gcc_assert (stmt); | |
| 133 | |
| 134 if (gimple_plf (stmt, STMT_NECESSARY)) | |
| 135 return; | |
| 136 | |
| 137 if (dump_file && (dump_flags & TDF_DETAILS)) | |
| 138 { | |
| 139 fprintf (dump_file, "Marking useful stmt: "); | |
| 140 print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM); | |
| 141 fprintf (dump_file, "\n"); | |
| 142 } | |
| 143 | |
| 144 gimple_set_plf (stmt, STMT_NECESSARY, true); | |
| 145 if (add_to_worklist) | |
| 111 | 146 worklist.safe_push (stmt); |
| 147 if (add_to_worklist && bb_contains_live_stmts && !is_gimple_debug (stmt)) | |
| 148 bitmap_set_bit (bb_contains_live_stmts, gimple_bb (stmt)->index); | |
| 0 | 149 } |
| 150 | |
| 151 | |
| 152 /* Mark the statement defining operand OP as necessary. */ | |
| 153 | |
| 154 static inline void | |
| 155 mark_operand_necessary (tree op) | |
| 156 { | |
| 111 | 157 gimple *stmt; |
| 0 | 158 int ver; |
| 159 | |
| 160 gcc_assert (op); | |
| 161 | |
| 162 ver = SSA_NAME_VERSION (op); | |
| 111 | 163 if (bitmap_bit_p (processed, ver)) |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
164 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
165 stmt = SSA_NAME_DEF_STMT (op); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
166 gcc_assert (gimple_nop_p (stmt) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
167 || gimple_plf (stmt, STMT_NECESSARY)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
168 return; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
169 } |
| 111 | 170 bitmap_set_bit (processed, ver); |
| 0 | 171 |
| 172 stmt = SSA_NAME_DEF_STMT (op); | |
| 173 gcc_assert (stmt); | |
| 174 | |
| 175 if (gimple_plf (stmt, STMT_NECESSARY) || gimple_nop_p (stmt)) | |
| 176 return; | |
| 177 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
178 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:
0
diff
changeset
|
179 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
180 fprintf (dump_file, "marking necessary through "); |
| 111 | 181 print_generic_expr (dump_file, op); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
182 fprintf (dump_file, " stmt "); |
| 111 | 183 print_gimple_stmt (dump_file, stmt, 0); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
184 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
185 |
| 0 | 186 gimple_set_plf (stmt, STMT_NECESSARY, true); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
187 if (bb_contains_live_stmts) |
| 111 | 188 bitmap_set_bit (bb_contains_live_stmts, gimple_bb (stmt)->index); |
| 189 worklist.safe_push (stmt); | |
| 0 | 190 } |
| 191 | |
| 192 | |
| 193 /* Mark STMT as necessary if it obviously is. Add it to the worklist if | |
| 194 it can make other statements necessary. | |
| 195 | |
| 196 If AGGRESSIVE is false, control statements are conservatively marked as | |
| 197 necessary. */ | |
| 198 | |
| 199 static void | |
| 111 | 200 mark_stmt_if_obviously_necessary (gimple *stmt, bool aggressive) |
| 0 | 201 { |
| 202 /* With non-call exceptions, we have to assume that all statements could | |
| 111 | 203 throw. If a statement could throw, it can be deemed necessary. */ |
| 204 if (cfun->can_throw_non_call_exceptions | |
| 205 && !cfun->can_delete_dead_exceptions | |
| 131 | 206 && stmt_could_throw_p (cfun, stmt)) |
| 0 | 207 { |
| 208 mark_stmt_necessary (stmt, true); | |
| 209 return; | |
| 210 } | |
| 211 | |
| 212 /* Statements that are implicitly live. Most function calls, asm | |
| 213 and return statements are required. Labels and GIMPLE_BIND nodes | |
| 214 are kept because they are control flow, and we have no way of | |
| 215 knowing whether they can be removed. DCE can eliminate all the | |
| 216 other statements in a block, and CFG can then remove the block | |
| 217 and labels. */ | |
| 218 switch (gimple_code (stmt)) | |
| 219 { | |
| 220 case GIMPLE_PREDICT: | |
| 221 case GIMPLE_LABEL: | |
| 222 mark_stmt_necessary (stmt, false); | |
| 223 return; | |
| 224 | |
| 225 case GIMPLE_ASM: | |
| 226 case GIMPLE_RESX: | |
| 227 case GIMPLE_RETURN: | |
| 228 mark_stmt_necessary (stmt, true); | |
| 229 return; | |
| 230 | |
| 231 case GIMPLE_CALL: | |
| 111 | 232 { |
| 233 tree callee = gimple_call_fndecl (stmt); | |
| 234 if (callee != NULL_TREE | |
| 131 | 235 && fndecl_built_in_p (callee, BUILT_IN_NORMAL)) |
| 111 | 236 switch (DECL_FUNCTION_CODE (callee)) |
| 237 { | |
| 238 case BUILT_IN_MALLOC: | |
| 239 case BUILT_IN_ALIGNED_ALLOC: | |
| 240 case BUILT_IN_CALLOC: | |
| 241 CASE_BUILT_IN_ALLOCA: | |
| 242 case BUILT_IN_STRDUP: | |
| 243 case BUILT_IN_STRNDUP: | |
| 244 return; | |
| 245 | |
| 246 default:; | |
| 247 } | |
| 145 | 248 |
| 249 if (callee != NULL_TREE | |
| 250 && flag_allocation_dce | |
| 251 && DECL_IS_REPLACEABLE_OPERATOR_NEW_P (callee)) | |
| 252 return; | |
| 253 | |
| 111 | 254 /* Most, but not all function calls are required. Function calls that |
| 255 produce no result and have no side effects (i.e. const pure | |
| 256 functions) are unnecessary. */ | |
| 257 if (gimple_has_side_effects (stmt)) | |
| 258 { | |
| 259 mark_stmt_necessary (stmt, true); | |
| 260 return; | |
| 261 } | |
| 145 | 262 /* IFN_GOACC_LOOP calls are necessary in that they are used to |
| 263 represent parameter (i.e. step, bound) of a lowered OpenACC | |
| 264 partitioned loop. But this kind of partitioned loop might not | |
| 265 survive from aggressive loop removal for it has loop exit and | |
| 266 is assumed to be finite. Therefore, we need to explicitly mark | |
| 267 these calls. (An example is libgomp.oacc-c-c++-common/pr84955.c) */ | |
| 268 if (gimple_call_internal_p (stmt, IFN_GOACC_LOOP)) | |
| 269 { | |
| 270 mark_stmt_necessary (stmt, true); | |
| 271 return; | |
| 272 } | |
| 111 | 273 if (!gimple_call_lhs (stmt)) |
| 0 | 274 return; |
| 111 | 275 break; |
| 276 } | |
| 0 | 277 |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
278 case GIMPLE_DEBUG: |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
279 /* Debug temps without a value are not useful. ??? If we could |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
280 easily locate the debug temp bind stmt for a use thereof, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
281 would could refrain from marking all debug temps here, and |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
282 mark them only if they're used. */ |
| 131 | 283 if (gimple_debug_nonbind_marker_p (stmt) |
| 284 || !gimple_debug_bind_p (stmt) | |
| 111 | 285 || gimple_debug_bind_has_value_p (stmt) |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
286 || TREE_CODE (gimple_debug_bind_get_var (stmt)) != DEBUG_EXPR_DECL) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
287 mark_stmt_necessary (stmt, false); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
288 return; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
289 |
| 0 | 290 case GIMPLE_GOTO: |
| 291 gcc_assert (!simple_goto_p (stmt)); | |
| 292 mark_stmt_necessary (stmt, true); | |
| 293 return; | |
| 294 | |
| 295 case GIMPLE_COND: | |
| 296 gcc_assert (EDGE_COUNT (gimple_bb (stmt)->succs) == 2); | |
| 297 /* Fall through. */ | |
| 298 | |
| 299 case GIMPLE_SWITCH: | |
| 300 if (! aggressive) | |
| 301 mark_stmt_necessary (stmt, true); | |
| 302 break; | |
| 303 | |
| 111 | 304 case GIMPLE_ASSIGN: |
| 305 if (gimple_clobber_p (stmt)) | |
| 306 return; | |
| 307 break; | |
| 308 | |
| 0 | 309 default: |
| 310 break; | |
| 311 } | |
| 312 | |
| 313 /* If the statement has volatile operands, it needs to be preserved. | |
| 314 Same for statements that can alter control flow in unpredictable | |
| 315 ways. */ | |
| 316 if (gimple_has_volatile_ops (stmt) || is_ctrl_altering_stmt (stmt)) | |
| 317 { | |
| 318 mark_stmt_necessary (stmt, true); | |
| 319 return; | |
| 320 } | |
| 321 | |
| 111 | 322 if (stmt_may_clobber_global_p (stmt)) |
| 0 | 323 { |
| 324 mark_stmt_necessary (stmt, true); | |
| 325 return; | |
| 326 } | |
| 327 | |
| 145 | 328 if (gimple_vdef (stmt) && keep_all_vdefs_p ()) |
| 329 { | |
| 330 mark_stmt_necessary (stmt, true); | |
| 331 return; | |
| 332 } | |
| 333 | |
| 0 | 334 return; |
| 335 } | |
| 336 | |
| 337 | |
|
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
|
338 /* Mark the last statement of BB as necessary. */ |
|
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
|
339 |
|
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
|
340 static void |
|
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
|
341 mark_last_stmt_necessary (basic_block bb) |
|
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
|
342 { |
| 111 | 343 gimple *stmt = last_stmt (bb); |
|
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
|
344 |
| 111 | 345 bitmap_set_bit (last_stmt_necessary, bb->index); |
| 346 bitmap_set_bit (bb_contains_live_stmts, bb->index); | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
347 |
|
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
|
348 /* We actually mark the statement only if it is a control statement. */ |
|
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
|
349 if (stmt && is_ctrl_stmt (stmt)) |
|
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
|
350 mark_stmt_necessary (stmt, true); |
|
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
|
351 } |
|
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
|
352 |
|
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
|
353 |
|
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
|
354 /* Mark control dependent edges of BB as necessary. We have to do this only |
|
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
|
355 once for each basic block so we set the appropriate bit after we're done. |
|
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
|
356 |
|
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
|
357 When IGNORE_SELF is true, ignore BB in the list of control dependences. */ |
|
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
|
358 |
| 0 | 359 static void |
| 111 | 360 mark_control_dependent_edges_necessary (basic_block bb, bool ignore_self) |
| 0 | 361 { |
| 362 bitmap_iterator bi; | |
| 363 unsigned edge_number; | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
364 bool skipped = false; |
| 0 | 365 |
| 111 | 366 gcc_assert (bb != EXIT_BLOCK_PTR_FOR_FN (cfun)); |
| 0 | 367 |
| 111 | 368 if (bb == ENTRY_BLOCK_PTR_FOR_FN (cfun)) |
| 0 | 369 return; |
| 370 | |
| 111 | 371 EXECUTE_IF_SET_IN_BITMAP (cd->get_edges_dependent_on (bb->index), |
| 372 0, edge_number, bi) | |
| 0 | 373 { |
| 111 | 374 basic_block cd_bb = cd->get_edge_src (edge_number); |
| 0 | 375 |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
376 if (ignore_self && cd_bb == bb) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
377 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
378 skipped = true; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
379 continue; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
380 } |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
381 |
| 111 | 382 if (!bitmap_bit_p (last_stmt_necessary, cd_bb->index)) |
|
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
|
383 mark_last_stmt_necessary (cd_bb); |
|
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
|
384 } |
| 0 | 385 |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
386 if (!skipped) |
| 111 | 387 bitmap_set_bit (visited_control_parents, bb->index); |
| 0 | 388 } |
| 389 | |
| 390 | |
| 391 /* Find obviously necessary statements. These are things like most function | |
| 392 calls, and stores to file level variables. | |
| 393 | |
| 394 If EL is NULL, control statements are conservatively marked as | |
| 395 necessary. Otherwise it contains the list of edges used by control | |
| 396 dependence analysis. */ | |
| 397 | |
| 398 static void | |
| 111 | 399 find_obviously_necessary_stmts (bool aggressive) |
| 0 | 400 { |
| 401 basic_block bb; | |
| 402 gimple_stmt_iterator gsi; | |
| 403 edge e; | |
| 111 | 404 gimple *phi, *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
|
405 int flags; |
| 0 | 406 |
| 111 | 407 FOR_EACH_BB_FN (bb, cfun) |
| 0 | 408 { |
| 409 /* PHI nodes are never inherently necessary. */ | |
| 410 for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi)) | |
| 411 { | |
| 412 phi = gsi_stmt (gsi); | |
| 413 gimple_set_plf (phi, STMT_NECESSARY, false); | |
| 414 } | |
| 415 | |
| 416 /* Check all statements in the block. */ | |
| 417 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) | |
| 418 { | |
| 419 stmt = gsi_stmt (gsi); | |
| 420 gimple_set_plf (stmt, STMT_NECESSARY, false); | |
| 111 | 421 mark_stmt_if_obviously_necessary (stmt, aggressive); |
| 0 | 422 } |
| 423 } | |
| 424 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
425 /* Pure and const functions are finite and thus have no infinite loops in |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
426 them. */ |
|
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
|
427 flags = flags_from_decl_or_type (current_function_decl); |
|
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
|
428 if ((flags & (ECF_CONST|ECF_PURE)) && !(flags & ECF_LOOPING_CONST_OR_PURE)) |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
429 return; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
430 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
431 /* Prevent the empty possibly infinite loops from being removed. */ |
| 111 | 432 if (aggressive) |
| 0 | 433 { |
| 145 | 434 class loop *loop; |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
435 if (mark_irreducible_loops ()) |
| 111 | 436 FOR_EACH_BB_FN (bb, cfun) |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
437 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
438 edge_iterator ei; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
439 FOR_EACH_EDGE (e, ei, bb->succs) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
440 if ((e->flags & EDGE_DFS_BACK) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
441 && (e->flags & EDGE_IRREDUCIBLE_LOOP)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
442 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
443 if (dump_file) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
444 fprintf (dump_file, "Marking back edge of irreducible loop %i->%i\n", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
445 e->src->index, e->dest->index); |
| 111 | 446 mark_control_dependent_edges_necessary (e->dest, false); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
447 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
448 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
449 |
| 111 | 450 FOR_EACH_LOOP (loop, 0) |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
451 if (!finite_loop_p (loop)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
452 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
453 if (dump_file) |
| 145 | 454 fprintf (dump_file, "cannot prove finiteness of loop %i\n", loop->num); |
| 111 | 455 mark_control_dependent_edges_necessary (loop->latch, false); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
456 } |
| 0 | 457 } |
| 458 } | |
| 459 | |
| 460 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
461 /* Return true if REF is based on an aliased base, otherwise false. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
462 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
463 static bool |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
464 ref_may_be_aliased (tree ref) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
465 { |
| 111 | 466 gcc_assert (TREE_CODE (ref) != WITH_SIZE_EXPR); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
467 while (handled_component_p (ref)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
468 ref = TREE_OPERAND (ref, 0); |
|
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
|
469 if (TREE_CODE (ref) == MEM_REF |
|
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
|
470 && TREE_CODE (TREE_OPERAND (ref, 0)) == ADDR_EXPR) |
|
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
|
471 ref = TREE_OPERAND (TREE_OPERAND (ref, 0), 0); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
472 return !(DECL_P (ref) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
473 && !may_be_aliased (ref)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
474 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
475 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
476 static bitmap visited = NULL; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
477 static unsigned int longest_chain = 0; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
478 static unsigned int total_chain = 0; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
479 static unsigned int nr_walks = 0; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
480 static bool chain_ovfl = false; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
481 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
482 /* Worker for the walker that marks reaching definitions of REF, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
483 which is based on a non-aliased decl, necessary. It returns |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
484 true whenever the defining statement of the current VDEF is |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
485 a kill for REF, as no dominating may-defs are necessary for REF |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
486 anymore. DATA points to the basic-block that contains the |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
487 stmt that refers to REF. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
488 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
489 static bool |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
490 mark_aliased_reaching_defs_necessary_1 (ao_ref *ref, tree vdef, void *data) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
491 { |
| 111 | 492 gimple *def_stmt = SSA_NAME_DEF_STMT (vdef); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
493 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
494 /* All stmts we visit are necessary. */ |
| 111 | 495 if (! gimple_clobber_p (def_stmt)) |
| 496 mark_operand_necessary (vdef); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
497 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
498 /* If the stmt lhs kills ref, then we can stop walking. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
499 if (gimple_has_lhs (def_stmt) |
| 111 | 500 && TREE_CODE (gimple_get_lhs (def_stmt)) != SSA_NAME |
| 501 /* The assignment is not necessarily carried out if it can throw | |
| 502 and we can catch it in the current function where we could inspect | |
| 503 the previous value. | |
| 504 ??? We only need to care about the RHS throwing. For aggregate | |
| 505 assignments or similar calls and non-call exceptions the LHS | |
| 506 might throw as well. */ | |
| 131 | 507 && !stmt_can_throw_internal (cfun, def_stmt)) |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
508 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
509 tree base, lhs = gimple_get_lhs (def_stmt); |
| 131 | 510 poly_int64 size, offset, max_size; |
| 111 | 511 bool reverse; |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
512 ao_ref_base (ref); |
| 111 | 513 base |
| 514 = get_ref_base_and_extent (lhs, &offset, &size, &max_size, &reverse); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
515 /* We can get MEM[symbol: sZ, index: D.8862_1] here, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
516 so base == refd->base does not always hold. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
517 if (base == ref->base) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
518 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
519 /* For a must-alias check we need to be able to constrain |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
520 the accesses properly. */ |
| 131 | 521 if (known_eq (size, max_size) |
| 522 && known_subrange_p (ref->offset, ref->max_size, offset, size)) | |
| 523 return true; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
524 /* Or they need to be exactly the same. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
525 else if (ref->ref |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
526 /* Make sure there is no induction variable involved |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
527 in the references (gcc.c-torture/execute/pr42142.c). |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
528 The simplest way is to check if the kill dominates |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
529 the use. */ |
| 111 | 530 /* But when both are in the same block we cannot |
| 531 easily tell whether we came from a backedge | |
| 532 unless we decide to compute stmt UIDs | |
| 533 (see PR58246). */ | |
| 534 && (basic_block) data != gimple_bb (def_stmt) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
535 && dominated_by_p (CDI_DOMINATORS, (basic_block) data, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
536 gimple_bb (def_stmt)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
537 && operand_equal_p (ref->ref, lhs, 0)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
538 return true; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
539 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
540 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
541 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
542 /* Otherwise keep walking. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
543 return false; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
544 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
545 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
546 static void |
| 111 | 547 mark_aliased_reaching_defs_necessary (gimple *stmt, tree ref) |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
548 { |
| 145 | 549 /* Should have been caught before calling this function. */ |
| 550 gcc_checking_assert (!keep_all_vdefs_p ()); | |
| 551 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
552 unsigned int chain; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
553 ao_ref refd; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
554 gcc_assert (!chain_ovfl); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
555 ao_ref_init (&refd, ref); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
556 chain = walk_aliased_vdefs (&refd, gimple_vuse (stmt), |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
557 mark_aliased_reaching_defs_necessary_1, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
558 gimple_bb (stmt), NULL); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
559 if (chain > longest_chain) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
560 longest_chain = chain; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
561 total_chain += chain; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
562 nr_walks++; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
563 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
564 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
565 /* Worker for the walker that marks reaching definitions of REF, which |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
566 is not based on a non-aliased decl. For simplicity we need to end |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
567 up marking all may-defs necessary that are not based on a non-aliased |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
568 decl. The only job of this walker is to skip may-defs based on |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
569 a non-aliased decl. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
570 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
571 static bool |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
572 mark_all_reaching_defs_necessary_1 (ao_ref *ref ATTRIBUTE_UNUSED, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
573 tree vdef, void *data ATTRIBUTE_UNUSED) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
574 { |
| 111 | 575 gimple *def_stmt = SSA_NAME_DEF_STMT (vdef); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
576 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
577 /* We have to skip already visited (and thus necessary) statements |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
578 to make the chaining work after we dropped back to simple mode. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
579 if (chain_ovfl |
| 111 | 580 && bitmap_bit_p (processed, SSA_NAME_VERSION (vdef))) |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
581 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
582 gcc_assert (gimple_nop_p (def_stmt) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
583 || gimple_plf (def_stmt, STMT_NECESSARY)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
584 return false; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
585 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
586 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
587 /* We want to skip stores to non-aliased variables. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
588 if (!chain_ovfl |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
589 && gimple_assign_single_p (def_stmt)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
590 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
591 tree lhs = gimple_assign_lhs (def_stmt); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
592 if (!ref_may_be_aliased (lhs)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
593 return false; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
594 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
595 |
| 111 | 596 /* We want to skip statments that do not constitute stores but have |
| 597 a virtual definition. */ | |
| 598 if (is_gimple_call (def_stmt)) | |
| 599 { | |
| 600 tree callee = gimple_call_fndecl (def_stmt); | |
| 601 if (callee != NULL_TREE | |
| 131 | 602 && fndecl_built_in_p (callee, BUILT_IN_NORMAL)) |
| 111 | 603 switch (DECL_FUNCTION_CODE (callee)) |
| 604 { | |
| 605 case BUILT_IN_MALLOC: | |
| 606 case BUILT_IN_ALIGNED_ALLOC: | |
| 607 case BUILT_IN_CALLOC: | |
| 608 CASE_BUILT_IN_ALLOCA: | |
| 609 case BUILT_IN_FREE: | |
| 610 return false; | |
| 611 | |
| 612 default:; | |
| 613 } | |
| 145 | 614 |
| 615 if (callee != NULL_TREE | |
| 616 && (DECL_IS_REPLACEABLE_OPERATOR_NEW_P (callee) | |
| 617 || DECL_IS_OPERATOR_DELETE_P (callee))) | |
| 618 return false; | |
| 111 | 619 } |
| 620 | |
| 621 if (! gimple_clobber_p (def_stmt)) | |
| 622 mark_operand_necessary (vdef); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
623 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
624 return false; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
625 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
626 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
627 static void |
| 111 | 628 mark_all_reaching_defs_necessary (gimple *stmt) |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
629 { |
| 145 | 630 /* Should have been caught before calling this function. */ |
| 631 gcc_checking_assert (!keep_all_vdefs_p ()); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
632 walk_aliased_vdefs (NULL, gimple_vuse (stmt), |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
633 mark_all_reaching_defs_necessary_1, NULL, &visited); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
634 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
635 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
636 /* Return true for PHI nodes with one or identical arguments |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
637 can be removed. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
638 static bool |
| 111 | 639 degenerate_phi_p (gimple *phi) |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
640 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
641 unsigned int i; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
642 tree op = gimple_phi_arg_def (phi, 0); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
643 for (i = 1; i < gimple_phi_num_args (phi); i++) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
644 if (gimple_phi_arg_def (phi, i) != op) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
645 return false; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
646 return true; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
647 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
648 |
| 0 | 649 /* Propagate necessity using the operands of necessary statements. |
| 650 Process the uses on each statement in the worklist, and add all | |
| 651 feeding statements which contribute to the calculation of this | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
652 value to the worklist. |
| 0 | 653 |
| 654 In conservative mode, EL is NULL. */ | |
| 655 | |
| 656 static void | |
| 111 | 657 propagate_necessity (bool aggressive) |
| 0 | 658 { |
| 111 | 659 gimple *stmt; |
| 0 | 660 |
| 661 if (dump_file && (dump_flags & TDF_DETAILS)) | |
| 662 fprintf (dump_file, "\nProcessing worklist:\n"); | |
| 663 | |
| 111 | 664 while (worklist.length () > 0) |
| 0 | 665 { |
| 666 /* Take STMT from worklist. */ | |
| 111 | 667 stmt = worklist.pop (); |
| 0 | 668 |
| 669 if (dump_file && (dump_flags & TDF_DETAILS)) | |
| 670 { | |
| 671 fprintf (dump_file, "processing: "); | |
| 672 print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM); | |
| 673 fprintf (dump_file, "\n"); | |
| 674 } | |
| 675 | |
| 676 if (aggressive) | |
| 677 { | |
|
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 /* Mark the last statement of the basic blocks on which the block |
|
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
|
679 containing STMT is control dependent, but only if we haven't |
| 0 | 680 already done so. */ |
| 681 basic_block bb = gimple_bb (stmt); | |
| 111 | 682 if (bb != ENTRY_BLOCK_PTR_FOR_FN (cfun) |
| 683 && !bitmap_bit_p (visited_control_parents, bb->index)) | |
| 684 mark_control_dependent_edges_necessary (bb, false); | |
| 0 | 685 } |
| 686 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
687 if (gimple_code (stmt) == GIMPLE_PHI |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
688 /* We do not process virtual PHI nodes nor do we track their |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
689 necessity. */ |
| 111 | 690 && !virtual_operand_p (gimple_phi_result (stmt))) |
| 0 | 691 { |
| 692 /* PHI nodes are somewhat special in that each PHI alternative has | |
| 693 data and control dependencies. All the statements feeding the | |
| 694 PHI node's arguments are always necessary. In aggressive mode, | |
| 695 we also consider the control dependent edges leading to the | |
| 696 predecessor block associated with each PHI alternative as | |
| 697 necessary. */ | |
| 111 | 698 gphi *phi = as_a <gphi *> (stmt); |
| 0 | 699 size_t k; |
| 700 | |
| 701 for (k = 0; k < gimple_phi_num_args (stmt); k++) | |
| 702 { | |
| 703 tree arg = PHI_ARG_DEF (stmt, k); | |
| 704 if (TREE_CODE (arg) == SSA_NAME) | |
| 705 mark_operand_necessary (arg); | |
| 706 } | |
| 707 | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
708 /* For PHI operands it matters from where the control flow arrives |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
709 to the BB. Consider the following example: |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
710 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
711 a=exp1; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
712 b=exp2; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
713 if (test) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
714 ; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
715 else |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
716 ; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
717 c=PHI(a,b) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
718 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
719 We need to mark control dependence of the empty basic blocks, since they |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
720 contains computation of PHI operands. |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
721 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
722 Doing so is too restrictive in the case the predecestor block is in |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
723 the loop. Consider: |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
724 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
725 if (b) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
726 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
727 int i; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
728 for (i = 0; i<1000; ++i) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
729 ; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
730 j = 0; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
731 } |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
732 return j; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
733 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
734 There is PHI for J in the BB containing return statement. |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
735 In this case the control dependence of predecestor block (that is |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
736 within the empty loop) also contains the block determining number |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
737 of iterations of the block that would prevent removing of empty |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
738 loop in this case. |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
739 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
740 This scenario can be avoided by splitting critical edges. |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
741 To save the critical edge splitting pass we identify how the control |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
742 dependence would look like if the edge was split. |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
743 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
744 Consider the modified CFG created from current CFG by splitting |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
745 edge B->C. In the postdominance tree of modified CFG, C' is |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
746 always child of C. There are two cases how chlids of C' can look |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
747 like: |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
748 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
749 1) C' is leaf |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
750 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
751 In this case the only basic block C' is control dependent on is B. |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
752 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
753 2) C' has single child that is B |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
754 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
755 In this case control dependence of C' is same as control |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
756 dependence of B in original CFG except for block B itself. |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
757 (since C' postdominate B in modified CFG) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
758 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
759 Now how to decide what case happens? There are two basic options: |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
760 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
761 a) C postdominate B. Then C immediately postdominate B and |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
762 case 2 happens iff there is no other way from B to C except |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
763 the edge B->C. |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
764 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
765 There is other way from B to C iff there is succesor of B that |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
766 is not postdominated by B. Testing this condition is somewhat |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
767 expensive, because we need to iterate all succesors of B. |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
768 We are safe to assume that this does not happen: we will mark B |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
769 as needed when processing the other path from B to C that is |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
770 conrol dependent on B and marking control dependencies of B |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
771 itself is harmless because they will be processed anyway after |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
772 processing control statement in B. |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
773 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
774 b) C does not postdominate B. Always case 1 happens since there is |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
775 path from C to exit that does not go through B and thus also C'. */ |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
776 |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
777 if (aggressive && !degenerate_phi_p (stmt)) |
| 0 | 778 { |
| 779 for (k = 0; k < gimple_phi_num_args (stmt); k++) | |
| 780 { | |
| 111 | 781 basic_block arg_bb = gimple_phi_arg_edge (phi, k)->src; |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
782 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
783 if (gimple_bb (stmt) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
784 != get_immediate_dominator (CDI_POST_DOMINATORS, arg_bb)) |
| 0 | 785 { |
| 111 | 786 if (!bitmap_bit_p (last_stmt_necessary, arg_bb->index)) |
|
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
|
787 mark_last_stmt_necessary (arg_bb); |
| 0 | 788 } |
| 111 | 789 else if (arg_bb != ENTRY_BLOCK_PTR_FOR_FN (cfun) |
| 790 && !bitmap_bit_p (visited_control_parents, | |
|
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
|
791 arg_bb->index)) |
| 111 | 792 mark_control_dependent_edges_necessary (arg_bb, true); |
| 0 | 793 } |
| 794 } | |
| 795 } | |
| 796 else | |
| 797 { | |
| 798 /* Propagate through the operands. Examine all the USE, VUSE and | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
799 VDEF operands in this statement. Mark all the statements |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
800 which feed this statement's uses as necessary. */ |
| 0 | 801 ssa_op_iter iter; |
| 802 tree use; | |
| 803 | |
| 111 | 804 /* If this is a call to free which is directly fed by an |
| 805 allocation function do not mark that necessary through | |
| 806 processing the argument. */ | |
| 145 | 807 bool is_delete_operator |
| 808 = (is_gimple_call (stmt) | |
| 809 && gimple_call_operator_delete_p (as_a <gcall *> (stmt))); | |
| 810 if (is_delete_operator | |
| 811 || gimple_call_builtin_p (stmt, BUILT_IN_FREE)) | |
| 111 | 812 { |
| 813 tree ptr = gimple_call_arg (stmt, 0); | |
| 814 gimple *def_stmt; | |
| 815 tree def_callee; | |
| 816 /* If the pointer we free is defined by an allocation | |
| 817 function do not add the call to the worklist. */ | |
| 818 if (TREE_CODE (ptr) == SSA_NAME | |
| 819 && is_gimple_call (def_stmt = SSA_NAME_DEF_STMT (ptr)) | |
| 820 && (def_callee = gimple_call_fndecl (def_stmt)) | |
| 145 | 821 && ((DECL_BUILT_IN_CLASS (def_callee) == BUILT_IN_NORMAL |
| 822 && (DECL_FUNCTION_CODE (def_callee) == BUILT_IN_ALIGNED_ALLOC | |
| 823 || DECL_FUNCTION_CODE (def_callee) == BUILT_IN_MALLOC | |
| 824 || DECL_FUNCTION_CODE (def_callee) == BUILT_IN_CALLOC)) | |
| 825 || DECL_IS_REPLACEABLE_OPERATOR_NEW_P (def_callee))) | |
| 826 { | |
| 827 /* Delete operators can have alignment and (or) size as next | |
| 828 arguments. When being a SSA_NAME, they must be marked | |
| 829 as necessary. */ | |
| 830 if (is_delete_operator && gimple_call_num_args (stmt) >= 2) | |
| 831 for (unsigned i = 1; i < gimple_call_num_args (stmt); i++) | |
| 832 { | |
| 833 tree arg = gimple_call_arg (stmt, i); | |
| 834 if (TREE_CODE (arg) == SSA_NAME) | |
| 835 mark_operand_necessary (arg); | |
| 836 } | |
| 837 | |
| 838 continue; | |
| 839 } | |
| 111 | 840 } |
| 841 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
842 FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_USE) |
| 0 | 843 mark_operand_necessary (use); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
844 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
845 use = gimple_vuse (stmt); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
846 if (!use) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
847 continue; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
848 |
| 145 | 849 /* No need to search for vdefs if we intrinsicly keep them all. */ |
| 850 if (keep_all_vdefs_p ()) | |
| 851 continue; | |
| 852 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
853 /* If we dropped to simple mode make all immediately |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
854 reachable definitions necessary. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
855 if (chain_ovfl) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
856 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
857 mark_all_reaching_defs_necessary (stmt); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
858 continue; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
859 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
860 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
861 /* For statements that may load from memory (have a VUSE) we |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
862 have to mark all reaching (may-)definitions as necessary. |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
863 We partition this task into two cases: |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
864 1) explicit loads based on decls that are not aliased |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
865 2) implicit loads (like calls) and explicit loads not |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
866 based on decls that are not aliased (like indirect |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
867 references or loads from globals) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
868 For 1) we mark all reaching may-defs as necessary, stopping |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
869 at dominating kills. For 2) we want to mark all dominating |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
870 references necessary, but non-aliased ones which we handle |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
871 in 1). By keeping a global visited bitmap for references |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
872 we walk for 2) we avoid quadratic behavior for those. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
873 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
874 if (is_gimple_call (stmt)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
875 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
876 tree callee = gimple_call_fndecl (stmt); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
877 unsigned i; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
878 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
879 /* Calls to functions that are merely acting as barriers |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
880 or that only store to memory do not make any previous |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
881 stores necessary. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
882 if (callee != NULL_TREE |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
883 && DECL_BUILT_IN_CLASS (callee) == BUILT_IN_NORMAL |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
884 && (DECL_FUNCTION_CODE (callee) == BUILT_IN_MEMSET |
| 111 | 885 || DECL_FUNCTION_CODE (callee) == BUILT_IN_MEMSET_CHK |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
886 || DECL_FUNCTION_CODE (callee) == BUILT_IN_MALLOC |
| 111 | 887 || DECL_FUNCTION_CODE (callee) == BUILT_IN_ALIGNED_ALLOC |
| 888 || DECL_FUNCTION_CODE (callee) == BUILT_IN_CALLOC | |
| 889 || DECL_FUNCTION_CODE (callee) == BUILT_IN_FREE | |
| 890 || DECL_FUNCTION_CODE (callee) == BUILT_IN_VA_END | |
| 891 || ALLOCA_FUNCTION_CODE_P (DECL_FUNCTION_CODE (callee)) | |
| 892 || DECL_FUNCTION_CODE (callee) == BUILT_IN_STACK_SAVE | |
| 893 || DECL_FUNCTION_CODE (callee) == BUILT_IN_STACK_RESTORE | |
| 894 || DECL_FUNCTION_CODE (callee) == BUILT_IN_ASSUME_ALIGNED)) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
895 continue; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
896 |
| 145 | 897 if (callee != NULL_TREE |
| 898 && (DECL_IS_REPLACEABLE_OPERATOR_NEW_P (callee) | |
| 899 || DECL_IS_OPERATOR_DELETE_P (callee))) | |
| 900 continue; | |
| 901 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
902 /* Calls implicitly load from memory, their arguments |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
903 in addition may explicitly perform memory loads. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
904 mark_all_reaching_defs_necessary (stmt); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
905 for (i = 0; i < gimple_call_num_args (stmt); ++i) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
906 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
907 tree arg = gimple_call_arg (stmt, i); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
908 if (TREE_CODE (arg) == SSA_NAME |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
909 || is_gimple_min_invariant (arg)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
910 continue; |
| 111 | 911 if (TREE_CODE (arg) == WITH_SIZE_EXPR) |
| 912 arg = TREE_OPERAND (arg, 0); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
913 if (!ref_may_be_aliased (arg)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
914 mark_aliased_reaching_defs_necessary (stmt, arg); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
915 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
916 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
917 else if (gimple_assign_single_p (stmt)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
918 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
919 tree rhs; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
920 /* If this is a load mark things necessary. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
921 rhs = gimple_assign_rhs1 (stmt); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
922 if (TREE_CODE (rhs) != SSA_NAME |
| 111 | 923 && !is_gimple_min_invariant (rhs) |
| 924 && TREE_CODE (rhs) != CONSTRUCTOR) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
925 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
926 if (!ref_may_be_aliased (rhs)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
927 mark_aliased_reaching_defs_necessary (stmt, rhs); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
928 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
929 mark_all_reaching_defs_necessary (stmt); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
930 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
931 } |
| 111 | 932 else if (greturn *return_stmt = dyn_cast <greturn *> (stmt)) |
| 933 { | |
| 934 tree rhs = gimple_return_retval (return_stmt); | |
| 935 /* A return statement may perform a load. */ | |
| 936 if (rhs | |
| 937 && TREE_CODE (rhs) != SSA_NAME | |
| 938 && !is_gimple_min_invariant (rhs) | |
| 939 && TREE_CODE (rhs) != CONSTRUCTOR) | |
| 940 { | |
| 941 if (!ref_may_be_aliased (rhs)) | |
| 942 mark_aliased_reaching_defs_necessary (stmt, rhs); | |
| 943 else | |
| 944 mark_all_reaching_defs_necessary (stmt); | |
| 945 } | |
| 946 } | |
| 947 else if (gasm *asm_stmt = dyn_cast <gasm *> (stmt)) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
948 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
949 unsigned i; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
950 mark_all_reaching_defs_necessary (stmt); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
951 /* Inputs may perform loads. */ |
| 111 | 952 for (i = 0; i < gimple_asm_ninputs (asm_stmt); ++i) |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
953 { |
| 111 | 954 tree op = TREE_VALUE (gimple_asm_input_op (asm_stmt, i)); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
955 if (TREE_CODE (op) != SSA_NAME |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
956 && !is_gimple_min_invariant (op) |
| 111 | 957 && TREE_CODE (op) != CONSTRUCTOR |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
958 && !ref_may_be_aliased (op)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
959 mark_aliased_reaching_defs_necessary (stmt, op); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
960 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
961 } |
| 111 | 962 else if (gimple_code (stmt) == GIMPLE_TRANSACTION) |
| 963 { | |
| 964 /* The beginning of a transaction is a memory barrier. */ | |
| 965 /* ??? If we were really cool, we'd only be a barrier | |
| 966 for the memories touched within the transaction. */ | |
| 967 mark_all_reaching_defs_necessary (stmt); | |
| 968 } | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
969 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
970 gcc_unreachable (); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
971 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
972 /* If we over-used our alias oracle budget drop to simple |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
973 mode. The cost metric allows quadratic behavior |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
974 (number of uses times number of may-defs queries) up to |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
975 a constant maximal number of queries and after that falls back to |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
976 super-linear complexity. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
977 if (/* Constant but quadratic for small functions. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
978 total_chain > 128 * 128 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
979 /* Linear in the number of may-defs. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
980 && total_chain > 32 * longest_chain |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
981 /* Linear in the number of uses. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
982 && total_chain > nr_walks * 32) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
983 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
984 chain_ovfl = true; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
985 if (visited) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
986 bitmap_clear (visited); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
987 } |
| 0 | 988 } |
| 989 } | |
| 990 } | |
| 991 | |
| 992 /* Remove dead PHI nodes from block BB. */ | |
| 993 | |
| 994 static bool | |
| 995 remove_dead_phis (basic_block bb) | |
| 996 { | |
| 997 bool something_changed = false; | |
| 111 | 998 gphi *phi; |
| 999 gphi_iterator gsi; | |
| 0 | 1000 |
| 111 | 1001 for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi);) |
| 0 | 1002 { |
| 1003 stats.total_phis++; | |
| 111 | 1004 phi = gsi.phi (); |
| 0 | 1005 |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1006 /* We do not track necessity of virtual PHI nodes. Instead do |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1007 very simple dead PHI removal here. */ |
| 111 | 1008 if (virtual_operand_p (gimple_phi_result (phi))) |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1009 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1010 /* Virtual PHI nodes with one or identical arguments |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1011 can be removed. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1012 if (degenerate_phi_p (phi)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1013 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1014 tree vdef = gimple_phi_result (phi); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1015 tree vuse = gimple_phi_arg_def (phi, 0); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1016 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1017 use_operand_p use_p; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1018 imm_use_iterator iter; |
| 111 | 1019 gimple *use_stmt; |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1020 FOR_EACH_IMM_USE_STMT (use_stmt, iter, vdef) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1021 FOR_EACH_IMM_USE_ON_STMT (use_p, iter) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1022 SET_USE (use_p, vuse); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1023 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (vdef) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1024 && TREE_CODE (vuse) == SSA_NAME) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1025 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (vuse) = 1; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1026 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1027 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1028 gimple_set_plf (phi, STMT_NECESSARY, true); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1029 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1030 |
| 0 | 1031 if (!gimple_plf (phi, STMT_NECESSARY)) |
| 1032 { | |
| 1033 something_changed = true; | |
| 1034 if (dump_file && (dump_flags & TDF_DETAILS)) | |
| 1035 { | |
| 1036 fprintf (dump_file, "Deleting : "); | |
| 1037 print_gimple_stmt (dump_file, phi, 0, TDF_SLIM); | |
| 1038 fprintf (dump_file, "\n"); | |
| 1039 } | |
| 1040 | |
| 1041 remove_phi_node (&gsi, true); | |
| 1042 stats.removed_phis++; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1043 continue; |
| 0 | 1044 } |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1045 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1046 gsi_next (&gsi); |
| 0 | 1047 } |
| 1048 return something_changed; | |
| 1049 } | |
| 1050 | |
| 1051 | |
| 1052 /* Remove dead statement pointed to by iterator I. Receives the basic block BB | |
| 1053 containing I so that we don't have to look it up. */ | |
| 1054 | |
| 1055 static void | |
| 145 | 1056 remove_dead_stmt (gimple_stmt_iterator *i, basic_block bb, |
| 1057 vec<edge> &to_remove_edges) | |
| 0 | 1058 { |
| 111 | 1059 gimple *stmt = gsi_stmt (*i); |
| 0 | 1060 |
| 1061 if (dump_file && (dump_flags & TDF_DETAILS)) | |
| 1062 { | |
| 1063 fprintf (dump_file, "Deleting : "); | |
| 1064 print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM); | |
| 1065 fprintf (dump_file, "\n"); | |
| 1066 } | |
| 1067 | |
| 1068 stats.removed++; | |
| 1069 | |
| 1070 /* If we have determined that a conditional branch statement contributes | |
| 111 | 1071 nothing to the program, then we not only remove it, but we need to update |
| 1072 the CFG. We can chose any of edges out of BB as long as we are sure to not | |
| 1073 close infinite loops. This is done by always choosing the edge closer to | |
| 1074 exit in inverted_post_order_compute order. */ | |
| 0 | 1075 if (is_ctrl_stmt (stmt)) |
| 1076 { | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1077 edge_iterator ei; |
| 111 | 1078 edge e = NULL, e2; |
| 0 | 1079 |
| 111 | 1080 /* See if there is only one non-abnormal edge. */ |
| 1081 if (single_succ_p (bb)) | |
| 1082 e = single_succ_edge (bb); | |
| 1083 /* Otherwise chose one that is closer to bb with live statement in it. | |
| 1084 To be able to chose one, we compute inverted post order starting from | |
| 1085 all BBs with live statements. */ | |
| 1086 if (!e) | |
| 1087 { | |
| 1088 if (!bb_postorder) | |
| 1089 { | |
| 1090 auto_vec<int, 20> postorder; | |
| 1091 inverted_post_order_compute (&postorder, | |
| 1092 &bb_contains_live_stmts); | |
| 1093 bb_postorder = XNEWVEC (int, last_basic_block_for_fn (cfun)); | |
| 1094 for (unsigned int i = 0; i < postorder.length (); ++i) | |
| 1095 bb_postorder[postorder[i]] = i; | |
| 1096 } | |
| 1097 FOR_EACH_EDGE (e2, ei, bb->succs) | |
| 1098 if (!e || e2->dest == EXIT_BLOCK_PTR_FOR_FN (cfun) | |
| 1099 || bb_postorder [e->dest->index] | |
| 1100 < bb_postorder [e2->dest->index]) | |
| 1101 e = e2; | |
| 1102 } | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1103 gcc_assert (e); |
| 111 | 1104 e->probability = profile_probability::always (); |
| 0 | 1105 |
| 1106 /* The edge is no longer associated with a conditional, so it does | |
| 111 | 1107 not have TRUE/FALSE flags. |
| 1108 We are also safe to drop EH/ABNORMAL flags and turn them into | |
| 1109 normal control flow, because we know that all the destinations (including | |
| 1110 those odd edges) are equivalent for program execution. */ | |
| 1111 e->flags &= ~(EDGE_TRUE_VALUE | EDGE_FALSE_VALUE | EDGE_EH | EDGE_ABNORMAL); | |
| 0 | 1112 |
| 1113 /* The lone outgoing edge from BB will be a fallthru edge. */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1114 e->flags |= EDGE_FALLTHRU; |
| 0 | 1115 |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1116 /* Remove the remaining outgoing edges. */ |
| 145 | 1117 FOR_EACH_EDGE (e2, ei, bb->succs) |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1118 if (e != e2) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1119 { |
| 111 | 1120 /* If we made a BB unconditionally exit a loop or removed |
| 1121 an entry into an irreducible region, then this transform | |
| 1122 alters the set of BBs in the loop. Schedule a fixup. */ | |
| 1123 if (loop_exit_edge_p (bb->loop_father, e) | |
| 1124 || (e2->dest->flags & BB_IRREDUCIBLE_LOOP)) | |
| 1125 loops_state_set (LOOPS_NEED_FIXUP); | |
| 145 | 1126 to_remove_edges.safe_push (e2); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1127 } |
| 0 | 1128 } |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1129 |
| 111 | 1130 /* If this is a store into a variable that is being optimized away, |
| 1131 add a debug bind stmt if possible. */ | |
| 131 | 1132 if (MAY_HAVE_DEBUG_BIND_STMTS |
| 111 | 1133 && gimple_assign_single_p (stmt) |
| 1134 && is_gimple_val (gimple_assign_rhs1 (stmt))) | |
| 1135 { | |
| 1136 tree lhs = gimple_assign_lhs (stmt); | |
| 1137 if ((VAR_P (lhs) || TREE_CODE (lhs) == PARM_DECL) | |
| 1138 && !DECL_IGNORED_P (lhs) | |
| 1139 && is_gimple_reg_type (TREE_TYPE (lhs)) | |
| 1140 && !is_global_var (lhs) | |
| 1141 && !DECL_HAS_VALUE_EXPR_P (lhs)) | |
| 1142 { | |
| 1143 tree rhs = gimple_assign_rhs1 (stmt); | |
| 1144 gdebug *note | |
| 1145 = gimple_build_debug_bind (lhs, unshare_expr (rhs), stmt); | |
| 1146 gsi_insert_after (i, note, GSI_SAME_STMT); | |
| 1147 } | |
| 1148 } | |
| 1149 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1150 unlink_stmt_vdef (stmt); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1151 gsi_remove (i, true); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1152 release_defs (stmt); |
| 0 | 1153 } |
| 1154 | |
| 111 | 1155 /* Helper for maybe_optimize_arith_overflow. Find in *TP if there are any |
| 1156 uses of data (SSA_NAME) other than REALPART_EXPR referencing it. */ | |
| 1157 | |
| 1158 static tree | |
| 1159 find_non_realpart_uses (tree *tp, int *walk_subtrees, void *data) | |
| 1160 { | |
| 1161 if (TYPE_P (*tp) || TREE_CODE (*tp) == REALPART_EXPR) | |
| 1162 *walk_subtrees = 0; | |
| 1163 if (*tp == (tree) data) | |
| 1164 return *tp; | |
| 1165 return NULL_TREE; | |
| 1166 } | |
| 1167 | |
| 1168 /* If the IMAGPART_EXPR of the {ADD,SUB,MUL}_OVERFLOW result is never used, | |
| 1169 but REALPART_EXPR is, optimize the {ADD,SUB,MUL}_OVERFLOW internal calls | |
| 1170 into plain unsigned {PLUS,MINUS,MULT}_EXPR, and if needed reset debug | |
| 1171 uses. */ | |
| 1172 | |
| 1173 static void | |
| 1174 maybe_optimize_arith_overflow (gimple_stmt_iterator *gsi, | |
| 1175 enum tree_code subcode) | |
| 1176 { | |
| 1177 gimple *stmt = gsi_stmt (*gsi); | |
| 1178 tree lhs = gimple_call_lhs (stmt); | |
| 1179 | |
| 1180 if (lhs == NULL || TREE_CODE (lhs) != SSA_NAME) | |
| 1181 return; | |
| 1182 | |
| 1183 imm_use_iterator imm_iter; | |
| 1184 use_operand_p use_p; | |
| 1185 bool has_debug_uses = false; | |
| 1186 bool has_realpart_uses = false; | |
| 1187 bool has_other_uses = false; | |
| 1188 FOR_EACH_IMM_USE_FAST (use_p, imm_iter, lhs) | |
| 1189 { | |
| 1190 gimple *use_stmt = USE_STMT (use_p); | |
| 1191 if (is_gimple_debug (use_stmt)) | |
| 1192 has_debug_uses = true; | |
| 1193 else if (is_gimple_assign (use_stmt) | |
| 1194 && gimple_assign_rhs_code (use_stmt) == REALPART_EXPR | |
| 1195 && TREE_OPERAND (gimple_assign_rhs1 (use_stmt), 0) == lhs) | |
| 1196 has_realpart_uses = true; | |
| 1197 else | |
| 1198 { | |
| 1199 has_other_uses = true; | |
| 1200 break; | |
| 1201 } | |
| 1202 } | |
| 1203 | |
| 1204 if (!has_realpart_uses || has_other_uses) | |
| 1205 return; | |
| 1206 | |
| 1207 tree arg0 = gimple_call_arg (stmt, 0); | |
| 1208 tree arg1 = gimple_call_arg (stmt, 1); | |
| 1209 location_t loc = gimple_location (stmt); | |
| 1210 tree type = TREE_TYPE (TREE_TYPE (lhs)); | |
| 1211 tree utype = type; | |
| 1212 if (!TYPE_UNSIGNED (type)) | |
| 1213 utype = build_nonstandard_integer_type (TYPE_PRECISION (type), 1); | |
| 1214 tree result = fold_build2_loc (loc, subcode, utype, | |
| 1215 fold_convert_loc (loc, utype, arg0), | |
| 1216 fold_convert_loc (loc, utype, arg1)); | |
| 1217 result = fold_convert_loc (loc, type, result); | |
| 1218 | |
| 1219 if (has_debug_uses) | |
| 1220 { | |
| 1221 gimple *use_stmt; | |
| 1222 FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, lhs) | |
| 1223 { | |
| 1224 if (!gimple_debug_bind_p (use_stmt)) | |
| 1225 continue; | |
| 1226 tree v = gimple_debug_bind_get_value (use_stmt); | |
| 1227 if (walk_tree (&v, find_non_realpart_uses, lhs, NULL)) | |
| 1228 { | |
| 1229 gimple_debug_bind_reset_value (use_stmt); | |
| 1230 update_stmt (use_stmt); | |
| 1231 } | |
| 1232 } | |
| 1233 } | |
| 1234 | |
| 1235 if (TREE_CODE (result) == INTEGER_CST && TREE_OVERFLOW (result)) | |
| 1236 result = drop_tree_overflow (result); | |
| 1237 tree overflow = build_zero_cst (type); | |
| 1238 tree ctype = build_complex_type (type); | |
| 1239 if (TREE_CODE (result) == INTEGER_CST) | |
| 1240 result = build_complex (ctype, result, overflow); | |
| 1241 else | |
| 1242 result = build2_loc (gimple_location (stmt), COMPLEX_EXPR, | |
| 1243 ctype, result, overflow); | |
| 1244 | |
| 1245 if (dump_file && (dump_flags & TDF_DETAILS)) | |
| 1246 { | |
| 1247 fprintf (dump_file, "Transforming call: "); | |
| 1248 print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM); | |
| 1249 fprintf (dump_file, "because the overflow result is never used into: "); | |
| 1250 print_generic_stmt (dump_file, result, TDF_SLIM); | |
| 1251 fprintf (dump_file, "\n"); | |
| 1252 } | |
| 1253 | |
| 1254 if (!update_call_from_tree (gsi, result)) | |
| 1255 gimplify_and_update_call_from_tree (gsi, result); | |
| 1256 } | |
| 1257 | |
| 0 | 1258 /* Eliminate unnecessary statements. Any instruction not marked as necessary |
| 1259 contributes nothing to the program, and can be deleted. */ | |
| 1260 | |
| 1261 static bool | |
| 1262 eliminate_unnecessary_stmts (void) | |
| 1263 { | |
| 1264 bool something_changed = false; | |
| 1265 basic_block bb; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1266 gimple_stmt_iterator gsi, psi; |
| 111 | 1267 gimple *stmt; |
| 0 | 1268 tree call; |
| 111 | 1269 vec<basic_block> h; |
| 145 | 1270 auto_vec<edge> to_remove_edges; |
| 0 | 1271 |
| 1272 if (dump_file && (dump_flags & TDF_DETAILS)) | |
| 1273 fprintf (dump_file, "\nEliminating unnecessary statements:\n"); | |
| 1274 | |
| 1275 clear_special_calls (); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1276 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1277 /* Walking basic blocks and statements in reverse order avoids |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1278 releasing SSA names before any other DEFs that refer to them are |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1279 released. This helps avoid loss of debug information, as we get |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1280 a chance to propagate all RHSs of removed SSAs into debug uses, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1281 rather than only the latest ones. E.g., consider: |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1282 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1283 x_3 = y_1 + z_2; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1284 a_5 = x_3 - b_4; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1285 # DEBUG a => a_5 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1286 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1287 If we were to release x_3 before a_5, when we reached a_5 and |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1288 tried to substitute it into the debug stmt, we'd see x_3 there, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1289 but x_3's DEF, type, etc would have already been disconnected. |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1290 By going backwards, the debug stmt first changes to: |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1291 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1292 # DEBUG a => x_3 - b_4 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1293 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1294 and then to: |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1295 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1296 # DEBUG a => y_1 + z_2 - b_4 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1297 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1298 as desired. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1299 gcc_assert (dom_info_available_p (CDI_DOMINATORS)); |
| 111 | 1300 h = get_all_dominated_blocks (CDI_DOMINATORS, |
| 1301 single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun))); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1302 |
| 111 | 1303 while (h.length ()) |
| 0 | 1304 { |
| 111 | 1305 bb = h.pop (); |
| 0 | 1306 |
| 1307 /* Remove dead statements. */ | |
| 145 | 1308 auto_bitmap debug_seen; |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1309 for (gsi = gsi_last_bb (bb); !gsi_end_p (gsi); gsi = psi) |
| 0 | 1310 { |
| 1311 stmt = gsi_stmt (gsi); | |
| 1312 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1313 psi = gsi; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1314 gsi_prev (&psi); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1315 |
| 0 | 1316 stats.total++; |
| 1317 | |
| 111 | 1318 /* We can mark a call to free as not necessary if the |
| 1319 defining statement of its argument is not necessary | |
| 1320 (and thus is getting removed). */ | |
| 1321 if (gimple_plf (stmt, STMT_NECESSARY) | |
| 145 | 1322 && (gimple_call_builtin_p (stmt, BUILT_IN_FREE) |
| 1323 || (is_gimple_call (stmt) | |
| 1324 && gimple_call_operator_delete_p (as_a <gcall *> (stmt))))) | |
| 111 | 1325 { |
| 1326 tree ptr = gimple_call_arg (stmt, 0); | |
| 1327 if (TREE_CODE (ptr) == SSA_NAME) | |
| 1328 { | |
| 1329 gimple *def_stmt = SSA_NAME_DEF_STMT (ptr); | |
| 1330 if (!gimple_nop_p (def_stmt) | |
| 1331 && !gimple_plf (def_stmt, STMT_NECESSARY)) | |
| 1332 gimple_set_plf (stmt, STMT_NECESSARY, false); | |
| 1333 } | |
| 1334 } | |
| 1335 | |
| 0 | 1336 /* If GSI is not necessary then remove it. */ |
| 1337 if (!gimple_plf (stmt, STMT_NECESSARY)) | |
| 1338 { | |
| 111 | 1339 /* Keep clobbers that we can keep live live. */ |
| 1340 if (gimple_clobber_p (stmt)) | |
| 1341 { | |
| 1342 ssa_op_iter iter; | |
| 1343 use_operand_p use_p; | |
| 1344 bool dead = false; | |
| 1345 FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE) | |
| 1346 { | |
| 1347 tree name = USE_FROM_PTR (use_p); | |
| 1348 if (!SSA_NAME_IS_DEFAULT_DEF (name) | |
| 1349 && !bitmap_bit_p (processed, SSA_NAME_VERSION (name))) | |
| 1350 { | |
| 1351 dead = true; | |
| 1352 break; | |
| 1353 } | |
| 1354 } | |
| 1355 if (!dead) | |
| 145 | 1356 { |
| 1357 bitmap_clear (debug_seen); | |
| 1358 continue; | |
| 1359 } | |
| 111 | 1360 } |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1361 if (!is_gimple_debug (stmt)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1362 something_changed = true; |
| 145 | 1363 remove_dead_stmt (&gsi, bb, to_remove_edges); |
| 1364 continue; | |
| 0 | 1365 } |
| 1366 else if (is_gimple_call (stmt)) | |
| 1367 { | |
| 111 | 1368 tree name = gimple_call_lhs (stmt); |
| 1369 | |
| 1370 notice_special_calls (as_a <gcall *> (stmt)); | |
| 0 | 1371 |
| 111 | 1372 /* When LHS of var = call (); is dead, simplify it into |
| 1373 call (); saving one operand. */ | |
| 1374 if (name | |
| 1375 && TREE_CODE (name) == SSA_NAME | |
| 1376 && !bitmap_bit_p (processed, SSA_NAME_VERSION (name)) | |
| 1377 /* Avoid doing so for allocation calls which we | |
| 1378 did not mark as necessary, it will confuse the | |
| 1379 special logic we apply to malloc/free pair removal. */ | |
| 1380 && (!(call = gimple_call_fndecl (stmt)) | |
| 145 | 1381 || ((DECL_BUILT_IN_CLASS (call) != BUILT_IN_NORMAL |
| 1382 || (DECL_FUNCTION_CODE (call) != BUILT_IN_ALIGNED_ALLOC | |
| 1383 && DECL_FUNCTION_CODE (call) != BUILT_IN_MALLOC | |
| 1384 && DECL_FUNCTION_CODE (call) != BUILT_IN_CALLOC | |
| 1385 && !ALLOCA_FUNCTION_CODE_P | |
| 1386 (DECL_FUNCTION_CODE (call)))) | |
| 1387 && !DECL_IS_REPLACEABLE_OPERATOR_NEW_P (call)))) | |
| 111 | 1388 { |
| 1389 something_changed = true; | |
| 1390 if (dump_file && (dump_flags & TDF_DETAILS)) | |
| 0 | 1391 { |
| 111 | 1392 fprintf (dump_file, "Deleting LHS of call: "); |
| 1393 print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM); | |
| 1394 fprintf (dump_file, "\n"); | |
| 1395 } | |
| 1396 | |
| 1397 gimple_call_set_lhs (stmt, NULL_TREE); | |
| 1398 maybe_clean_or_replace_eh_stmt (stmt, stmt); | |
| 1399 update_stmt (stmt); | |
| 1400 release_ssa_name (name); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1401 |
| 145 | 1402 /* GOMP_SIMD_LANE (unless three argument) or ASAN_POISON |
| 1403 without lhs is not needed. */ | |
| 111 | 1404 if (gimple_call_internal_p (stmt)) |
| 1405 switch (gimple_call_internal_fn (stmt)) | |
| 1406 { | |
| 1407 case IFN_GOMP_SIMD_LANE: | |
| 145 | 1408 if (gimple_call_num_args (stmt) >= 3 |
| 1409 && !integer_nonzerop (gimple_call_arg (stmt, 2))) | |
| 1410 break; | |
| 1411 /* FALLTHRU */ | |
| 111 | 1412 case IFN_ASAN_POISON: |
| 145 | 1413 remove_dead_stmt (&gsi, bb, to_remove_edges); |
| 111 | 1414 break; |
| 1415 default: | |
| 1416 break; | |
| 1417 } | |
| 0 | 1418 } |
| 111 | 1419 else if (gimple_call_internal_p (stmt)) |
| 1420 switch (gimple_call_internal_fn (stmt)) | |
| 1421 { | |
| 1422 case IFN_ADD_OVERFLOW: | |
| 1423 maybe_optimize_arith_overflow (&gsi, PLUS_EXPR); | |
| 1424 break; | |
| 1425 case IFN_SUB_OVERFLOW: | |
| 1426 maybe_optimize_arith_overflow (&gsi, MINUS_EXPR); | |
| 1427 break; | |
| 1428 case IFN_MUL_OVERFLOW: | |
| 1429 maybe_optimize_arith_overflow (&gsi, MULT_EXPR); | |
| 1430 break; | |
| 1431 default: | |
| 1432 break; | |
| 1433 } | |
| 0 | 1434 } |
| 145 | 1435 else if (gimple_debug_bind_p (stmt)) |
| 1436 { | |
| 1437 /* We are only keeping the last debug-bind of a | |
| 1438 non-DEBUG_EXPR_DECL variable in a series of | |
| 1439 debug-bind stmts. */ | |
| 1440 tree var = gimple_debug_bind_get_var (stmt); | |
| 1441 if (TREE_CODE (var) != DEBUG_EXPR_DECL | |
| 1442 && !bitmap_set_bit (debug_seen, DECL_UID (var))) | |
| 1443 remove_dead_stmt (&gsi, bb, to_remove_edges); | |
| 1444 continue; | |
| 1445 } | |
| 1446 bitmap_clear (debug_seen); | |
| 0 | 1447 } |
| 145 | 1448 |
| 1449 /* Remove dead PHI nodes. */ | |
| 1450 something_changed |= remove_dead_phis (bb); | |
| 0 | 1451 } |
| 1452 | |
| 111 | 1453 h.release (); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1454 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1455 /* Since we don't track liveness of virtual PHI nodes, it is possible that we |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1456 rendered some PHI nodes unreachable while they are still in use. |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1457 Mark them for renaming. */ |
| 145 | 1458 if (!to_remove_edges.is_empty ()) |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1459 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1460 basic_block prev_bb; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1461 |
| 145 | 1462 /* Remove edges. We've delayed this to not get bogus debug stmts |
| 1463 during PHI node removal. */ | |
| 1464 for (unsigned i = 0; i < to_remove_edges.length (); ++i) | |
| 1465 remove_edge (to_remove_edges[i]); | |
| 1466 cfg_altered = true; | |
| 1467 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1468 find_unreachable_blocks (); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1469 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1470 /* Delete all unreachable basic blocks in reverse dominator order. */ |
| 111 | 1471 for (bb = EXIT_BLOCK_PTR_FOR_FN (cfun)->prev_bb; |
| 1472 bb != ENTRY_BLOCK_PTR_FOR_FN (cfun); bb = prev_bb) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1473 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1474 prev_bb = bb->prev_bb; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1475 |
| 111 | 1476 if (!bitmap_bit_p (bb_contains_live_stmts, bb->index) |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1477 || !(bb->flags & BB_REACHABLE)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1478 { |
| 111 | 1479 for (gphi_iterator gsi = gsi_start_phis (bb); !gsi_end_p (gsi); |
| 1480 gsi_next (&gsi)) | |
| 1481 if (virtual_operand_p (gimple_phi_result (gsi.phi ()))) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1482 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1483 bool found = false; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1484 imm_use_iterator iter; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1485 |
| 111 | 1486 FOR_EACH_IMM_USE_STMT (stmt, iter, |
| 1487 gimple_phi_result (gsi.phi ())) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1488 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1489 if (!(gimple_bb (stmt)->flags & BB_REACHABLE)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1490 continue; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1491 if (gimple_code (stmt) == GIMPLE_PHI |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1492 || gimple_plf (stmt, STMT_NECESSARY)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1493 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1494 found = true; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1495 BREAK_FROM_IMM_USE_STMT (iter); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1496 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1497 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1498 if (found) |
| 111 | 1499 mark_virtual_phi_result_for_renaming (gsi.phi ()); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1500 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1501 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1502 if (!(bb->flags & BB_REACHABLE)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1503 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1504 /* Speed up the removal of blocks that don't |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1505 dominate others. Walking backwards, this should |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1506 be the common case. ??? Do we need to recompute |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1507 dominators because of cfg_altered? */ |
| 131 | 1508 if (!first_dom_son (CDI_DOMINATORS, bb)) |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1509 delete_basic_block (bb); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1510 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1511 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1512 h = get_all_dominated_blocks (CDI_DOMINATORS, bb); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1513 |
| 111 | 1514 while (h.length ()) |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1515 { |
| 111 | 1516 bb = h.pop (); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1517 prev_bb = bb->prev_bb; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1518 /* Rearrangements to the CFG may have failed |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1519 to update the dominators tree, so that |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1520 formerly-dominated blocks are now |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1521 otherwise reachable. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1522 if (!!(bb->flags & BB_REACHABLE)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1523 continue; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1524 delete_basic_block (bb); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1525 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1526 |
| 111 | 1527 h.release (); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1528 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1529 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1530 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1531 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1532 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1533 |
| 111 | 1534 if (bb_postorder) |
| 1535 free (bb_postorder); | |
| 1536 bb_postorder = NULL; | |
| 1537 | |
| 0 | 1538 return something_changed; |
| 1539 } | |
| 1540 | |
| 1541 | |
| 1542 /* Print out removed statement statistics. */ | |
| 1543 | |
| 1544 static void | |
| 1545 print_stats (void) | |
| 1546 { | |
| 1547 float percg; | |
| 1548 | |
| 1549 percg = ((float) stats.removed / (float) stats.total) * 100; | |
| 1550 fprintf (dump_file, "Removed %d of %d statements (%d%%)\n", | |
| 1551 stats.removed, stats.total, (int) percg); | |
| 1552 | |
| 1553 if (stats.total_phis == 0) | |
| 1554 percg = 0; | |
| 1555 else | |
| 1556 percg = ((float) stats.removed_phis / (float) stats.total_phis) * 100; | |
| 1557 | |
| 1558 fprintf (dump_file, "Removed %d of %d PHI nodes (%d%%)\n", | |
| 1559 stats.removed_phis, stats.total_phis, (int) percg); | |
| 1560 } | |
| 1561 | |
| 1562 /* Initialization for this pass. Set up the used data structures. */ | |
| 1563 | |
| 1564 static void | |
| 1565 tree_dce_init (bool aggressive) | |
| 1566 { | |
| 1567 memset ((void *) &stats, 0, sizeof (stats)); | |
| 1568 | |
| 1569 if (aggressive) | |
| 1570 { | |
| 111 | 1571 last_stmt_necessary = sbitmap_alloc (last_basic_block_for_fn (cfun)); |
| 1572 bitmap_clear (last_stmt_necessary); | |
| 1573 bb_contains_live_stmts = sbitmap_alloc (last_basic_block_for_fn (cfun)); | |
| 1574 bitmap_clear (bb_contains_live_stmts); | |
| 0 | 1575 } |
| 1576 | |
| 1577 processed = sbitmap_alloc (num_ssa_names + 1); | |
| 111 | 1578 bitmap_clear (processed); |
| 0 | 1579 |
| 111 | 1580 worklist.create (64); |
| 0 | 1581 cfg_altered = false; |
| 1582 } | |
| 1583 | |
| 1584 /* Cleanup after this pass. */ | |
| 1585 | |
| 1586 static void | |
| 1587 tree_dce_done (bool aggressive) | |
| 1588 { | |
| 1589 if (aggressive) | |
| 1590 { | |
| 111 | 1591 delete cd; |
| 0 | 1592 sbitmap_free (visited_control_parents); |
| 1593 sbitmap_free (last_stmt_necessary); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1594 sbitmap_free (bb_contains_live_stmts); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1595 bb_contains_live_stmts = NULL; |
| 0 | 1596 } |
| 1597 | |
| 1598 sbitmap_free (processed); | |
| 1599 | |
| 111 | 1600 worklist.release (); |
| 0 | 1601 } |
| 1602 | |
| 1603 /* Main routine to eliminate dead code. | |
| 1604 | |
| 1605 AGGRESSIVE controls the aggressiveness of the algorithm. | |
| 1606 In conservative mode, we ignore control dependence and simply declare | |
| 1607 all but the most trivially dead branches necessary. This mode is fast. | |
| 1608 In aggressive mode, control dependences are taken into account, which | |
| 1609 results in more dead code elimination, but at the cost of some time. | |
| 1610 | |
| 1611 FIXME: Aggressive mode before PRE doesn't work currently because | |
| 1612 the dominance info is not invalidated after DCE1. This is | |
| 1613 not an issue right now because we only run aggressive DCE | |
| 1614 as the last tree SSA pass, but keep this in mind when you | |
| 1615 start experimenting with pass ordering. */ | |
| 1616 | |
| 1617 static unsigned int | |
| 1618 perform_tree_ssa_dce (bool aggressive) | |
| 1619 { | |
| 1620 bool something_changed = 0; | |
| 1621 | |
|
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
|
1622 calculate_dominance_info (CDI_DOMINATORS); |
|
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
|
1623 |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1624 /* Preheaders are needed for SCEV to work. |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1625 Simple lateches and recorded exits improve chances that loop will |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1626 proved to be finite in testcases such as in loop-15.c and loop-24.c */ |
| 111 | 1627 bool in_loop_pipeline = scev_initialized_p (); |
| 1628 if (aggressive && ! in_loop_pipeline) | |
| 1629 { | |
| 1630 scev_initialize (); | |
| 1631 loop_optimizer_init (LOOPS_NORMAL | |
| 1632 | LOOPS_HAVE_RECORDED_EXITS); | |
| 1633 } | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1634 |
| 0 | 1635 tree_dce_init (aggressive); |
| 1636 | |
| 1637 if (aggressive) | |
| 1638 { | |
| 1639 /* Compute control dependence. */ | |
| 1640 calculate_dominance_info (CDI_POST_DOMINATORS); | |
| 111 | 1641 cd = new control_dependences (); |
| 0 | 1642 |
| 111 | 1643 visited_control_parents = |
| 1644 sbitmap_alloc (last_basic_block_for_fn (cfun)); | |
| 1645 bitmap_clear (visited_control_parents); | |
| 0 | 1646 |
| 1647 mark_dfs_back_edges (); | |
| 1648 } | |
| 1649 | |
| 111 | 1650 find_obviously_necessary_stmts (aggressive); |
| 0 | 1651 |
| 111 | 1652 if (aggressive && ! in_loop_pipeline) |
| 1653 { | |
| 1654 loop_optimizer_finalize (); | |
| 1655 scev_finalize (); | |
| 1656 } | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1657 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1658 longest_chain = 0; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1659 total_chain = 0; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1660 nr_walks = 0; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1661 chain_ovfl = false; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1662 visited = BITMAP_ALLOC (NULL); |
| 111 | 1663 propagate_necessity (aggressive); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1664 BITMAP_FREE (visited); |
| 0 | 1665 |
| 1666 something_changed |= eliminate_unnecessary_stmts (); | |
| 1667 something_changed |= cfg_altered; | |
| 1668 | |
| 1669 /* We do not update postdominators, so free them unconditionally. */ | |
| 1670 free_dominance_info (CDI_POST_DOMINATORS); | |
| 1671 | |
| 1672 /* If we removed paths in the CFG, then we need to update | |
| 1673 dominators as well. I haven't investigated the possibility | |
| 1674 of incrementally updating dominators. */ | |
| 1675 if (cfg_altered) | |
| 1676 free_dominance_info (CDI_DOMINATORS); | |
| 1677 | |
| 1678 statistics_counter_event (cfun, "Statements deleted", stats.removed); | |
| 1679 statistics_counter_event (cfun, "PHI nodes deleted", stats.removed_phis); | |
| 1680 | |
| 1681 /* Debugging dumps. */ | |
| 1682 if (dump_file && (dump_flags & (TDF_STATS|TDF_DETAILS))) | |
| 1683 print_stats (); | |
| 1684 | |
| 1685 tree_dce_done (aggressive); | |
| 1686 | |
| 1687 if (something_changed) | |
| 111 | 1688 { |
| 1689 free_numbers_of_iterations_estimates (cfun); | |
| 1690 if (in_loop_pipeline) | |
| 1691 scev_reset (); | |
| 1692 return TODO_update_ssa | TODO_cleanup_cfg; | |
| 1693 } | |
| 1694 return 0; | |
| 0 | 1695 } |
| 1696 | |
| 1697 /* Pass entry points. */ | |
| 1698 static unsigned int | |
| 1699 tree_ssa_dce (void) | |
| 1700 { | |
| 1701 return perform_tree_ssa_dce (/*aggressive=*/false); | |
| 1702 } | |
| 1703 | |
| 1704 static unsigned int | |
| 1705 tree_ssa_cd_dce (void) | |
| 1706 { | |
| 1707 return perform_tree_ssa_dce (/*aggressive=*/optimize >= 2); | |
| 1708 } | |
| 1709 | |
| 111 | 1710 namespace { |
| 0 | 1711 |
| 111 | 1712 const pass_data pass_data_dce = |
| 0 | 1713 { |
| 111 | 1714 GIMPLE_PASS, /* type */ |
| 1715 "dce", /* name */ | |
| 1716 OPTGROUP_NONE, /* optinfo_flags */ | |
| 1717 TV_TREE_DCE, /* tv_id */ | |
| 1718 ( PROP_cfg | PROP_ssa ), /* properties_required */ | |
| 1719 0, /* properties_provided */ | |
| 1720 0, /* properties_destroyed */ | |
| 1721 0, /* todo_flags_start */ | |
| 1722 0, /* todo_flags_finish */ | |
| 0 | 1723 }; |
| 1724 | |
| 111 | 1725 class pass_dce : public gimple_opt_pass |
| 0 | 1726 { |
| 111 | 1727 public: |
| 1728 pass_dce (gcc::context *ctxt) | |
| 1729 : gimple_opt_pass (pass_data_dce, ctxt) | |
| 1730 {} | |
| 1731 | |
| 1732 /* opt_pass methods: */ | |
| 1733 opt_pass * clone () { return new pass_dce (m_ctxt); } | |
| 1734 virtual bool gate (function *) { return flag_tree_dce != 0; } | |
| 1735 virtual unsigned int execute (function *) { return tree_ssa_dce (); } | |
| 1736 | |
| 1737 }; // class pass_dce | |
| 1738 | |
| 1739 } // anon namespace | |
| 1740 | |
| 1741 gimple_opt_pass * | |
| 1742 make_pass_dce (gcc::context *ctxt) | |
| 1743 { | |
| 1744 return new pass_dce (ctxt); | |
| 1745 } | |
| 1746 | |
| 1747 namespace { | |
| 1748 | |
| 1749 const pass_data pass_data_cd_dce = | |
| 1750 { | |
| 1751 GIMPLE_PASS, /* type */ | |
| 1752 "cddce", /* name */ | |
| 1753 OPTGROUP_NONE, /* optinfo_flags */ | |
| 1754 TV_TREE_CD_DCE, /* tv_id */ | |
| 1755 ( PROP_cfg | PROP_ssa ), /* properties_required */ | |
| 1756 0, /* properties_provided */ | |
| 1757 0, /* properties_destroyed */ | |
| 1758 0, /* todo_flags_start */ | |
| 1759 0, /* todo_flags_finish */ | |
| 0 | 1760 }; |
| 1761 | |
| 111 | 1762 class pass_cd_dce : public gimple_opt_pass |
| 0 | 1763 { |
| 111 | 1764 public: |
| 1765 pass_cd_dce (gcc::context *ctxt) | |
| 1766 : gimple_opt_pass (pass_data_cd_dce, ctxt) | |
| 1767 {} | |
| 1768 | |
| 1769 /* opt_pass methods: */ | |
| 1770 opt_pass * clone () { return new pass_cd_dce (m_ctxt); } | |
| 1771 virtual bool gate (function *) { return flag_tree_dce != 0; } | |
| 1772 virtual unsigned int execute (function *) { return tree_ssa_cd_dce (); } | |
| 1773 | |
| 1774 }; // class pass_cd_dce | |
| 1775 | |
| 1776 } // anon namespace | |
| 1777 | |
| 1778 gimple_opt_pass * | |
| 1779 make_pass_cd_dce (gcc::context *ctxt) | |
| 1780 { | |
| 1781 return new pass_cd_dce (ctxt); | |
| 1782 } | |
| 131 | 1783 |
| 1784 | |
| 1785 /* A cheap DCE interface. WORKLIST is a list of possibly dead stmts and | |
| 1786 is consumed by this function. The function has linear complexity in | |
| 1787 the number of dead stmts with a constant factor like the average SSA | |
| 1788 use operands number. */ | |
| 1789 | |
| 1790 void | |
| 1791 simple_dce_from_worklist (bitmap worklist) | |
| 1792 { | |
| 1793 while (! bitmap_empty_p (worklist)) | |
| 1794 { | |
| 1795 /* Pop item. */ | |
| 1796 unsigned i = bitmap_first_set_bit (worklist); | |
| 1797 bitmap_clear_bit (worklist, i); | |
| 1798 | |
| 1799 tree def = ssa_name (i); | |
| 1800 /* Removed by somebody else or still in use. */ | |
| 1801 if (! def || ! has_zero_uses (def)) | |
| 1802 continue; | |
| 1803 | |
| 1804 gimple *t = SSA_NAME_DEF_STMT (def); | |
| 1805 if (gimple_has_side_effects (t)) | |
| 1806 continue; | |
| 1807 | |
| 1808 /* Add uses to the worklist. */ | |
| 1809 ssa_op_iter iter; | |
| 1810 use_operand_p use_p; | |
| 1811 FOR_EACH_PHI_OR_STMT_USE (use_p, t, iter, SSA_OP_USE) | |
| 1812 { | |
| 1813 tree use = USE_FROM_PTR (use_p); | |
| 1814 if (TREE_CODE (use) == SSA_NAME | |
| 1815 && ! SSA_NAME_IS_DEFAULT_DEF (use)) | |
| 1816 bitmap_set_bit (worklist, SSA_NAME_VERSION (use)); | |
| 1817 } | |
| 1818 | |
| 1819 /* Remove stmt. */ | |
| 1820 if (dump_file && (dump_flags & TDF_DETAILS)) | |
| 1821 { | |
| 1822 fprintf (dump_file, "Removing dead stmt:"); | |
| 1823 print_gimple_stmt (dump_file, t, 0); | |
| 1824 } | |
| 1825 gimple_stmt_iterator gsi = gsi_for_stmt (t); | |
| 1826 if (gimple_code (t) == GIMPLE_PHI) | |
| 1827 remove_phi_node (&gsi, true); | |
| 1828 else | |
| 1829 { | |
| 1830 gsi_remove (&gsi, true); | |
| 1831 release_defs (t); | |
| 1832 } | |
| 1833 } | |
| 1834 } |