Mercurial > hg > CbC > CbC_gcc
annotate gcc/cfgloop.h @ 81:dbfc0d2dde36
minor fix
| author | Shinji KONO <kono@ie.u-ryukyu.ac.jp> |
|---|---|
| date | Sat, 24 Sep 2011 02:43:04 +0900 |
| parents | f6334be47118 |
| children | 04ced10e8804 |
| rev | line source |
|---|---|
| 0 | 1 /* Natural loop functions |
| 2 Copyright (C) 1987, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, | |
|
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
|
3 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. |
| 0 | 4 |
| 5 This file is part of GCC. | |
| 6 | |
| 7 GCC is free software; you can redistribute it and/or modify it under | |
| 8 the terms of the GNU General Public License as published by the Free | |
| 9 Software Foundation; either version 3, or (at your option) any later | |
| 10 version. | |
| 11 | |
| 12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |
| 13 WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 15 for more details. | |
| 16 | |
| 17 You should have received a copy of the GNU General Public License | |
| 18 along with GCC; see the file COPYING3. If not see | |
| 19 <http://www.gnu.org/licenses/>. */ | |
| 20 | |
| 21 #ifndef GCC_CFGLOOP_H | |
| 22 #define GCC_CFGLOOP_H | |
| 23 | |
| 24 #include "basic-block.h" | |
| 25 /* For rtx_code. */ | |
| 26 #include "rtl.h" | |
| 27 #include "vecprim.h" | |
| 28 #include "double-int.h" | |
| 29 | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
30 #include "bitmap.h" |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
31 #include "sbitmap.h" |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
32 |
| 0 | 33 /* Structure to hold decision about unrolling/peeling. */ |
| 34 enum lpt_dec | |
| 35 { | |
| 36 LPT_NONE, | |
| 37 LPT_PEEL_COMPLETELY, | |
| 38 LPT_PEEL_SIMPLE, | |
| 39 LPT_UNROLL_CONSTANT, | |
| 40 LPT_UNROLL_RUNTIME, | |
| 41 LPT_UNROLL_STUPID | |
| 42 }; | |
| 43 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
44 struct GTY (()) lpt_decision { |
| 0 | 45 enum lpt_dec decision; |
| 46 unsigned times; | |
| 47 }; | |
| 48 | |
| 49 /* The structure describing a bound on number of iterations of a loop. */ | |
| 50 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
51 struct GTY ((chain_next ("%h.next"))) nb_iter_bound { |
| 0 | 52 /* The statement STMT is executed at most ... */ |
| 53 gimple stmt; | |
| 54 | |
| 55 /* ... BOUND + 1 times (BOUND must be an unsigned constant). | |
| 56 The + 1 is added for the following reasons: | |
| 57 | |
| 58 a) 0 would otherwise be unused, while we would need to care more about | |
| 59 overflows (as MAX + 1 is sometimes produced as the estimate on number | |
| 60 of executions of STMT). | |
| 61 b) it is consistent with the result of number_of_iterations_exit. */ | |
| 62 double_int bound; | |
| 63 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
64 /* True if the statement will cause the loop to be leaved the (at most) |
| 0 | 65 BOUND + 1-st time it is executed, that is, all the statements after it |
| 66 are executed at most BOUND times. */ | |
| 67 bool is_exit; | |
| 68 | |
| 69 /* The next bound in the list. */ | |
| 70 struct nb_iter_bound *next; | |
| 71 }; | |
| 72 | |
| 73 /* Description of the loop exit. */ | |
| 74 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
75 struct GTY (()) loop_exit { |
| 0 | 76 /* The exit edge. */ |
| 77 struct edge_def *e; | |
| 78 | |
| 79 /* Previous and next exit in the list of the exits of the loop. */ | |
| 80 struct loop_exit *prev; | |
| 81 struct loop_exit *next; | |
| 82 | |
| 83 /* Next element in the list of loops from that E exits. */ | |
| 84 struct loop_exit *next_e; | |
| 85 }; | |
| 86 | |
| 87 typedef struct loop *loop_p; | |
| 88 DEF_VEC_P (loop_p); | |
| 89 DEF_VEC_ALLOC_P (loop_p, heap); | |
| 90 DEF_VEC_ALLOC_P (loop_p, gc); | |
| 91 | |
| 92 /* An integer estimation of the number of iterations. Estimate_state | |
| 93 describes what is the state of the estimation. */ | |
| 94 enum loop_estimation | |
| 95 { | |
| 96 /* Estimate was not computed yet. */ | |
| 97 EST_NOT_COMPUTED, | |
| 98 /* Estimate is ready. */ | |
| 99 EST_AVAILABLE | |
| 100 }; | |
| 101 | |
| 102 /* Structure to hold information for each natural loop. */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
103 struct GTY ((chain_next ("%h.next"))) loop { |
| 0 | 104 /* Index into loops array. */ |
| 105 int num; | |
| 106 | |
| 107 /* Number of loop insns. */ | |
| 108 unsigned ninsns; | |
| 109 | |
| 110 /* Basic block of loop header. */ | |
| 111 struct basic_block_def *header; | |
| 112 | |
| 113 /* Basic block of loop latch. */ | |
| 114 struct basic_block_def *latch; | |
| 115 | |
| 116 /* For loop unrolling/peeling decision. */ | |
| 117 struct lpt_decision lpt_decision; | |
| 118 | |
| 119 /* Average number of executed insns per iteration. */ | |
| 120 unsigned av_ninsns; | |
| 121 | |
| 122 /* Number of blocks contained within the loop. */ | |
| 123 unsigned num_nodes; | |
| 124 | |
| 125 /* Superloops of the loop, starting with the outermost loop. */ | |
| 126 VEC (loop_p, gc) *superloops; | |
| 127 | |
| 128 /* The first inner (child) loop or NULL if innermost loop. */ | |
| 129 struct loop *inner; | |
| 130 | |
| 131 /* Link to the next (sibling) loop. */ | |
| 132 struct loop *next; | |
| 133 | |
| 134 /* Auxiliary info specific to a pass. */ | |
| 135 PTR GTY ((skip (""))) aux; | |
| 136 | |
|
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
|
137 /* The number of times the latch of the loop is executed. This can be an |
|
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
|
138 INTEGER_CST, or a symbolic expression representing the number of |
|
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
|
139 iterations like "N - 1", or a COND_EXPR containing the runtime |
|
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
|
140 conditions under which the number of iterations is non zero. |
|
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
|
141 |
|
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
|
142 Don't access this field directly: number_of_latch_executions |
|
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
|
143 computes and caches the computed information in this field. */ |
| 0 | 144 tree nb_iterations; |
| 145 | |
| 146 /* An integer guaranteed to bound the number of iterations of the loop | |
| 147 from above. */ | |
| 148 double_int nb_iterations_upper_bound; | |
| 149 | |
| 150 /* An integer giving the expected number of iterations of the loop. */ | |
| 151 double_int nb_iterations_estimate; | |
| 152 | |
| 153 bool any_upper_bound; | |
| 154 bool any_estimate; | |
| 155 | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
156 /* True if the loop can be parallel. */ |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
157 bool can_be_parallel; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
158 |
| 0 | 159 /* An integer estimation of the number of iterations. Estimate_state |
| 160 describes what is the state of the estimation. */ | |
| 161 enum loop_estimation estimate_state; | |
| 162 | |
| 163 /* Upper bound on number of iterations of a loop. */ | |
| 164 struct nb_iter_bound *bounds; | |
| 165 | |
| 166 /* Head of the cyclic list of the exits of the loop. */ | |
| 167 struct loop_exit *exits; | |
| 168 }; | |
| 169 | |
| 170 /* Flags for state of loop structure. */ | |
| 171 enum | |
| 172 { | |
| 173 LOOPS_HAVE_PREHEADERS = 1, | |
| 174 LOOPS_HAVE_SIMPLE_LATCHES = 2, | |
| 175 LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS = 4, | |
| 176 LOOPS_HAVE_RECORDED_EXITS = 8, | |
| 177 LOOPS_MAY_HAVE_MULTIPLE_LATCHES = 16, | |
| 178 LOOP_CLOSED_SSA = 32, | |
| 179 LOOPS_NEED_FIXUP = 64, | |
| 180 LOOPS_HAVE_FALLTHRU_PREHEADERS = 128 | |
| 181 }; | |
| 182 | |
| 183 #define LOOPS_NORMAL (LOOPS_HAVE_PREHEADERS | LOOPS_HAVE_SIMPLE_LATCHES \ | |
| 184 | LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS) | |
| 185 #define AVOID_CFG_MODIFICATIONS (LOOPS_MAY_HAVE_MULTIPLE_LATCHES) | |
| 186 | |
| 187 /* Structure to hold CFG information about natural loops within a function. */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
188 struct GTY (()) loops { |
| 0 | 189 /* State of loops. */ |
| 190 int state; | |
| 191 | |
| 192 /* Array of the loops. */ | |
| 193 VEC (loop_p, gc) *larray; | |
| 194 | |
| 195 /* Maps edges to the list of their descriptions as loop exits. Edges | |
| 196 whose sources or destinations have loop_father == NULL (which may | |
| 197 happen during the cfg manipulations) should not appear in EXITS. */ | |
| 198 htab_t GTY((param_is (struct loop_exit))) exits; | |
| 199 | |
| 200 /* Pointer to root of loop hierarchy tree. */ | |
| 201 struct loop *tree_root; | |
| 202 }; | |
| 203 | |
| 204 /* Loop recognition. */ | |
| 205 extern int flow_loops_find (struct loops *); | |
| 206 extern void disambiguate_loops_with_multiple_latches (void); | |
| 207 extern void flow_loops_free (struct loops *); | |
| 208 extern void flow_loops_dump (FILE *, | |
| 209 void (*)(const struct loop *, FILE *, int), int); | |
| 210 extern void flow_loop_dump (const struct loop *, FILE *, | |
| 211 void (*)(const struct loop *, FILE *, int), int); | |
| 212 struct loop *alloc_loop (void); | |
| 213 extern void flow_loop_free (struct loop *); | |
| 214 int flow_loop_nodes_find (basic_block, struct loop *); | |
| 215 void fix_loop_structure (bitmap changed_bbs); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
216 bool mark_irreducible_loops (void); |
| 0 | 217 void release_recorded_exits (void); |
| 218 void record_loop_exits (void); | |
| 219 void rescan_loop_exit (edge, bool, bool); | |
| 220 | |
| 221 /* Loop data structure manipulation/querying. */ | |
| 222 extern void flow_loop_tree_node_add (struct loop *, struct loop *); | |
| 223 extern void flow_loop_tree_node_remove (struct loop *); | |
| 224 extern void add_loop (struct loop *, struct loop *); | |
| 225 extern bool flow_loop_nested_p (const struct loop *, const struct loop *); | |
| 226 extern bool flow_bb_inside_loop_p (const struct loop *, const_basic_block); | |
| 227 extern struct loop * find_common_loop (struct loop *, struct loop *); | |
| 228 struct loop *superloop_at_depth (struct loop *, unsigned); | |
| 229 struct eni_weights_d; | |
| 230 extern unsigned tree_num_loop_insns (struct loop *, struct eni_weights_d *); | |
| 231 extern int num_loop_insns (const struct loop *); | |
| 232 extern int average_num_loop_insns (const struct loop *); | |
| 233 extern unsigned get_loop_level (const struct loop *); | |
| 234 extern bool loop_exit_edge_p (const struct loop *, const_edge); | |
|
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
|
235 extern bool loop_exits_to_bb_p (struct loop *, basic_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
|
236 extern bool loop_exits_from_bb_p (struct loop *, basic_block); |
| 0 | 237 extern void mark_loop_exit_edges (void); |
| 238 | |
| 239 /* Loops & cfg manipulation. */ | |
| 240 extern basic_block *get_loop_body (const struct loop *); | |
| 241 extern unsigned get_loop_body_with_size (const struct loop *, basic_block *, | |
| 242 unsigned); | |
| 243 extern basic_block *get_loop_body_in_dom_order (const struct loop *); | |
| 244 extern basic_block *get_loop_body_in_bfs_order (const struct loop *); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
245 extern basic_block *get_loop_body_in_custom_order (const struct loop *, |
| 0 | 246 int (*) (const void *, const void *)); |
| 247 | |
| 248 extern VEC (edge, heap) *get_loop_exit_edges (const struct loop *); | |
| 249 edge single_exit (const struct loop *); | |
| 250 extern unsigned num_loop_branches (const struct loop *); | |
| 251 | |
| 252 extern edge loop_preheader_edge (const struct loop *); | |
| 253 extern edge loop_latch_edge (const struct loop *); | |
| 254 | |
| 255 extern void add_bb_to_loop (basic_block, struct loop *); | |
| 256 extern void remove_bb_from_loops (basic_block); | |
| 257 | |
| 258 extern void cancel_loop_tree (struct loop *); | |
| 259 extern void delete_loop (struct loop *); | |
| 260 | |
| 261 enum | |
| 262 { | |
| 263 CP_SIMPLE_PREHEADERS = 1, | |
| 264 CP_FALLTHRU_PREHEADERS = 2 | |
| 265 }; | |
| 266 | |
| 267 basic_block create_preheader (struct loop *, int); | |
| 268 extern void create_preheaders (int); | |
| 269 extern void force_single_succ_latches (void); | |
| 270 | |
| 271 extern void verify_loop_structure (void); | |
| 272 | |
| 273 /* Loop analysis. */ | |
| 274 extern bool just_once_each_iteration_p (const struct loop *, const_basic_block); | |
| 275 gcov_type expected_loop_iterations_unbounded (const struct loop *); | |
| 276 extern unsigned expected_loop_iterations (const struct loop *); | |
| 277 extern rtx doloop_condition_get (rtx); | |
| 278 | |
|
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
|
279 void estimate_numbers_of_iterations_loop (struct loop *, bool); |
| 0 | 280 HOST_WIDE_INT estimated_loop_iterations_int (struct loop *, bool); |
| 281 bool estimated_loop_iterations (struct loop *, bool, double_int *); | |
| 282 | |
| 283 /* Loop manipulation. */ | |
| 284 extern bool can_duplicate_loop_p (const struct loop *loop); | |
| 285 | |
| 286 #define DLTHE_FLAG_UPDATE_FREQ 1 /* Update frequencies in | |
| 287 duplicate_loop_to_header_edge. */ | |
| 288 #define DLTHE_RECORD_COPY_NUMBER 2 /* Record copy number in the aux | |
| 289 field of newly create BB. */ | |
| 290 #define DLTHE_FLAG_COMPLETTE_PEEL 4 /* Update frequencies expecting | |
| 291 a complete peeling. */ | |
| 292 | |
| 293 extern edge create_empty_if_region_on_edge (edge, tree); | |
| 294 extern struct loop *create_empty_loop_on_edge (edge, tree, tree, tree, tree, | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
295 tree *, tree *, struct loop *); |
| 0 | 296 extern struct loop * duplicate_loop (struct loop *, struct loop *); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
297 extern void duplicate_subloops (struct loop *, struct loop *); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
298 extern bool duplicate_loop_to_header_edge (struct loop *, edge, |
| 0 | 299 unsigned, sbitmap, edge, |
| 300 VEC (edge, heap) **, int); | |
| 301 extern struct loop *loopify (edge, edge, | |
| 302 basic_block, edge, edge, bool, | |
| 303 unsigned, unsigned); | |
| 304 struct loop * loop_version (struct loop *, void *, | |
| 305 basic_block *, unsigned, unsigned, unsigned, bool); | |
| 306 extern bool remove_path (edge); | |
| 307 void scale_loop_frequencies (struct loop *, int, int); | |
| 308 | |
| 309 /* Induction variable analysis. */ | |
| 310 | |
| 311 /* The description of induction variable. The things are a bit complicated | |
| 312 due to need to handle subregs and extends. The value of the object described | |
| 313 by it can be obtained as follows (all computations are done in extend_mode): | |
| 314 | |
| 315 Value in i-th iteration is | |
| 316 delta + mult * extend_{extend_mode} (subreg_{mode} (base + i * step)). | |
| 317 | |
| 318 If first_special is true, the value in the first iteration is | |
| 319 delta + mult * base | |
| 320 | |
| 321 If extend = UNKNOWN, first_special must be false, delta 0, mult 1 and value is | |
| 322 subreg_{mode} (base + i * step) | |
| 323 | |
| 324 The get_iv_value function can be used to obtain these expressions. | |
| 325 | |
| 326 ??? Add a third mode field that would specify the mode in that inner | |
| 327 computation is done, which would enable it to be different from the | |
| 328 outer one? */ | |
| 329 | |
| 330 struct rtx_iv | |
| 331 { | |
| 332 /* Its base and step (mode of base and step is supposed to be extend_mode, | |
| 333 see the description above). */ | |
| 334 rtx base, step; | |
| 335 | |
| 336 /* The type of extend applied to it (SIGN_EXTEND, ZERO_EXTEND or UNKNOWN). */ | |
| 337 enum rtx_code extend; | |
| 338 | |
| 339 /* Operations applied in the extended mode. */ | |
| 340 rtx delta, mult; | |
| 341 | |
| 342 /* The mode it is extended to. */ | |
| 343 enum machine_mode extend_mode; | |
| 344 | |
| 345 /* The mode the variable iterates in. */ | |
| 346 enum machine_mode mode; | |
| 347 | |
| 348 /* Whether the first iteration needs to be handled specially. */ | |
| 349 unsigned first_special : 1; | |
| 350 }; | |
| 351 | |
| 352 /* The description of an exit from the loop and of the number of iterations | |
| 353 till we take the exit. */ | |
| 354 | |
| 355 struct niter_desc | |
| 356 { | |
| 357 /* The edge out of the loop. */ | |
| 358 edge out_edge; | |
| 359 | |
| 360 /* The other edge leading from the condition. */ | |
| 361 edge in_edge; | |
| 362 | |
| 363 /* True if we are able to say anything about number of iterations of the | |
| 364 loop. */ | |
| 365 bool simple_p; | |
| 366 | |
| 367 /* True if the loop iterates the constant number of times. */ | |
| 368 bool const_iter; | |
| 369 | |
| 370 /* Number of iterations if constant. */ | |
| 371 unsigned HOST_WIDEST_INT niter; | |
| 372 | |
| 373 /* Upper bound on the number of iterations. */ | |
| 374 unsigned HOST_WIDEST_INT niter_max; | |
| 375 | |
| 376 /* Assumptions under that the rest of the information is valid. */ | |
| 377 rtx assumptions; | |
| 378 | |
| 379 /* Assumptions under that the loop ends before reaching the latch, | |
| 380 even if value of niter_expr says otherwise. */ | |
| 381 rtx noloop_assumptions; | |
| 382 | |
| 383 /* Condition under that the loop is infinite. */ | |
| 384 rtx infinite; | |
| 385 | |
| 386 /* Whether the comparison is signed. */ | |
| 387 bool signed_p; | |
| 388 | |
| 389 /* The mode in that niter_expr should be computed. */ | |
| 390 enum machine_mode mode; | |
| 391 | |
| 392 /* The number of iterations of the loop. */ | |
| 393 rtx niter_expr; | |
| 394 }; | |
| 395 | |
| 396 extern void iv_analysis_loop_init (struct loop *); | |
| 397 extern bool iv_analyze (rtx, rtx, struct rtx_iv *); | |
| 398 extern bool iv_analyze_result (rtx, rtx, struct rtx_iv *); | |
| 399 extern bool iv_analyze_expr (rtx, rtx, enum machine_mode, struct rtx_iv *); | |
| 400 extern rtx get_iv_value (struct rtx_iv *, rtx); | |
| 401 extern bool biv_p (rtx, rtx); | |
| 402 extern void find_simple_exit (struct loop *, struct niter_desc *); | |
| 403 extern void iv_analysis_done (void); | |
| 404 | |
| 405 extern struct niter_desc *get_simple_loop_desc (struct loop *loop); | |
| 406 extern void free_simple_loop_desc (struct loop *loop); | |
| 407 | |
| 408 static inline struct niter_desc * | |
| 409 simple_loop_desc (struct loop *loop) | |
| 410 { | |
| 411 return (struct niter_desc *) loop->aux; | |
| 412 } | |
| 413 | |
| 414 /* Accessors for the loop structures. */ | |
| 415 | |
| 416 /* Returns the loop with index NUM from current_loops. */ | |
| 417 | |
| 418 static inline struct loop * | |
| 419 get_loop (unsigned num) | |
| 420 { | |
| 421 return VEC_index (loop_p, current_loops->larray, num); | |
| 422 } | |
| 423 | |
| 424 /* Returns the number of superloops of LOOP. */ | |
| 425 | |
| 426 static inline unsigned | |
| 427 loop_depth (const struct loop *loop) | |
| 428 { | |
| 429 return VEC_length (loop_p, loop->superloops); | |
| 430 } | |
| 431 | |
| 432 /* Returns the immediate superloop of LOOP, or NULL if LOOP is the outermost | |
| 433 loop. */ | |
| 434 | |
| 435 static inline struct loop * | |
| 436 loop_outer (const struct loop *loop) | |
| 437 { | |
| 438 unsigned n = VEC_length (loop_p, loop->superloops); | |
| 439 | |
| 440 if (n == 0) | |
| 441 return NULL; | |
| 442 | |
| 443 return VEC_index (loop_p, loop->superloops, n - 1); | |
| 444 } | |
| 445 | |
| 446 /* Returns the list of loops in current_loops. */ | |
| 447 | |
| 448 static inline VEC (loop_p, gc) * | |
| 449 get_loops (void) | |
| 450 { | |
| 451 if (!current_loops) | |
| 452 return NULL; | |
| 453 | |
| 454 return current_loops->larray; | |
| 455 } | |
| 456 | |
| 457 /* Returns the number of loops in current_loops (including the removed | |
| 458 ones and the fake loop that forms the root of the loop tree). */ | |
| 459 | |
| 460 static inline unsigned | |
| 461 number_of_loops (void) | |
| 462 { | |
| 463 if (!current_loops) | |
| 464 return 0; | |
| 465 | |
| 466 return VEC_length (loop_p, current_loops->larray); | |
| 467 } | |
| 468 | |
| 469 /* Returns true if state of the loops satisfies all properties | |
| 470 described by FLAGS. */ | |
| 471 | |
| 472 static inline bool | |
| 473 loops_state_satisfies_p (unsigned flags) | |
| 474 { | |
| 475 return (current_loops->state & flags) == flags; | |
| 476 } | |
| 477 | |
| 478 /* Sets FLAGS to the loops state. */ | |
| 479 | |
| 480 static inline void | |
| 481 loops_state_set (unsigned flags) | |
| 482 { | |
| 483 current_loops->state |= flags; | |
| 484 } | |
| 485 | |
| 486 /* Clears FLAGS from the loops state. */ | |
| 487 | |
| 488 static inline void | |
| 489 loops_state_clear (unsigned flags) | |
| 490 { | |
| 491 if (!current_loops) | |
| 492 return; | |
| 493 current_loops->state &= ~flags; | |
| 494 } | |
| 495 | |
| 496 /* Loop iterators. */ | |
| 497 | |
| 498 /* Flags for loop iteration. */ | |
| 499 | |
| 500 enum li_flags | |
| 501 { | |
| 502 LI_INCLUDE_ROOT = 1, /* Include the fake root of the loop tree. */ | |
| 503 LI_FROM_INNERMOST = 2, /* Iterate over the loops in the reverse order, | |
| 504 starting from innermost ones. */ | |
| 505 LI_ONLY_INNERMOST = 4 /* Iterate only over innermost loops. */ | |
| 506 }; | |
| 507 | |
| 508 /* The iterator for loops. */ | |
| 509 | |
| 510 typedef struct | |
| 511 { | |
| 512 /* The list of loops to visit. */ | |
| 513 VEC(int,heap) *to_visit; | |
| 514 | |
| 515 /* The index of the actual loop. */ | |
| 516 unsigned idx; | |
| 517 } loop_iterator; | |
| 518 | |
| 519 static inline void | |
| 520 fel_next (loop_iterator *li, loop_p *loop) | |
| 521 { | |
| 522 int anum; | |
| 523 | |
| 524 while (VEC_iterate (int, li->to_visit, li->idx, anum)) | |
| 525 { | |
| 526 li->idx++; | |
| 527 *loop = get_loop (anum); | |
| 528 if (*loop) | |
| 529 return; | |
| 530 } | |
| 531 | |
| 532 VEC_free (int, heap, li->to_visit); | |
| 533 *loop = NULL; | |
| 534 } | |
| 535 | |
| 536 static inline void | |
| 537 fel_init (loop_iterator *li, loop_p *loop, unsigned flags) | |
| 538 { | |
| 539 struct loop *aloop; | |
| 540 unsigned i; | |
| 541 int mn; | |
| 542 | |
| 543 li->idx = 0; | |
| 544 if (!current_loops) | |
| 545 { | |
| 546 li->to_visit = NULL; | |
| 547 *loop = NULL; | |
| 548 return; | |
| 549 } | |
| 550 | |
| 551 li->to_visit = VEC_alloc (int, heap, number_of_loops ()); | |
| 552 mn = (flags & LI_INCLUDE_ROOT) ? 0 : 1; | |
| 553 | |
| 554 if (flags & LI_ONLY_INNERMOST) | |
| 555 { | |
| 556 for (i = 0; VEC_iterate (loop_p, current_loops->larray, i, aloop); i++) | |
| 557 if (aloop != NULL | |
| 558 && aloop->inner == NULL | |
| 559 && aloop->num >= mn) | |
| 560 VEC_quick_push (int, li->to_visit, aloop->num); | |
| 561 } | |
| 562 else if (flags & LI_FROM_INNERMOST) | |
| 563 { | |
| 564 /* Push the loops to LI->TO_VISIT in postorder. */ | |
| 565 for (aloop = current_loops->tree_root; | |
| 566 aloop->inner != NULL; | |
| 567 aloop = aloop->inner) | |
| 568 continue; | |
| 569 | |
| 570 while (1) | |
| 571 { | |
| 572 if (aloop->num >= mn) | |
| 573 VEC_quick_push (int, li->to_visit, aloop->num); | |
| 574 | |
| 575 if (aloop->next) | |
| 576 { | |
| 577 for (aloop = aloop->next; | |
| 578 aloop->inner != NULL; | |
| 579 aloop = aloop->inner) | |
| 580 continue; | |
| 581 } | |
| 582 else if (!loop_outer (aloop)) | |
| 583 break; | |
| 584 else | |
| 585 aloop = loop_outer (aloop); | |
| 586 } | |
| 587 } | |
| 588 else | |
| 589 { | |
| 590 /* Push the loops to LI->TO_VISIT in preorder. */ | |
| 591 aloop = current_loops->tree_root; | |
| 592 while (1) | |
| 593 { | |
| 594 if (aloop->num >= mn) | |
| 595 VEC_quick_push (int, li->to_visit, aloop->num); | |
| 596 | |
| 597 if (aloop->inner != NULL) | |
| 598 aloop = aloop->inner; | |
| 599 else | |
| 600 { | |
| 601 while (aloop != NULL && aloop->next == NULL) | |
| 602 aloop = loop_outer (aloop); | |
| 603 if (aloop == NULL) | |
| 604 break; | |
| 605 aloop = aloop->next; | |
| 606 } | |
| 607 } | |
| 608 } | |
| 609 | |
| 610 fel_next (li, loop); | |
| 611 } | |
| 612 | |
| 613 #define FOR_EACH_LOOP(LI, LOOP, FLAGS) \ | |
| 614 for (fel_init (&(LI), &(LOOP), FLAGS); \ | |
| 615 (LOOP); \ | |
| 616 fel_next (&(LI), &(LOOP))) | |
| 617 | |
| 618 #define FOR_EACH_LOOP_BREAK(LI) \ | |
| 619 { \ | |
| 620 VEC_free (int, heap, (LI)->to_visit); \ | |
| 621 break; \ | |
| 622 } | |
| 623 | |
| 624 /* The properties of the target. */ | |
|
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
|
625 struct target_cfgloop { |
|
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
|
626 /* Number of available registers. */ |
|
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
|
627 unsigned x_target_avail_regs; |
| 0 | 628 |
|
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
|
629 /* Number of available registers that are call-clobbered. */ |
|
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
|
630 unsigned x_target_clobbered_regs; |
|
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
|
631 |
|
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
|
632 /* Number of registers reserved for temporary expressions. */ |
|
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
|
633 unsigned x_target_res_regs; |
|
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
|
634 |
|
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
|
635 /* The cost for register when there still is some reserve, but we are |
|
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
|
636 approaching the number of available registers. */ |
|
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
|
637 unsigned x_target_reg_cost[2]; |
|
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
|
638 |
|
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
|
639 /* The cost for register when we need to spill. */ |
|
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
|
640 unsigned x_target_spill_cost[2]; |
|
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
|
641 }; |
|
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
|
642 |
|
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
|
643 extern struct target_cfgloop default_target_cfgloop; |
|
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
|
644 #if SWITCHABLE_TARGET |
|
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
|
645 extern struct target_cfgloop *this_target_cfgloop; |
|
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
|
646 #else |
|
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
|
647 #define this_target_cfgloop (&default_target_cfgloop) |
|
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
|
648 #endif |
|
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
|
649 |
|
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
|
650 #define target_avail_regs \ |
|
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
|
651 (this_target_cfgloop->x_target_avail_regs) |
|
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
|
652 #define target_clobbered_regs \ |
|
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
|
653 (this_target_cfgloop->x_target_clobbered_regs) |
|
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
|
654 #define target_res_regs \ |
|
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
|
655 (this_target_cfgloop->x_target_res_regs) |
|
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
|
656 #define target_reg_cost \ |
|
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
|
657 (this_target_cfgloop->x_target_reg_cost) |
|
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
|
658 #define target_spill_cost \ |
|
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
|
659 (this_target_cfgloop->x_target_spill_cost) |
| 0 | 660 |
| 661 /* Register pressure estimation for induction variable optimizations & loop | |
| 662 invariant motion. */ | |
|
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
|
663 extern unsigned estimate_reg_pressure_cost (unsigned, unsigned, bool, bool); |
| 0 | 664 extern void init_set_costs (void); |
| 665 | |
| 666 /* Loop optimizer initialization. */ | |
| 667 extern void loop_optimizer_init (unsigned); | |
| 668 extern void loop_optimizer_finalize (void); | |
| 669 | |
| 670 /* Optimization passes. */ | |
| 671 extern void unswitch_loops (void); | |
| 672 | |
| 673 enum | |
| 674 { | |
| 675 UAP_PEEL = 1, /* Enables loop peeling. */ | |
| 676 UAP_UNROLL = 2, /* Enables unrolling of loops if it seems profitable. */ | |
| 677 UAP_UNROLL_ALL = 4 /* Enables unrolling of all loops. */ | |
| 678 }; | |
| 679 | |
| 680 extern void unroll_and_peel_loops (int); | |
| 681 extern void doloop_optimize_loops (void); | |
| 682 extern void move_loop_invariants (void); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
683 extern bool finite_loop_p (struct loop *); |
| 0 | 684 |
| 685 #endif /* GCC_CFGLOOP_H */ |